模仿C++中的静态构造函数

Question

这是一个与 C++ 中对象的初始化相关的问题。

我有一组类（不是实例），继承自一个公共基类，并且我需要它们在程序启动时在容器（特别是映射）中注册有关自身的信息。

问题是我需要它是动态的。容器是在独立的项目中定义的，与类不同。我宁愿避免制作该库的多个硬编码版本，每个版本用于使用该库的每个程序中的每一组类。

我考虑过在每个子类中都有一个特殊类的静态实例，这将在其构造函数中进行注册。但是，我没有找到任何方法来保证容器将在这些对象的构造之前被构造。

我还应该注意，在创建这些子类的任何实例之前，容器中有关子类的信息应该可用。

有没有办法做到这一点，或者模仿 C++ 中的静态构造函数？

Answer 1

您同时描述了不同的问题。对于某种静态初始化的特定问题，一种简单的方法是创建一个将执行注册的伪类。那么每个不同的类都可以有一个 static const X 成员，该成员必须在翻译单元中定义，并且定义将触发实例的实例化和类的注册。

这并没有解决初始化订单惨败这一难题。该语言不对不同翻译单元中对象的初始化顺序提供任何保证。也就是说，如果您使用此类类编译三个翻译单元，则无法保证假成员的相对执行顺序。这也适用于库：如果您要在其中注册类的容器是全局/静态成员属性，则无法保证该容器已被初始化。

如果您有权访问代码，则可以修改容器代码以使用静态局部变量，这将在确保初始化顺序方面向前迈出一步。作为可能的解决方案的草图：

// registry lib
class registry { // basically a singleton
public:
   static registry& instance() { // ensures initialization in the first call
      static registry inst;
       return inst;
   }
// rest of the code
private:
   registry(); // disable other code from constructing elements of this type
};
// register.h
struct register {
   template <typename T>
   register( std::string name ) {
       registry::instance().register( name, T (*factory)() ); // or whatever you need to register
   }
};
// a.h
class a {
public:
   static a* factory();
private:
   static const register r;
};
// a.cpp
const register a::r( "class a", a::factory );
// b.h/b.cpp similar to a.h/a.cpp

现在在这种情况下，a 和 b 类的注册之间没有明确的顺序，但这可能不是问题。另一方面，通过在 registry::instance 函数中使用局部静态变量，可以保证单例的初始化在之前执行对 registry::register 方法的任何调用（作为第一次调用 instance 方法的一部分）。

如果您无法进行此更改，那么您基本上就不走运，并且无法保证注册表将在其他翻译单元中的其他静态成员属性（或全局变量）之前实例化。如果是这种情况，那么您必须将类的注册推迟到第一次实例化，并向每个要注册的类的构造函数添加代码，以确保该类在实际注册之前注册。对象的构造。

这可能是也不是一个解决方案，具体取决于其他代码是否创建该类型的对象。在工厂函数的特殊情况下（第一个想到的），如果没有其他方法允许创建 a 或 b 类型的对象...那么小猪支持注册构造函数调用也不是解决方案。

Answer 2

这是单例模式的候选者。基本上，您希望在实例化子类的第一个实例时实例化容器。这可以通过检查基类构造函数中的单例指针是否为 NULL 来实现，如果是，则实例化容器。

Answer 3

一种想法是将注册函子传递给类。每个后代都会执行要注册的函数。该函子可以在构造函数中传递。

例子：

struct Registration_Interface
{
  virtual void operator() (const std::string& component_name) = 0;
};

struct Base
{
};

struct Child1
  : public Base
{
  Child(Registration_Interface& registration_ftor)
  {
     //...
     registration_ftor("Child1");
  }
};

Answer 4

请参阅：http://www.parashift.com/c++-faq -lite/ctors.html#faq-10.14

一个选择是在添加第一件事时延迟构造容器：

  void AddToContainer(...) {
    // Will be initialized the first time this function is called.
    static Container* c = new Container();
    c->Add(...);
  }

“模仿”静态构造函数的唯一方法是显式调用函数来执行你的静态初始化。没有其他方法可以仅通过链接到模块来运行主程序前的代码。

Answer 5

您可以使用“首次使用时初始化”模式，然后实例化一个虚拟静态实例以确保尽早初始化。

class cExample
{
    public :
       cExample() ;

       // Static functions here

    private :
        static bool static_init ;

        // other static members here
}

cExample::static init = false ;

cExample::cExample()
{
    // Static initialisation on first use
    if( !static_init )
    {
        // initialise static members
    }

    // Instance initialisation here (if needed)
}

// Dummy instance to force initialisation before main() (if necessary)
static cExample force_init ;

Answer 6

这是违反 OOP 范式的，但是让你的静态成员形成一个由 2 个全局变量引导的链表怎么样？你可以这样做：

ClassRegistrator *head = nullptr;
ClassRegistrator *tail = nullptr;

struct ClassRegistrator {
    // ... Data that you need
    ClassRegistrator *next;
    ClassRegistrator(classData ...) {
      if (!head) 
          head = tail = this;
      else {
        tail->next = this;
        tail = this;
      }
      // ... Do other stuff that you need for registration
    }
};

// The class you want to register
class MyClass { 
    static ClassRegistrator registrator;
}

ClassRegistrator MyClass::registrator(...); // Call the constructor

我相信全局变量，因为它们不需要构造函数，而只是纯数据，保证在您开始执行您的代码。

显然这不是线程安全的等，但应该可以完成你的工作。