Question

我可以控制静态对象被破坏的顺序吗？有没有办法强制执行我想要的订单？例如，以某种方式指定我想要最后销毁某个对象，或者至少在另一个静态对象之后销毁？

Answer 1

静态对象以与构造相反的顺序被破坏。施工顺序很难控制。您唯一可以确定的是，将按照定义的顺序构造在同一编译单元中定义的两个对象。其他任何东西都或多或少是随机的。

Answer 2

其他答案坚持认为无法做到。根据规范，他们是对的 - 但是是一个可以让你做到的技巧。

只创建一个单个静态变量，包含通常会创建静态变量的所有其他内容的类或结构，如下所示：

class StaticVariables {
    public:
    StaticVariables(): pvar1(new Var1Type), pvar2(new Var2Type) { };
    ~StaticVariables();

    Var1Type *pvar1;
    Var2Type *pvar2;
};

static StaticVariables svars;

您可以按照您需要的顺序创建变量，更重要的是，在StaticVariables的构造函数和析构函数中以您需要的顺序销毁它们。为了使其完全透明，您也可以创建对变量的静态引用，如下所示：

static Var1Type &var1(*svars.var1);

Voilà - 完全控制。 :-)那就是说，这是额外的工作，而且通常是不必要的。但是当必要时，知道它是非常有用的。

Answer 3

简短回答：一般来说，没有。

稍微长一点的答案：对于单个翻译单元中的全局静态对象，初始化顺序是从上到下，销毁顺序完全相反。几个翻译单元之间的顺序未定义。

如果您确实需要特定订单，则需要自己完成此操作。

Answer 4

静态对象的破坏顺序与它们构造的顺序相反（例如，最后构造的对象最后被破坏），并且您可以通过使用上面描述的技术来控制构造静态对象的顺序。在Meyers的书 Effective C ++ 中，第47项“确保全局对象在使用前初始化”。

例如，以某种方式指定我希望某个对象最后被销毁，或者至少在另一个静态注入之后销毁？

确保它在另一个静态对象之前构建。

如何控制施工顺序？并非所有的静力学都在同一个dll中。

我会忽略（为简单起见）它们不在同一个DLL中的事实。

我对Meyers第47项（长4页）的解释如下。假设你的全局是在像这样的头文件中定义的......

//GlobalA.h
extern GlobalA globalA; //declare a global

...在包含这样的文件中添加一些代码...

//GlobalA.h
extern GlobalA globalA; //declare a global
class InitA
{
  static int refCount;
public:
  InitA();
  ~InitA();
};
static InitA initA;

这样做的结果是包含GlobalA.h的任何文件（例如，定义第二个全局变量的GlobalB.cpp源文件）将定义InitA类的静态实例，该实例将在任何内容之前构造在该源文件中的其他内容（例如，在您的第二个全局变量之前）。

此InitA类具有静态引用计数器。当构造第一个InitA实例时，现在保证在构造GlobalB实例之前，InitA构造函数可以做任何事情来确保初始化globalA实例。

Answer 5

Theres没有办法在标准C ++中这样做，但是如果你对你的特定编译器内部有一个很好的工作知识，那么很可能就可以实现。

在Visual C ++中，指向静态init函数的指针位于.CRT$XI段（对于C类型的静态init）或.CRT$XC段（对于C ++类型的静态init）链接器收集所有声明和按字母顺序合并它们。您可以使用

通过在适当的段中声明对象来控制静态初始化的发生顺序

#pragma init_seg

例如，如果您希望在文件B之前创建文件A的对象：

文件A.cpp：

#pragma init_seg(".CRT$XCB")
class A{}A;

文件B.cpp：

#pragma init_seg(".CRT$XCC")
class B{}B;

.CRT$XCB在.CRT$XCC之前合并。当CRT遍历静态init函数指针时，它将在文件B之前遇到文件A.

在Watcom中，该段是XI，＃pragma initialize的变体可以控制构造：

#pragma initialize before library
#pragma initialize after library
#pragma initialize before user

...请参阅文档了解更多

Answer 6

读：
SO Initialization Order

SO Solving the Order of Initialization Problem

Answer 7

不，你不能。你永远不应该依赖于构造/破坏静态对象的其他东西。

您始终可以使用单身人士来控制全球资源的构建/销毁顺序。

Answer 8

你真的需要在main之前初始化变量吗？

如果您不能使用简单的习惯用法轻松实际控制构造和破坏的顺序，请参阅此处：

#include <cassert>

class single {
    static single* instance;

public:
    static single& get_instance() {
        assert(instance != 0);
        return *instance;
    }

    single()
    // :  normal constructor here
    {
        assert(instance == 0);
        instance = this;
    }

    ~single() {
        // normal destructor here
        instance = 0;
    }
};
single* single::instance = 0;

int real_main(int argc, char** argv) {
    //real program here...

    //everywhere you need
    single::get_instance();
    return 0;
}

int main(int argc, char** argv) {
    single a;
    // other classes made with the same pattern
    // since they are auto variables the order of construction
    // and destruction is well defined.
    return real_main(argc, argv);
}

它并不会阻止您实际尝试创建该类的第二个实例，但如果您这样做，则断言将失败。根据我的经验，它运作良好。

Answer 9

您可以通过static std::optional<T>代替T来有效实现类似的功能。只需对变量进行初始化，使用间接并通过分配std::nullopt（或者，对于boost，boost::none）来销毁它。

它与指针的不同之处在于它具有预先分配的内存，这就是我猜你想要的内容。因此，如果你摧毁它＆amp; （也许很久以后）重新创建它，你的对象将具有相同的地址（你可以保留），并且你当时不需要支付动态分配/解除分配的费用。

如果您没有boost::optional<T> / std::，请使用std::experimental::。

C ++中静态对象的破坏顺序

9 个答案: