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)} {}
};

查看完全限定呼叫：

this->ClassB_Base::ClassB_Action()

我删除“this->”，并使用以下命令：

ClassB_Base::ClassB_Action()

/EDIT 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

用例：

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

  int xData[10];
};

---

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

C++的另一个基本部分是多重继承，并且具有多重继承性，所有基类总是以声明顺序构造的（我忽略虚拟继承，这增加了一些与此无关的其他并发症）。 这几乎是唯一一个可以用来调整构建顺序的工具。但这可以谨慎地使用，对你有利。例如，与第一个示例中显示的代码不同：

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

ClassA：私有ClassB，公共ClassA\U库{
公众：
ClassA（int maxSize=4000）
：ClassB{maxSize}，
ClassA_Base{static_cast（*this）}
{
}
};

---

您不是拥有

ClassB

一个

ClassA

的私有成员，而是从其私有继承；然后将对它的引用传递给

ClassA\u Base

的构造函数

ClassB

首先得到完整的构造，然后

ClassA\U Base

得到它的引用。

谢谢！这对我来说是一个有效的解决方案。我已编辑该问题以添加更多信息。我会在几个工作日内接受，以考虑任何其他输入。

//// 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);
}

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