C++ 派生 class 和基本复制构造函数作为指针

Question

I have a base class aaa and two derived classes bbb and ccc .

Is it possible to declare the base class first and then reference it to its derived classes, to make them share the same reference of it?

To show what I mean I wrote this small code:

#include <iostream>
#include <functional>
#include <memory>

class aaa
{
    protected:

        int a;

    public:

        aaa(int _a)
        {
            a = _a;
        }

        aaa(aaa &_aaa) = default;
        aaa(aaa &&_aaa) = default;

        int get_a(void)
        {
            return a;
        }

        void set_a(int _a)
        {
            a = _a;
        }

        int *get_a_addr(void)
        {
            return &a;
        }
};

class bbb : public aaa
{   
    public:

        bbb(aaa &_aaa) : aaa(_aaa)
        {
            ;
        }

        bbb(aaa &&_aaa) : aaa(_aaa)
        {
            ;
        }
};

class ccc : public aaa
{
    public:

        ccc(aaa &_aaa) : aaa(_aaa)
        {
            ;
        }

        ccc(aaa &&_aaa) : aaa(_aaa)
        {
            ;
        }
};

int main(void)
{   
    aaa a(10);
    bbb b(std::ref(a));
    ccc c(std::ref(a));

    std::cout << "address of a" << std::endl;
    std::cout << a.get_a_addr() << std::endl;
    std::cout << b.get_a_addr() << std::endl;
    std::cout << c.get_a_addr() << std::endl;

    return 0;
}

But b and c clearly don't have access to the same memory area of a::a .

As far as I know the only way to accomplish this is using nested classes. Isn't possible the way I am trying to?

Answer 1

All three objects have a different instance of the a member. And since you return the address of the ˋaˋ member in ˋget_a_addressˋ and not its content, the return value differs for each object. I assume you want to return the same value (the content of the ˋaˋ object) for all these calls.

Answer 2

No, each base class subobject is independent of all other subobjects. What you can do is have a fake base class, whose only job is to reference the real thing.

class realA
{
  void foo() { ... }
  void bar() { ... }
};

class a
{
   ...
   void foo() { impl->foo(); }
   void bar() { impl->bar(); }
   std::shared_ptr<realA> impl;
};

a behaves just like realA because it has all the same methods as realA , doing the same thing.

Your b and c still have separate a subobjects, but now they may share the same realA object, which is the class that does the real work.