C++ 中静态对象的销毁顺序

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

静态对象的销毁顺序与它们的构造顺序相反（例如，第一个构造的对象最后被销毁），并且您可以使用条款 47 中描述的技术来控制静态对象的构造顺序， Meyers 的《Effective C++》一书中“确保全局对象在使用前已初始化”。

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

确保它是在其他静态对象之前构造的。

如何控制施工顺序？ 并非所有静态数据都在同一个 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 4

简短回答：一般来说，不会。

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

如果您确实需要特定的订单，则需要自己制作。

Answer 5

阅读：
SO 初始化顺序

SO 解决初始化顺序问题

Answer 6

在标准 C++ 中无法做到这一点，但如果您对特定编译器内部结构有很好的了解，那么它可能是可以实现的。

在 Visual C++ 中，指向静态初始化函数的指针位于 .CRT$XI 段（对于 C 类型静态初始化）或 .CRT$XC 段（对于 C++ 类型） static 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 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 来有效地实现类似的功能。 只需像使用变量一样初始化它，使用间接方法并通过分配 std::nullopt 来销毁它（或者，对于 boost，则为 boost::none ）。

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

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