C ++將基類成員鏈接到派生類成員

Question

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一致。

Answer 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;
}

輸出：

2