在c++中模拟虚拟构造函数

Question

在我的应用程序中，我必须从基类派生一些类，问题是我想强制派生类具有 3 个特定的构造函数实现。由于 c++ 没有虚拟纯构造函数，它看起来非常绝望（我必须手动检查每个类的实现以确保特定的构造函数被实现，这不是很有趣）。

昨天我发现了一种疯狂的方法来模拟虚拟演员的行为：

template <class T>
class AbstractEnforcer{
  protected:
    AbstractEnforcer(){}
  private:
    static void Enforcer(){
      delete new T();
      delete new T(*(new unsigned int));
      delete new T(*(new unsigned int, *(new QString));
    }
  }

class AbstractClass : private AbstractEnforcer<AbstractClass>{

}

这种方法的唯一不便之处在于我必须使用以下语法声明所有派生类：

class X : private AbstractEnforcer<X>

即使这不是问题；因为 Enforcer() 方法永远不会被调用（即使如此它也不会执行任何操作[希望如此！！！]）

我的问题是： “是否有任何方法（不使用宏）强制派生类使用此机制而不对 AbstractClass 进行参数化（因为这仅在一个派生级别中起作用”

template <class T>
class AbstractClass : private AbstractEnforcer<T>{

}

Answer 1

您的解决方案无法解决问题，因为未实例化未使用的模板化代码，因此除非您手动调用此函数，否则它将不会验证所需构造函数的存在。

您可以做的是从执行器的构造函数中调用此方法：

template <class T>
class AbstractEnforcer{
    protected:
        AbstractEnforcer(){ Enforcer(); }
    private:
        static void Enforcer(){
            delete new T();
            delete new T(*(new unsigned int));
            delete new T(*(new unsigned int, *(new QString)));
        }
        // disable:
        AbstractEnforcer (const AbstractEnforcer &enf);
};

class AbstractClass : private AbstractEnforcer<AbstractClass>{

};

int main () {
    AbstractClass c;
}

然后，编译器会抱怨 - 任务完成。

请注意，我已禁用复制构造函数，以便无法绕过该检查（通过调用不同的构造函数）。

编辑 - 非泄漏 Enforcer()：[因为绝对不需要在那里使用动态分配..]

        static void Enforcer(){
            T t1();
            T t2(int(3));
            T t3(int(4), QString());
        }

Answer 2

请参阅 C++ 常见问题解答中的此页面。

我要做的是这样的：

class AbstractClass {
    public:
        virtual AbstractClass* create() const = 0;
        virtual AbstractClass* create(unsigned int) const = 0;
        virtual AbstractClass* create(unsigned int, QString) const = 0;
};

然后每个派生类将被迫重写这些函数，这应该使用不同的构造函数创建新对象。

Answer 3

从这个评论到一个答案，我认为你并不是真的想实现你在这里所要求的，而是一件不同的事情。我参考的评论是：

第1部分：

我知道我们不能有虚拟的
构造函数，我不想有
一、我的目的是编译器
静态代码检查会发出警报
如果我忘记实施特定的
构造函数原型。

第 2 部分：

我的项目是
像动态加载系统这样的插件和
我以某种方式强制执行演员
第三个的原型实现
政党代码。

您在问题中要求的是 1，您可以通过不同的方式强制执行它，只需阅读一些答案，或者查看元编程示例和 boost::type_traits 库。

现在，如果您真正想要的是第 2 部分：提供动态加载插件机制，那么您不需要强制执行构造函数，而是需要为插件对象和插件对象的创建提供一个通用接口。无法实例化未知（在编译时）对象的实例，这意味着您将无法从代码中调用构造函数。我建议

// Interface:
class plugin {
public:
   virtual void operation() = 0;
};
class plugin_factory {
public:
   virtual plugin* create() = 0;
   virtual plugin* create( unsigned int ) = 0;
   virtual plugin* create( unsigned int, QString const & ) = 0;
};

用户需要提供插件的实现以及创建它们的工厂。他们可能需要为他们的库实现一个入口点，以便您可以访问工厂（或者他们可以在您的系统中注册他们的工厂，否则我建议使用库来实现这些目的（boost::extension似乎是一个值得一看的地方）

Answer 4

我可能只是有一个用于生成测试的模板：

template <typename T>
void enforceConstructors() {
    T t1;
    T t2(0);
    QString q;
    T t3(0, q);
}

然后在测试中的某个地方执行以下操作：

enforceConstructors<X>();
enforceConstructors<Y>();
enforceConstructors<Z>();

这些可能全部放在一起，也可能位于每个类 X、Y、Z 的单独位置。取决于您想要如何组织测试。

如果我使用的值不合适，请输入一些合适的值，或者编译该测试但不运行它。如果您没有单元测试，请获取一些单元测试，或者将以下内容添加到类中（而不是从基类继承）：

#ifndef NDEBUG
    static void test() { enforceConstructors<X>(); }
#endif

通常不需要使构造函数成为抽象基类定义的接口的一部分。原因是这样的接口用于动态多态性 - 您将一个对象传递给某个函数，然后它调用它的函数。除了使用模板之外，您不能将类“传递”给函数并让它实例化该类。无论如何，模板大多在编译时强制执行它们的接口 - 如果您实例化模板并且它使用构造函数，那么构造函数必须存在。

Answer 5

如果您忘记实现构造函数但在代码中使用它，则会出现编译错误。例如：

Base * p = new Derived( 42 );

如果未提供 Derived(int) 构造函数，将出现编译时错误 - 将不会使用 Base 构造函数。

Answer 6

我最终采用了这个解决方案，但没有放弃：

#ifdef NDEBUG

#ifndef ENFORCE_CTORS
#define ENFORCE_CTORS(enforcingTemplate, enforcedClass) \
  friend void enforcingCtors(){static enforcingTemplate<enforcedClass> _enforcer;}
#endif


template<class T>
      class AbstractEnforcer : T{
        public:
          explicit AbstractEnforcer(){
            T enforcedCtor0(                                     );
            T enforcedCtor1( *(new unsigned int)                 );
            T enforcedCtor2( *(new unsigned int), *(new QString) );
            T enforcedCtor3( *(new unsigned int), *(new float  ) );
          }
      };
#endif

在每个我不想强制执行的类中，我只是添加这样的内容：

class X{
  ENFORCE_CTORS(AbstractEnforcer, X);
  /*
    .....
  */
}

我没有找到任何其他方法来在类中动态注入此代码。而且我可能不清楚这次行动的最终目的（抱歉我的英语很糟糕）。