如何在 C++ 中获得多态行为构造函数？

Question

我有一个基类，我希望它看起来像这样：

class B
{
    // should look like: int I() { return someConst; }
    virtual int I() = 0;
    public B() { something(I()); }
}

重点是强制派生类重写 I 并强制在构造每个对象时调用它。这用于做一些簿记，我需要知道正在构造什么类型的对象（但我否则将当前对象视为基类）。

这是行不通的，因为 C++ 不允许您从构造函数调用抽象虚函数。

有没有办法获得相同的效果？

---

基于这个链接似乎答案是没有办法得到我想要的东西。然而它说的是：

简短的回答是：不。基类不知道它派生自哪个类，这也是一件好事。 [...] 也就是说，在构造函数 Derived1::Derived1 开始之前，该对象不会正式成为 Derived1 的实例。

但就我而言，我不想知道它是什么，而是想知道它会变成什么。事实上，我什至不关心我得到什么，只要用户可以（事后）将其映射到一个类。所以我什至可以使用像返回指针这样的东西并摆脱它。

（现在回到阅读该链接）

Answer 1

您不能从构造函数中调用虚方法（或者更准确地说，您可以调用它们，但最终会从当前正在构造的类中调用成员函数）。是派生对象此时还不存在。您对此无能为力，从构造函数多态调用虚拟方法根本不可能。

您应该重新考虑您的设计 - 例如，将常量作为参数传递给构造函数。

class B
{
public:
    explicit B(int i)
    {
        something(i);
    }
};

有关详细信息，请参阅 C++ 常见问题解答。如果您确实想在构造过程中调用虚函数，阅读此内容。

Answer 2

也许对每个派生类型使用静态工厂方法？这是在 .NET 中构造奇异对象（即具有非常具体的初始化要求的对象）的常用方法，我对此表示赞赏。

class Base
{
  protected Base(int i)
  {
    // do stuff with i
  }
}

class Derived : public Base
{
  private Derived(int i)
    : Base(i)
  {
  }

  public Derived Create()
  {
    return new Derived(someConstantForThisDerivedType);
  }
}

在基本构造函数中调用虚拟方法通常是不受欢迎的，因为您永远无法确定特定方法的行为，并且（正如其他人已经指出的那样）派生构造函数尚未被调用。

Answer 3

这将不起作用，因为执行基类构造函数时派生类还不存在：

class Base
{
public:
    Base()
    {
        // Will call Base::I and not Derived::I because
        // Derived does not yet exist.
        something(I());
    }

    virtual ~Base() = 0
    {
    }

    virtual int I() const = 0;
};

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

    virtual ~Derived()
    {
    }

    virtual int I() const
    {
        return 42;
    }
};

相反，您可以将参数添加到基类构造函数：

class Base
{
public:
    explicit Base(int i)
    {
        something(i);
    }

    virtual ~Base() = 0
    {
    }
};

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

    virtual ~Derived()
    {
    }
};

或者如果您真的喜欢 OOP，您还可以创建几个附加类：

class Base
{
public:
    class BaseConstructorArgs
    {
    public:
        virtual ~BaseConstructorArgs() = 0
        {
        }

        virtual int I() const = 0;
    };

    explicit Base(const BaseConstructorArgs& args)
    {
        something(args.I());
    }

    virtual ~Base() = 0
    {
    }
};

class Derived : public Base
{
public:
    class DerivedConstructorArgs : public BaseConstructorArgs
    {
    public:
        virtual ~DerivedConstructorArgs()
        {
        }

        virtual int I() const
        {
            return 42;
        }
    };

    Derived()
     : Base(DerivedConstructorArgs())
    {
    }

    virtual ~Derived()
    {
    }
};

Answer 4

您需要的是两阶段构建。使用通用程序员的治疗方法：添加另一层间接层。