父类中子类的实例

Question

我在类层次结构中有两个类，其中父类需要有一个从它派生的类的实例作为成员变量。举个例子：

class B;

class A {
public:
    B* binst;

    A();
};

class B : public A {
};

A::A() {
    binst = new B;
}

显然，这会导致构造函数中的无限递归，因为要创建一个新的 B，您必须调用 A 的构造函数，这会创建一个新的 B，该新的 B 又调用 A 的构造函数，如此循环下去。

有办法解决这个问题吗？我遇到的问题是 A 中必须有 B，但 B 必须从 A 派生，并且没有办法阻止这种情况。

要了解为什么我需要这样做，请考虑脚本语言的面向对象层次结构（例如 python、ruby 或 lua 等）：

1. 任何事物的所有实例都派生自基类 Object。
2. 对象有一个方法查找表，它是MethodTable的一个实例。
3. MethodTable 是从 Object 派生的，并且必须是这样，以便脚本语言能够对其进行操作。

Answer 1

• “对象有一个方法查找表”
• “方法表派生自对象”

抛开编码问题，从概念的角度来看，这些语句在一起真的有意义吗？方法表是否应该有自己的方法表，然后方法表又有自己的方法表...等等？

我想说，听起来您需要稍微重构一下您的概念。例如，也许对象本身应该以某种方式负责公开其 MethodTable 成员的必要部分。因此不需要 MethodTable 本身是一个对象。 （可能还有其他各种可行的设计。如果不深入了解实际项目，很难说。）

Answer 2

编辑：通常，编译器/实现内部类型不派生自语言相关类型。如果您查看 Java 的内部结构，您会发现它们的继承实现不会派生自 Object。对象是一种语言结构，它是语言接口的一部分。方法表是实现的一部分。方法表不应该由语言操作，而应该由实现操作。

此外，强制从 Object 派生是一件愚蠢的事情，之所以会发生这种情况，是因为您没有考虑语言设计以及用户如何正确编写通用代码。在 Lua 或 Python 等动态类型语言中尤其如此。

Answer 3

对象可以有一个私有 MethodTableImpl 成员和一个返回 MethodTable 的公共 getter。 MethodTable 包含 MethodTableImpl 并派生自 Object。

Answer 4

我不知道你的类的目的，但这里有一个建议：

class A
{
public:
    virtual void func DoIt () = 0;
    ...
};

class B : public virtual A
{
public:
};

class C : public virtual A ,B
{
    void func DoIt () { /* statements */ }
};

现在 A 类只有 1 个实例。

Answer 5

准确理解您是否试图通过此构造实现目标将很有帮助。

正如您自己所指出的，这实际上就像让 A 的构造函数构造 A 的实例，这是堆栈溢出的不可避免的路径。

更通用的解决方案是为指向 A 实例的指针提供一个 set_subclass 方法，然后可以由 A 的任何子类（而不仅仅是 B）填充该实例。

class A {
public:
    A();
    virtual ~A();

    set_subclass(A* sub) { subclass = sub; }
private:
    A* subclass;
};

Answer 6

// List(1) or Stream(2) using inheritance
struct B;

struct A { 
  B *inst; 
  A(B *inst_) : inst(inst_) {}
  A()  : inst(0) {}
};

struct B : A {
  B(B *_inst) : A(inst) {}
  // chose option 1 or 2
  B() : A() {}       // option 1: List
  B() : A(0) {}      // same as above
  B() : A(this) {}   // option 2: Stream
};

auto B3 = new B(new B( new B));
// This is either a length 3 list (1)
// or a stream (2) implemented by self ref 3rd element

Answer 7

您可以为类 A 创建一个构造函数，它接受指向类 B 的对象的指针，并分配此指针而不是分配新的 B：

A::A(B* b) : binst (b) {}

在类 B 的构造中，您在 A 的构造函数中传递“this”：

B::B() : A(this) {} 

编译器可能会抱怨一下，但你可以尝试。 （不过它很难看。）

请注意，您不能使用 binst 指针在 A 的构造函数中访问对象 B，因为它尚未完全构造。

Answer 8

它实际上需要 binst 作为成员，还是只需要访问它？

class B;

class A {
public:
    B& binst(); //throws exception if not derived from B

    A() {}
    virtual ~A() {} //effectively required for the dynamic_cast
    void foo();
};

class B : public A {
public:
    void bar() {};
};

B& A::binst() {return dynamic_cast<B&>(this);} 
void A::foo() {return binst().bar();}