C ++ 11构造函数继承和纯虚方法

Question

注意：不是C ++ 11委托构造函数的重复纯虚拟方法和函数调用 - 危险？ 。 这个问题涉及一个概念上类似的问题，并没有真正为这种情况提供解决方案。

考虑以下程序：

#include <iostream>
using std::cout;
using std::endl;

class Base {
    virtual void init() = 0; // a hook function
  public:
    Base(int a, int b) { /* ... */  init(); }
    Base(char a, int b) { /* ... */  init(); }
    Base(char a, int b, double* c) { /* ... */  init(); }
    /* etc.  Dozens of constructors */
};    

class Derived1 : public Base {    
    void init() { cout << "In Derived1::init()" << endl; }    
  public:    
    using Base::Base;    
};      

class Derived2 : public Base {    
    void init() { cout << "In Derived2::init()" << endl; }    
  public:    
    using Base::Base;    
};    

int main() {
  Derived1 d1(1, 2);
  Derived2 d2('a', 3);
  return 0;
}

这段代码显然没有运行（虽然它在某些编译器上编译时会出现警告）。 问题是，实现这种模式的最佳方法是什么？ 假设Base中有许多派生类和几十个构造函数，在派生类中重新实现Base构造函数（在派生构造函数的主体中调用base构造函数和init（））并不是很理想。

Answer 1

该代码需要在派生类构造函数中运行，直到对象具有派生类型才能运行。

但您可以使用完美转发一次将其添加到所有构造函数：

class Derived1 : public Base
{
public:
    template<typename... T>
    explicit Derived1(T&&... t) : Base(std::forward<T>(t)...) {
      std::cout << "Derived1::init logic goes here" << endl;
    }
};

Answer 2

另一种方法是'命名'构造函数：

#include <iostream>

class Base
{
    public:
    template <typename Derived>
    static Derived construct() {
        Derived derived;
        derived.hello();
        return derived;
    }

    protected:
    Base() {};

    public:
    virtual ~Base() {};

    public:
    virtual void hello() = 0;
};

class Derived : public Base
{
    public:
    virtual void hello() {
        std::cout << "Hello\n";
    }
};

int main ()
{
    Derived d = Base::construct<Derived>();
}

Answer 3

为那些在创建对象后调用init()类创建特殊工厂