稍后在 C++ 中调用基类构造函数（不在初始值设定项列表中）

Question

我正在继承一个类，我想调用它的构造函数之一。但是，在调用它之前，我必须处理一些内容（不需要基类的任何内容）。有什么方法可以稍后调用它，而不是在初始化列表上调用它？我相信这可以在 Java 和 C# 中完成，但我不确定 C++ 是否可以。

我需要传递给构造函数的数据以后无法重新分配，因此我不能只调用默认构造函数并稍后对其进行初始化。

Answer 1

根据 @Konrad 的建议，另一种选择是使用静态方法来构造对象，例如：

class Derived {
public:
    Derived(int p1, int p2, int p3) : Base(p1, p2) { }

    static Derived* CreateDerived(int p3) { return new Derived(42, 314, p3); }
};

我发现这在从库扩展类并具有多个要覆盖的参数时很有用。
您甚至可以将构造函数设置为私有

Answer 2

struct base{
   base(int x){}
};

struct derived : base{
   derived(int x) : base(x){}
};

这就是 C++ 中从派生类的初始化列表调用基类构造函数的方式。

Answer 3

有什么方法可以让我稍后调用它，而不是在初始值设定项列表上调用它？

不，你不能。基类构造函数必须在初始化列表中调用，并且必须首先调用。

事实上，如果您省略它，编译器只会隐式添加调用。

我相信这可以在 Java 和 C# 中完成，但我不确定 C++。

C# 和 Java 都不允许这样做。

然而，您可以做的是调用一个方法作为基类构造函数调用的参数。然后在构造函数之前处理：

class Derived {
public:
    Derived() : Base(some_function()) { }

private:
    static int some_function() { return 42; }
};

Answer 4

正如几个人回答的那样，您不能延迟基类构造函数的调用，但是 K​​onrad 给出了一个很好的答案，很可能会解决您的问题。但是，这确实有其缺点（例如，当您需要使用其计算共享中间结果的值来初始化多个函数时），因此为了完整起见，这是解决固定初始化顺序问题的另一种方法，通过使用它。

给定固定的初始化顺序，如果您可以控制派生类（否则您将如何摆弄其中一个构造函数？），您可以潜入一个私有基，以便它将在另一个基类之前初始化基，然后可以使用私有基已计算的值进行初始化：

class my_dirty_little_secret {
  // friend class the_class;
public: 
  my_dirty_little_secret(const std::string& str)
  {
    // however that calculates x, y, and z from str I wouldn't know
  }
  int x;
  std::string y;
  float z;
};

class the_class : private my_dirty_little_secret // must be first, see ctor
                , public the_other_base_class {
  public:
    the_class(const std::string str)
      : my_dirty_little_secret(str)
      , the_other_base_class(x, y, z)
    {
    }
  // ...
};

my_dirty_little_secret 类是一个私有基，因此 the_class 的用户无法使用它，它的所有内容都是也是私有的，具有明确的友谊，仅授予 the_class 访问权限。但是，由于它在基类列表中首先列出，因此它将在 the_other_base_class 之前可靠地构造，因此无论它计算什么都可以用来初始化它。
基类列表中的一个很好的注释有望防止其他人通过重构破坏事物。

Answer 5

恕我直言，我认为不可能以您提到的方式推迟调用基类构造函数。

Answer 6

哇，我们都曾经年轻过。这个答案不会起作用，所以不要使用它。出于历史目的而留下的内容。

如果您可以完全控制基类，我建议添加一个受保护的方法来进行类初始化，使其成为虚拟的，并在调用其基类之前将派生类实现细节放入其中：

class Base
{
public:
    Base()
    {
        Initialize();
    }
protected:
    virtual void Initialize()
    {
        //do initialization;
    }
};

class Derived : Base
{
public:

    Derived() : Base()
    {
    }
protected:
    virtual void Initialize()
    {
        //Do my initialization
        //call base
        Base::Initialize();
    }
};