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中的事实。

我对迈耶斯项目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

在标准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初始化顺序

SO解决初始化问题的顺序

Answer 7

您真的需要在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 8

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

它与具有指针的不同之处在于它具有预分配的内存，我想这就是您想要的。 因此，如果销毁它并（可能以后再重新创建）它，则对象将具有相同的地址（可以保留），并且此时您无需支付动态分配/取消分配的费用。

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

Answer 9

不，你不能。 您永远不应依赖于静态对象的构造/破坏。

您始终可以使用单例来控制构建/销毁全局资源的顺序。