引用成员不会被父类的析构销毁

一，成员引用的方式。

将某个成员申明为类的引用方式，（其实就是指针）

发现类的析构函数并不会销毁引用成员。

#include <iostream>

class A
{
  public:
    A()
    {
        std::cout << "create A" << std::endl;
    }

    A(const A& a)
    {
        std::cout << "copy A" << std::endl;
    }
    ~A()
    {
        std::cout << "destroy A" << std::endl;
    }

    void f()
    {
        std::cout << "A f()" << std::endl;
    }
};

class B
{
  public:
    B(A &a)
        : m_a{a}
    {
        std::cout << "create B" << std::endl;
    }

    ~B()
    {
        std::cout << "destroy B" << std::endl;
    }

    void f()
    {
        m_a.f();
        std::cout << "B f()" << std::endl;
    }


  private:
    A  &m_a;
};

void test()
{
    A a;

    {
        B b{a};
        b.f();
    }
}

int main()
{
    test();
    return 0;
}

成员A不会被构造，而且也不会被销毁。行为模式和指针几乎完全一样。

只不过语法形式上是对象（用起来是对象的语法，行为模式是指针）

如果把A声明成普通的成员，以上代码，成员A会被拷贝构造，并且被销毁。

二， 测试引用的行为模式。

为了进一步测试引用其实就是指针，给A加了一个256字节的数组成员，给B加上一个引用方式的成员A

#include <iostream>

class A
{
  public:
    A()
    {
        std::cout << "create A" << std::endl;
    }

    A(const A& a)
    {
        std::cout << "copy A" << std::endl;
    }
    ~A()
    {
        std::cout << "destroy A" << std::endl;
    }

    void f()
    {
        std::cout << "A f()" << std::endl;
    }
  private:
    char a[256];
};

class B
{
  public:
    B(A &a)
        : m_a{a}
    {
        std::cout << "create B" << std::endl;
    }

    ~B()
    {
        std::cout << "destroy B" << std::endl;
    }

    void f()
    {
        m_a.f();
        std::cout << "B f()" << std::endl;
    }


  private:
    A  &m_a;
};

void test()
{
    A a;

    {
        B b{a};
        b.f();
    }
}

int main()
{
    test();
    std::cout << "size of A is " << sizeof(A) << std::endl;
    std::cout << "size of B is " << sizeof(B) << std::endl;
    return 0;
}

果然sizeof A 变成了256

而sizeof B 是8 （因为64位编译环境，指针是8个字节）

三， 如果把B中的成员改成通常的对象。

就会发现A会被构造和析构，并且B和A的size 是一致了。

#include <iostream>

class A
{
  public:
    A()
    {
        std::cout << "create A" << std::endl;
    }

    A(const A& a)
    {
        std::cout << "copy A" << std::endl;
    }
    ~A()
    {
        std::cout << "destroy A" << std::endl;
    }

    void f()
    {
        std::cout << "A f()" << std::endl;
    }
  private:
    char a[256];
};

class B
{
  public:
    B(A &a)
        : m_a{a}
    {
        std::cout << "create B" << std::endl;
    }

    ~B()
    {
        std::cout << "destroy B" << std::endl;
    }

    void f()
    {
        m_a.f();
        std::cout << "B f()" << std::endl;
    }


  private:
    A  m_a;
};

void test()
{
    A a;

    {
        B b{a};
        b.f();
    }
}

int main()
{
    test();
    std::cout << "size of A is " << sizeof(A) << std::endl;
    std::cout << "size of B is " << sizeof(B) << std::endl;
    return 0;
}