全球 C++对象初始化

Question

许多 C++ 程序员都遭受过与全局 C++ 对象初始化/清理的激烈冲突。最终我找到了一个足够好的解决方案来解决这个问题，我已经使用（并且享受）它很多年了。我的问题是：这个解决方案是否完全符合 C++ 标准，还是“依赖于平台/实现”？

问题

一般来说，全局对象有两个主要问题：

• 不可预测的构建/销毁顺序。如果这些对象相互依赖，就会产生影响。
• 构造/销毁代码在 CRT 初始化/清理期间在主程序入口点外部执行。无法使用 try/catch 包装此代码，或执行任何初步初始化。

克服这些问题的一种方法是根本不使用全局对象。相反，人们可以使用指向这些对象的静态/全局指针。在程序初始化期间，这些对象要么动态分配，要么实例化为入口点函数 (main) 中的自动变量，并且它们的指针存储在这些指针中。通过这种方式，您可以完全控制“全局”对象的生命周期。

然而这种方法也有一些缺点。这与以下事实有关：不仅这些对象的创建/销毁不同，而且它们的访问也不同。通常，全局对象驻留在由加载器分配的数据部分中，并且其虚拟地址在构建时已知。使用全局指针会导致以下缺点：

• 对象访问速度稍慢，额外的指针取消引用。在运行时期间，编译器不会假设对象位于指定地址，而是生成取消引用全局指针的代码。
• 优化较弱。编译器可能没有意识到指针总是指向同一个对象。
• 如果实际对象分配在堆上：
• • 性能较差（堆分配“繁重”）
• • 内存碎片
• • 可能出现内存不足异常
• 如果实际对象分配在堆栈上（main 中的自动变量）：
• • 堆栈大小通常是有限的。在某些情况下，“胖”物体对它的消耗不是最理想的。

解决方案

我找到的解决方案是覆盖对象的 new/delete 运算符。

// class definition
class MyObject
{
    // some members
    // ...

    static char s_pMyPlaceholder[];

public:

    // methods
    // ...

    static MyObject& Instance()
    {
        return *(MyObject*) s_pMyPlaceholder;
    }

    void* operator new (size_t) { return s_pMyPlaceholder; }
    void operator delete (void*) {}
};

// object placeholder instantiated
char MyObject::s_pMyPlaceholder[sizeof(MyObject)];

void main()
{
    // global initialization
    std::auto_ptr<MyObject> pMyObj(new MyObject);

    // run the program
    // ...

}

技巧是在全局内存中分配足够的空间（通过声明足够大小的全局数组），然后为所需的对象使用虚构的内存分配，这将“分配”这个全局内存”。通过这样，我们实现了以下目标：

• 从语义上讲，我们动态分配对象，因此我们可以完全控制
• 对象的生命周期。因此，与“指针方式”方法相关的所有缺点都不适用于。我们的案例。
• 该对象在程序中的任何地方都是可见的。顺便说一句，这个函数调用很容易被编译器内联，

因此一切看起来都很好。我只是好奇从 C++ 标准的角度来看它是否合法。

Answer 1

我认为这有两个问题，一是合法性问题，一是可用性问题。

第一个问题是对齐：不保证 MyObject::s_pMyPlaceholder 能够适当对齐以容纳 MyObject。

第二个问题是您将自己限制为 MyObject 类型的单个对象。创建第二个，您就覆盖了第一个，没有任何警告。

我建议使用 boost::Optional 来延迟对象的初始化。

Answer 2

我认为您没有正式保证您的解决方案适用于每个兼容的实现，因为 C++ 标准不保证静态分配的 char 数组按照任何相同大小的对象所需的方式对齐。

Answer 3

从 3.7.3.1（分配函数，[basic.stc.dynamic.allocation]）（ISO/IEC 14882/2003）：

2/ [...] 返回的指针应适当对齐，以便可以
转换为任何完整对象类型的指针，然后用于
访问分配的存储中的对象或数组（直到存储
通过调用相应的释放来显式释放
函数）。

我的疑问是，您无法保证 s_MyPlaceHolder[0] 的地址正确对齐。

我没有看到任何不好的事情（在单线程环境中）：

#include <cstdlib>

class MyObject
{
    static MyObject* instance;

    static void release_instance() { delete instance; }

public:
    static MyObject& get_instance()
    {
        if (!instance) 
        {
            instance = new MyObject();
            std::atexit(&release_instance);
        }

        return *instance;
    }
};

除了单例和全局变量通常是一个糟糕的主意（它们倾向于将您的代码与此类对象的存在结合起来，从而加强代码各部分之间的耦合）。

由于您对控制对象的生命周期感兴趣，因此可以使用 RAII：

class MyObject
{
    MyObject() { ... }
    ~MyObject() { ... }

    // Never defined
    MyObject(const MyObject&);
    void operator=(const MyObject&);


    static MyObject* instance = 0;
    static void create_instance()
    {
        if (instance) throw std::logic_error("Instance already created");
        else instance = new MyObject();
    }

    static void release_instance() { delete instance; }

public:
    struct InstanceKeeper
    {
        InstanceKeeper(InstanceKeeper& x) : must_clean(x.must_clean)
        { x.must_clean = false; }

        ~InstanceKeeper() { if (must_clean) release_instance(); }

    private:
        friend class MyObject;
        InstanceKeeper() : must_clean(true) { create_instance(); }  

        bool must_clean;
    };

    friend struct InstanceKeeper;
    static InstanceKeeper instance_keeper() { return InstanceKeeper(); }  

    static MyObject& instance()
    {
        if (!instance) throw std::logic_error("Instance not created");
        return *instance;
    }
};

用法：

int main()
{ 
    MyObject::InstanceKeeper k = MyObject::instance_keeper();

    MyObject::instance().do_something();
    ...

}

您甚至可以将 InstanceKeeper 对象传递给函数，它与 std:: 具有相同的行为auto_ptr。

您可能遇到的任何性能问题都是过早优化的情况。