C++标准中最令人惊讶的元素是什么?

几个声明者的顺序实际上是无序的:

volatile long int const long extern unsigned x;

是一样的

extern const volatile unsigned long long int x;

我觉得有点惊讶

class aclass
{
public:
int a;
};

some_function(aclass());

将有 a 初始化为 0 在里面 some_function ,同时

aclass ac;
some_function(ac);

将使其统一。 如果显式定义的默认构造函数 aclass :

class aclass
{
public:
aclass(): a() {}
int a;
};

然后 aclass ac; 也将初始化 一 到 0 .

我可以补充的另一个答案是 throw() 限定符。例如:

void dosomething() throw()
{
   // ....
}

void doSomethingElse() throw(std::exception)
{
  // ....
}

从直观上看,这似乎是与编译器的约定,表明除了列出的异常之外,不允许此函数抛出任何异常。但实际上,这在编译时什么也不做。相反,它是一个运行时机制,它不会阻止函数实际抛出异常。更糟糕的是,如果抛出了未列出的异常,它将通过调用 std::terminate() .

考虑到C++通常是多么的不可原谅,我觉得这个标准实际上让你有点惊讶。 delete 空指针。

对象在构造期间更改类型。

尤其是,当从构造函数调用虚函数时,您将 不 正在调用最派生的重写。相反,您是从 目前 构建。如果这个实现碰巧是 0 (纯虚拟函数),您的程序将在运行时崩溃。

半现实世界的例子:

class AbstractBase {
  public:
    AbstractBase() {
      log << "Creating " << className() << endl;
    }
  protected:
    virtual string className() const = 0;
}

class ConcreteGuy {
  protected:
    virtual string className() const { return "ConcreteGuy"; }
}

在构造 ConcreteGuy 对象,程序将以“调用纯虚拟函数”错误消息终止。

这就是为什么从构造函数调用虚拟函数被认为是有害的。

众所周知,数组发起程序可能会像枚举定义中那样跳入索引。

// initializing an array of int
int a[ 7] = { [5]=1, [2]=3, 2};
// resulting in
int a[ 7] = { 0, 0, 3, 2, 0, 1, 0};

// initializing an array of struct
struct { int x,y; } ar[ 4] = { [1].x=23, [3].y=34, [1].y=-1, [1].x=12};
// resulting in
struct { int x,y; } ar[ 4] = { { 0, 0}, { 12, -1}, { 0, 0}, { 0, 34}};

// interesting usage
char forbidden[ 256] = { ['a']=1, ['e']=1, ['i']=1, ['o']=1, ['u']=1};

大部分 these 也适用于C++。

在C++语句中评估某事…

int main()
{
    "This is a valid C++ program!"
    "I will list the first five primes:";
    2;
    3;
    5;
    7;
    11;
}