(Простые концепции 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;
}

(Вы можете просто вставить это прямо в компилятор)

Часть first моего ожидаемого выборочного вывода верна:

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'); появляется last , поэтому он уничтожается first , потому что деструкторы вызываются в обратном порядке их создания.

Но 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.

EDIT: Как уже упоминалось, порядок инициализации переменных со статической продолжительностью хранения является неопределенным, если переменные относятся к разным единицам перевода, но их можно определить, если они находятся в одной единице перевода.

Инициализация вызовами конструктора (как в этих примерах) называется dynamic initialization и

Динамическая инициализация нелокальной переменной со статическим хранилищем длительность либо упорядочена, либо неупорядочена . Определения явно члены статического класса шаблона специализированных классов заказали инициализация. Другие члены статических данных шаблона класса (т.е. неявно или явно созданные специализации) имеют неупорядоченные инициализация. Другие нелокальные переменные со статической продолжительностью хранения заказал инициализацию. Переменные с упорядоченной инициализацией определенный в пределах одной единицы перевода, инициализируется в порядок их определения в переводческой единице.

Это определяется реализацией, является ли динамическая инициализация нелокальная переменная со статической продолжительностью хранения выполняется до первое изложение основного. Если инициализация откладывается до некоторого момент времени после первого изложения основного, это должно произойти до первое использование odr (3.2) любой функции или переменной, определенной в та же единица перевода, что и для инициализируемой переменной.

Инициализация локальных статических переменных указывается как

... такая переменная инициализируется при первом прохождении контроля через его объявление; ...

А поскольку уничтожение переменных со статической продолжительностью хранения должно осуществляться в порядке, обратном их построению, то порядок построения и уничтожения переменных с типами Foo и Bar в этом примере фактически определен.

Опять же, когда у вас есть несколько переводов, вам лучше не полагаться на порядок инициализации.

Answer 2

См. эту запись C ++ FAQ , порядок инициализации статических объектов не определен. Не полагайтесь на это.