c++ - 基类需要引用尚未构造的派生类成员

问题描述

有没有办法确保通过引用传递给基类的派生类创建的对象已经构造并且仍然具有继承？

这是问题的基础：

class ClassA : public ClassA_Base {
public:
  ClassA(int maxSize = 4000)
  : ClassA_Base(xClassB_Object),
    xClassB_Object(maxSize) {};

private:
  ClassB xClassB_Object;
};

这是我能找到的最接近的答案。但他们并没有尝试使用继承：如何防止使用尚未构造的类成员？

编辑 1：我实施了 Sam Varshavchik 的解决方案。

class ClassA : private ClassB, public ClassA_Base {
public:
  ClassA(int maxSize = 4000)
  : ClassB{maxSize}, 
    ClassA_Base{static_cast<ClassB &>(*this)} {}
};

显然，我使用的函数名称与所讨论的示例代码不同，AppLevel、派生和基础的所有级别都有更多的代码。我的代码现在直接访问基本函数，而不是通过 xClassB_Object 所以我失去了一个“限定符”。“那个与 AppLevel/ClassA 功能几乎没有关系的函数是从哪里来的？！”

为了减轻“歧义”，我在通话中使用了更多限定词。而不仅仅是：

ClassB_Action()

查看完全合格的电话：

this->ClassB_Base::ClassB_Action()

我删除“this->”并使用以下内容：

ClassB_Base::ClassB_Action()

/编辑1：

这是问题的更详细版本。

我有一连串的课程。有些是工人，有些是为工人分配的。这为使用类提供了最大的灵活性。

我的目的是让用户从链中的任何级别派生，而不需要他们实现任何东西来支持基类，而不是调用构造函数。然后直接使用基类的成员函数。

问题是由于调用构造函数的顺序，当我的对象的引用传递给基类的构造函数时，它们并没有完全构造。我知道此时我可以传递引用，但我不能在基类构造函数中使用它。

这是整个类链：

ClassB - moves data into memory (does not need ClassA)
ClassA - modifies the data and passes to ClassB

ClassB_Base - Worker (Operates on buffer)
ClassB - Allocator (Creates a buffer)
ClassA_Base - Worker (Operates on data and calls ClassB worker)
ClassA - Allocator (Creates a ClassB)
AppLevelClass - Top layer passing in data

//// ClassB_Base acts on the data
class ClassB_Base {
public:
  ClassB_Base(int* pData, int* pIndex, int length) 
  : xpData(pData),
    xpIndex(pIndex),
    xLength(length) {}

  void ClassB_Action(int* data) {
    //// Do ClassB_Action stuff with the data
    xpData = xpIndex = &xLength; // Junk code to eliminate compiler warning
  }

private:
  int*    xpData;
  int*    xpIndex;
  int     xLength;
};

//// ClassB only allocates a data buffer for use in ClassB_Base
class ClassB : public ClassB_Base
{
public:
  ClassB(int maxSize)
  : ClassB_Base(new int[maxSize], &xIndex, maxSize) {}

private:
  int   xIndex;
};

//// ClassA_Base acts on the data and calls ClassB
class ClassA_Base {
public:
  ClassA_Base(ClassB_Base& ClassB_Passed_Ref)
  : xClassB_Object_Ref(ClassB_Passed_Ref) {}

  void ClassA_Action(int *data) {
    //// Do some ClassA_Action stuff with the data like sort or filter
    xClassB_Object_Ref.ClassB_Action(data);
  }

private:
  ClassB_Base& xClassB_Object_Ref;
};

//// ClassA only instantiates a class for use in ClassA_Base
class ClassA : public ClassA_Base {
public:
  ClassA(int maxSize = 4000)
  : ClassA_Base(xClassB_Object),
    xClassB_Object(maxSize) {}

private:
  ClassB xClassB_Object;
};

用例：

//// Now using the whole chain
class AppLevelClass1 : public ClassA {
public:
  AppLevelClass1(void) {
    ClassA_Action(xData);
  }

  int xData[10];
};

//// Or using part of the chain
class AppLevelClass2 : public ClassB {
public:
  AppLevelClass2(void) {
    ClassB_Action(xData);
  }

  int xData[10];
};

//// Or using another part of the chain
class AppLevelClass3 : public ClassB_Base {
public:
  AppLevelClass3(void) : ClassB_Base(xBuff, &xIndex, 100) {
    ClassB_Action(xData);
  }

  int xData[10];
  int xIndex;
  int xBuff[1000];
};

//// Other use cases
int main() {
  int data[10];
  int index;
  AppLevelClass myAppLevelClass;
  myAppLevelClass.ClassA_Action(data);

  ClassB_Base xClassB_Base(data, &index, 5);
  xClassB_Base.ClassB_Action(data);

  ClassB xClassB(1000);
  xClassB.ClassB_Action(data);

  ClassA_Base xClassA_Base1(xClassB_Base);
  xClassA_Base1.ClassA_Action(data);

  ClassA_Base xClassA_Base(xClassB);
  xClassA_Base.ClassA_Action(data);

  ClassA xClassA(1000);
  xClassA.ClassA_Action(data);
}

标签： c++constructorinitialization

在 C++ 中，基类总是在派生类的任何部分被构造之前被构造。没有例外，没有变通办法，没有替代方案。在基类完全构造并且其构造函数（如果有）返回之前，派生类的任何部分都不存在。这是基本的 C++。

然而

C++ 的另一个基本部分是多重继承，并且对于多重继承，所有基类总是按声明顺序构造（我忽略了虚拟继承，这增加了一些在这里不相关的额外复杂性）。

这几乎是您可以用来调整事物构建顺序的唯一工具。但这可以谨慎地用于您的优势。例如，代替第一个示例中显示的代码：

class ClassA : private ClassB, public ClassA_Base {
public:
  ClassA(int maxSize = 4000)
  : ClassB{maxSize}, 
    ClassA_Base{static_cast<ClassB &>(*this)}
  {
  }
};

您可以从它私下继承，而不是拥有ClassB的私有成员ClassA；然后将对它的引用传递给ClassA_Base的构造函数。ClassB首先完全构造，然后ClassA_Base获取对它的引用。

c++ - 基类需要引用尚未构造的派生类成员

问题描述

解决方案

推荐阅读