C++ 使用派生类初始化成员类

因此，我试图找到一种最佳实践方法，将成员类构造为其派生类的一部分

struct A {
    int a = 0
}

struct B : struct A {
    int b = 0;
}
class ContainingClassA {
    ContainingClassA() : member_A(){}

    virtual A get() {
        return member_A;
    }

    A member_A;
}

class ContainingClassB : public ContainingClassA {
    ContainingClassB(){}

    virtual B get() override{
        return member_A;
    }
}

---

是否有一种方法可以初始化包含ClassB的类

中的
成员a
，使其为B类型？我看到过，为了初始化
成员a
，可能在
包含classa的
中添加了一个构造函数。我知道我可以在
包含类B
中声明一个
B member\u B
变量并返回它，但是由于
B
是从
a
派生出来的，因此我似乎可以以某种方式将它存储在继承的变量
member\u a
中，
您可以使用模板来选择变量的类型。大概是这样的：

#include <iostream>

struct A {
  int a = 0;
};

struct B : A
{
  int b = 0;
};

template<typename T>
class ContainingClassA
{
 public:
  ContainingClassA() : member_A(){}

  virtual T get() {
    return member_A;
  }

  T member_A;
};

class ContainingClassB : public ContainingClassA<B>
{
 public:
  ContainingClassB() { }

  virtual B get() override
  {
    return member_A;
  }
};

int main()
{
  ContainingClassB cb;
  std::cout << cb.get().a;
  std::cout << std::endl;
  std::cout << cb.get().b;
  return 0;
}

#包括
结构A{
int a=0；
};
结构B:A
{
int b=0；
};
模板
类包含类A
{
公众：
ContainingClassA（）：成员_A（）{}
虚拟T get（）{
返回成员A；
}
T成员A；
};
类别包含类别B：公共包含类别A
{
公众：
包含类B（）{}
虚拟B get（）覆盖
{
返回成员A；
}
};
int main（）
{
包含B类cb；
标准：：cout
是否有一种方法可以初始化包含ClassB的类
中的
成员a
，使其为B类型

否。
成员A
是
包含类A
的成员
包含类b
使用与其父类相同的
成员A
，
包含类A
。不能更改父类的布局

此外，您不能更改虚拟函数的声明（只有少数例外）。换句话说，您不能用
bget（）
覆盖
a get（）

您可以更改
get（）
以返回引用，然后可以使用
B&get（）
覆盖
a&get（）
（因为
a&
和
B&
是协变类型）

但首先，您需要将解决方案分为A和B的“接口”和两个“实现”：

#include <iostream>

struct A {
    int a = 0;
};

struct B : public A {
    int b = 1;
};

class ContainingClassBase {
public:
    virtual const A& get() = 0;
};

class ContainingClassA : public ContainingClassBase {
    A member_A;
public:
    virtual const A& get() override { return member_A; }
};

class ContainingClassB : public ContainingClassBase {
    B member_B;
public:
    virtual const B& get() override { return member_B; }
};

int main() {
    ContainingClassA a;
    ContainingClassB b;
    std::cout << a.get().a << std::endl;
    std::cout << b.get().b << std::endl;
}

#包括
结构A{
int a=0；
};
结构B：公共A{
int b=1；
};
类包含类库{
公众：
虚拟常量A&get（）=0；
};
类ContainingClassA：公共ContainingClassBase{
一名成员；
公众：
虚拟常量A&get（）重写{return member_A；}
};
类ContainingClassB：公共ContainingClassBase{
B成员B；
公众：
虚拟常量B&get（）重写{return member_B；}
};
int main（）{
包含a类；
包含b类；
Std::Cub:B/<代码>包含<代码> < /COD>部分。<代码> a <代码>对“<代码> b <代码> > nNaulover AH没有知识或存储。当然，我很好奇，如果我在存储这些类的指针时不存储实例本身呢？考虑在基类中有一个指针，即<代码> A*成员。A、 
您可以在ClassContainingB中为其分配一个B实例；有几种特定的方法允许您更改函数重写的返回类型：
const A&get（）
和
const B&get（）
或
const A*get（）
和
const B*get（）
将是这种“协变返回类型”的有效情况。