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