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

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

这就是问题的基础：

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()

/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

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