如何在 C++03 中伪造构造函数继承？

Question

据我所知，您不能在 C++ 中继承构造函数。但是在某些情况下，您可能需要看起来像实例化继承类的方式与实例化它们的基类一样：

struct Base {
  int i;
  int const j;
  Base(int i, int j) : i(i), j(j) {}
};

// option 1)
struct Derived1 : Base {
  Derived1(int i, int j) : Base(i,j) {}
};
Base* baseFactory() {
  return new Derived1(42,47);
}

// option 2)
struct Derived2 : Base {
};
Base* baseFactory() {
  Base* b = new Derived2();
  b->i = 42;
  b->j = 47; // broken!
  // alternative could be to implement Base::operator=
  return b;
}

请注意，如果不是为它们的基类，派生类可能是默认构造的。

我认为选项 1 是通常所做的，但您输入的代码没有表达任何新内容。选项 2 破坏了 const 的正确性（并阻止您将引用用作成员），因为所有内容都必须是可分配的。

有什么好的办法吗？

编辑：C++11 很棒，但不幸的是我需要 C++03 解决方案。

Answer 1

选项 1 是 C++03 中的惯用方式，它确实需要更多的输入，但语言就是这样。选项 2 甚至不接近等效项，您将无法初始化 Derived2，因为 Base 没有默认构造函数，并且 隐式声明 Derived2 的默认构造函数的定义需要它。

但是除了语言的技术难度之外，您正在用 construction 换取 two-phase construction 这绝不是一个好主意，同时迫使您使用Derived2 动态分配的对象。

Answer 2

还有一种替代方法：

// option 3)
struct Derived3 : Base {
  Derived3(const Base &b) : Base(b) {}
};
Base* baseFactory3() {
    return new Derived3(Base(42,47));
}

如果构建一个完整的 Base 对象很昂贵或需要外部资源，这可能不是一个好主意。在这种情况下，您可以创建一个轻量级对象，该对象带有 Base 的构造函数参数，这样您就有多个 BaseArguments 构造函数和一个接收 BaseArguments 的 Base 构造函数，而不是多个 Base 构造函数。但是，我认为在大多数情况下不会有很多人会考虑这种好的风格。

Answer 3

C++11 支持继承的构造函数。

http://en.wikipedia.org/wiki/C%2B%2B11

然而，并非所有现在支持 C++11 子集的编译器都支持所有功能。

Microsoft Visual C++ 2010 支持几个新的 C++0x 功能，但不支持继承的构造函数，这里是一个列表：http://blogs.msdn.com/b/vcblog/archive/2010/04/06/c-0x-core-language-features-in-vc10-the-table.aspx

GCC 支持更多新功能，但不支持继承的构造函数。见http://gcc.gnu.org/projects/cxx0x.html

要使 GCC 能够使用 C++0x 功能进行编译，您需要添加 -std=c++0x 或 -std=gnu++0x 编译参数。 Visual C++ 2010 默认启用这些。

你只需要等待:)

对于以前版本的标准没有干净的解决方案，因此它是在 C++11 中引入的，因为它不可能与以前的版本一起使用。 所以，你唯一能做的就是复制你的构造函数并调用基构造函数。

Answer 4

这里是 Builder Pattern 的一个变体，我一直认为它可能很有用，但我从未真正有机会使用它；我想您可以将其称为构造函数模式。 :P

它还提供了一些其他优点，例如不必按特定顺序指定参数：您只需指定您感兴趣的内容以及您想要的任何顺序。

我仍然认为只有当你的类有很多具有不同参数的构造函数时这是合理的。否则，这只是一个烦恼。

class Person
{
  public:
    class Constructor;
};

class Person::Constructor
{
  public:
    Constructor& name(const std::string&);
    Constructor& age(int);
    Person* make();
};

Person* pers = Person::Constructor()
    .name("Bob Marley").make();


class Employee : public Person
{
  public:
    class Constructor;
};

class Employee::Constructor : public Person::Constructor
{
  public:
    Constructor& salary(double);
    Employee* make();
};

Employee* emp = Employee::Constructor()
    .name("Emilly Smith").age(23).make();

但同样，只有当你的类有很多带有很多参数的构造函数并且你想避免为它们编写多个重载时，这才是合理的；否则，这只会​​增加太多复杂性而没有任何实际好处。

我提到我不喜欢 han 提出的解决方案。这是因为（1）您将需要（重新）声明子类中的许多构造函数，以需要在工厂类中放置相同数量的函数； （2）它是hacky并且意图不明确； (3) 你可以认为这违反了依赖注入。