（简单 C++ 概念）构造函数/析构函数调用的意外输出

Question

给定以下代码：

#include <iostream>
using namespace std;

class Foo {
public:
    Foo ()          {   c = 'a'; cout << "Foo()" << endl;       }
    Foo (char ch)   {   c = ch; cout << "Foo(char)" << endl;    }
    ~Foo ()         {   cout << "~Foo()" << endl;               }

private:
    char c;
};

class Bar : public Foo {
public:
    Bar ()                      {   cout << "Bar()" << endl;    }
    Bar (char ch) : Foo(ch)     {   cout << "Bar(char)" << endl;    }
    ~Bar ()                     {   cout << "~Bar()" << endl;           }
};

Foo f1; static Bar b1;

int main()
{
    Bar b2;

    {
        static Foo f2('c');
        Foo f3;
        Bar b3 ('d');
    }

    return 0;
}

（您可以直接将其粘贴到编译器中）

我预期的示例输出的第一部分是正确的：

Foo()
Foo() 
Bar() 
Foo()
Bar()
Foo(char) 
Foo()
Foo(char)
Bar(char)
~Bar()
~Foo
~Foo()
~Bar()
~Foo()
~Foo()

但是我得到了两个静态的析构函数输出对象 static Bar b1; 和 static Foo f2('c'); 错误。

最后一部分的正确答案是：

~Bar()
~Foo()
~Foo()

我得到：

~Foo()
~Bar()
~Foo()

这是我的推理：

我明白所有本地对象都会在静态对象之前被破坏。剩下的两个静态对象中 static Bar b1; 和 static Foo f2('c');，static Foo f2('c'); > 出现在最后，因此它首先被析构，因为析构函数是按照其创建的相反顺序被调用的。

但 static Foo f2('c'); 并没有首先被破坏，static Bar b1; 才被破坏。为什么？

Answer 1

修改你的程序：

#include <iostream>
using namespace std;

class Foo {
public:
    Foo ()          {   c = 'a'; cout << "Foo()" << endl;       }
    Foo (char ch)   {   c = ch; cout << "Foo(char)" << ch << endl;    }
    ~Foo ()         {   cout << "~Foo()"<< c << endl;               }

protected:
    char c;
};

class Bar : public Foo {
public:
    Bar ()                      {   cout << "Bar()" << endl;    }
    Bar (char ch) : Foo(ch)     {   cout << "Bar(char)" << ch << endl;    }
    ~Bar ()                     {   cout << "~Bar()" << c << endl;           }
};

Foo f1('a'); static Bar b1('b');

int main()
{
    Bar b2('c');

    {
        static Foo f2('d');
        Foo f3('e');
        Bar b3 ('f');
    }

    return 0;
}

在 g++ 4.5.2 中生成以下输出：

Foo(char)a
Foo(char)b
Bar(char)b
Foo(char)c
Bar(char)c
Foo(char)d
Foo(char)e
Foo(char)f
Bar(char)f
~Bar()f
~Foo()f
~Foo()e
~Bar()c
~Foo()c
~Foo()d
~Bar()b
~Foo()b
~Foo()a

你看到最后一个被破坏的是非静态全局变量 Foo f1。

编辑：
正如其他人提到的，如果变量来自不同的翻译单元，则具有静态存储持续时间的变量的初始化顺序是不确定的，但当它们位于同一翻译单元中时可以定义它们。

通过构造函数调用进行的初始化（如本示例中所示）称为动态初始化，并且

动态初始化具有静态存储的非局部变量
持续时间可以是有序的，也可以是无序的。明确的定义
专门的类模板静态数据成员已订购
初始化。其他类模板静态数据成员（即
隐式或显式实例化的专业化）具有无序
初始化。 其他具有静态存储期限的非局部变量
已命令初始化。具有有序初始化的变量
在单个翻译单元中定义的应在
它们在翻译单元中的定义顺序。

是否动态初始化 a 是由实现定义的
具有静态存储持续时间的非局部变量在
main 的第一个语句。如果初始化被推迟到某个时间
main 的第一个语句之后的时间点，它应发生在
中定义的任何函数或变量的第一个 odr-use (3.2)
与要初始化的变量相同的翻译单元。

局部静态变量的初始化指定为

...这样的变量
控件第一次通过其声明时被初始化； ...

并且由于具有静态存储持续时间的变量的销毁应该按照其构造的相反顺序，因此类型为 Foo 和 Bar 在这个例子中实际上已经定义了。

再次强调，当你有多个翻译时，你最好不要依赖初始化的顺序。

Answer 2

请参阅此 C++ FAQ 条目，静态的初始化顺序对象未定义。 不要依赖它。