C ++将基类成员链接到派生类成员答案

【问题标题】：C++ linking base class members to derived class membersC ++将基类成员链接到派生类成员
【发布时间】：2017-09-01 21:17:53
【问题描述】：

class B_mem {
  public:
    int b_var;
};
class D_mem : public B_mem {
  public:
    int d_var;
};

class B {
  public:
    B_mem b_member;
};

class D : public B {
  public:
    D_mem d_member;
};


int main () {
    D derived;
    D_mem dmem;
    dmem.b_var = 2;
    dmem.d_var = 3;
    B* b_ptr = &derived;
    std::cout << b_ptr->b_member.b_var;  // Doesn't print 2
}

如何构建类，以便在设置/更新 D_mem 时，它会自动设置/更新 B_mem（如果相关）？在上面的示例中，我创建了 D 并填充了 D_mem，然后使用 B 类型的指针访问 D。我希望能够通过 B_mem 访问 D 中 D_mem 的基类成员。

我想知道是否有一些具有多态性、复制构造函数或集合函数的东西可以让我做到这一点，而无需手动保持 D_mem 和 B_mem 一致。

【问题讨论】：

dmem 和 derived.d_member 是不同的对象。
啊，是的！我的意思是在定义dmem 之后添加derived.d_member = dmem。即使修复了，您仍然会遇到同样的问题。

标签： c++ inheritance polymorphism copy-constructor move-constructor

【解决方案1】：

std::cout << b_ptr->b_member.b_var; // Doesn't print 2

当然不会。

线条

D_mem dmem;
dmem.b_var = 2;
dmem.d_var = 3;

没有改变derived 的成员变量。它们仍处于未初始化状态。

你可以使用：

int main () {
    D derived;

    D_mem& dmem = derived.d_member; // Get a reference to an existing object
    dmem.b_var = 2;                 // Modify the referenced object
    dmem.d_var = 3;

    // That still doesn't change b_member.
    // Need to update it too.
    derived.b_member.b_var = 2;

    B* b_ptr = &derived;
    std::cout << b_ptr->b_member.b_var;  // Doesn't print 2
}

或

int main () {
    D derived;
    D_mem dmem;
    dmem.b_var = 2;
    dmem.d_var = 3;

    derived.d_member = dmem;   // Set the value of derived.
    derived.b_member = dmem; 

    B* b_ptr = &derived;
    std::cout << b_ptr->b_member.b_var;  // Doesn't print 2
}

回复：

我想知道是否有一些具有多态性、复制构造函数或设置函数的东西可以让我做到这一点，而无需手动保持 D_mem 和 B_mem 一致。

如果您提供处理这些细节并将成员变量设为私有的成员函数，则可以这样做，但它会变得混乱，因为您在 D 中基本上有两个 B_mem 实例。

如果您使用指针而不是对象，代码将变得更简单和更易于维护。

这是一个示例实现：

#include <iostream>
#include <memory>

class B_mem {
   public:
      int b_var;
      virtual ~B_mem() {}
};

class D_mem : public B_mem {
   public:
      int d_var;
};

class B {
   protected:
      std::shared_ptr<B_mem> b_member;

   public:

      B(std::shared_ptr<B_mem> member) : b_member(member){}
      virtual ~B() {}

      virtual B_mem& getMember() = 0;

      virtual B_mem const& getMember() const = 0;
};

class D : public B {

   public:

      D() : B(std::shared_ptr<B_mem>(new D_mem)){}

      D_mem& getMember()
      {
         return *(std::dynamic_pointer_cast<D_mem>(b_member));
      }

      D_mem const& getMember() const
      {
         return *(std::dynamic_pointer_cast<D_mem>(b_member));
      }
};


int main () {
   D derived;

   derived.getMember().b_var = 2;
   derived.getMember().d_var = 3;

   B* b_ptr = &derived;
   std::cout << b_ptr->getMember().b_var << std::endl;
}

输出：

【讨论】：