c++类继承

一、继承的规则

（1）基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为protected时，那么基类成员在派生类中的访问权限最高也为protected，高于protected会降级为protected，但低于protected不会升级。当继承方式为public时，继承方式则保持不变；

（2）继承方式中的public、protected、private是用来指定基类成员在派生类中最高访问权限的；

（3）不管继承方式是什么，基类中的private成员在派生类中始终不能使用（不能在派生类的成员函数中访问和使用）；

（4）如果希望基类的成员既不向外暴漏（不能通过对象访问），还能在派生类中使用，那么只能声明为protected；

（5）由于private和protected继承方式会改变基类成员在派生类中的访问权限，导致继承关系复杂，所以在实际开发中，一般使用public。
（6）在派生类中，可以通过基类的公有成员函数间接访问基类的私有成员；
（7）使用using关键字可以改变基类成员在派生类中的访问权限。

继承访问权限：

#include 

class A
{
public:
    int m_A = 5;
protected:
    int m_B = 10;
private:
    int m_C = 15;
};

class B : public A 
{
public:
    int getB()
    {
        return m_B;
    }
};

int main()
{
    B b;
    b.m_A = 5;          // 没问题
    //b.m_B = 10;       // 不能访问，m_B是受保护成员变量
    //b.m_C = 15;       // 不能访问，m_C是私有变量，派生类不能访问
    b.getB();           // 可以通过成员函数访问m_B
}

使用using改变继承属性：

#include 

class A
{
public:
    int m_A = 5;
protected:
    int m_B = 10;
private:
    int m_C = 15;
};

class B : public A 
{
public:
    using A::m_B;

    int getA()
    {
        return m_A;
    }
private:
    using A::m_A;
};


int main()
{
    B b;
    // b.m_A = 5;            // 不能访问，使用using m_A变成了私有成员属性
    b.m_B = 10;              // 没问题，使用using，m_B变成了public
    //b.m_C = 15;            // 不能访问，m_C是私有变量，派生类不能访问
    b.getA();               // 可以通过成员函数访问m_A
}

二、类的对象模型

（1）创建派生类对象时，先调用基类构造函数，再调用派生类构造函数；
（2）销毁派生类对象时，先调用派生类析构函数，再调用基类析构函数；
（3）创建派生类对象时只会申请一次内存，派生类对象包含了基类对象的内存空间，this指针相同的；
（4）创建派生类对象时，先初始化基类对象，再初始化派生类对象；
（5）对派生类对象用sizeof得到的是基类所有成员（包括私有成员）+派生类对象所有成员的大小；

#include 
using namespace std;

void* operator new(size_t size)
{
    void* ptr = malloc(size);   // 申请内存
    cout << "申请到的内存地址是：" << ptr << " size大小：" << size << endl;
    return ptr;
}

void operator delete(void* ptr)
{
    if (ptr == nullptr) return;
    free(ptr);                  // 释放内存
    cout << "释放了内存。" << endl;
}

class A
{
public:
    int m_A = 5;
protected:
    int m_B = 10;
private:
    int m_C = 15;
public:
    A()
    {
        cout << "A中this指针是：" << this << endl;
        cout << "A中m_A指针是：" << &m_A << endl;
        cout << "A中m_B指针是：" << &m_B << endl;
        cout << "A中m_C指针是：" << &m_C << endl;

    }
};

class B : public A
{
public:
    int m_D = 30;
    B()
    {
        cout << "A中this指针是：" << this << endl;
        cout << "A中m_A指针是：" << &m_A << endl;
        cout << "A中m_B指针是：" << &m_B << endl;
        //cout << "A中m_C指针是：" << &m_C << endl;  // 私有无法访问
        cout << "A中m_D指针是：" << &m_D << endl;
    }
};

int main()
{
    cout << "基类占用内存的大小是：" << sizeof(A) << endl;
    cout << "派生类占用内存的大小是：" << sizeof(B) << endl;
    B* b = new B;
    delete b;
    
}

打印输出：

基类占用内存的大小是：12
派生类占用内存的大小是：16
申请到的内存地址是：00000168C69232B0 size大小：16
A中this指针是：00000168C69232B0
A中m_A指针是：00000168C69232B0
A中m_B指针是：00000168C69232B4
A中m_C指针是：00000168C69232B8
A中this指针是：00000168C69232B0
A中m_A指针是：00000168C69232B0
A中m_B指针是：00000168C69232B4
A中m_D指针是：00000168C69232BC
释放了内存。

（6）在C++中，不同继承方式的访问权限只是语法上的处理；
（7）对派生类对象用memset()清空基类私有成员；
（8）用指针可以访问到基类中的私有成员（没有内存对齐，没有占位符）

#include 
using namespace std;

void* operator new(size_t size)
{
    void* ptr = malloc(size);   // 申请内存
    cout << "申请到的内存地址是：" << ptr << " size大小：" << size << endl;
    return ptr;
}

void operator delete(void* ptr)
{
    if (ptr == nullptr) return;
    free(ptr);                  // 释放内存
    cout << "释放了内存。" << endl;
}

class A
{
public:
    int m_A = 5;
protected:
    int m_B = 10;
private:
    int m_C = 15;
public:
    A()
    {
        cout << "A中this指针是：" << this << endl;
        cout << "A中m_A指针是：" << &m_A << endl;
        cout << "A中m_B指针是：" << &m_B << endl;
        cout << "A中m_C指针是：" << &m_C << endl;
    }
    void funcA()
    {
        cout << "m_A=" << m_A << ",m_B=" << m_B << ",m_C=" << m_C << endl;
    }
};

class B : public A
{
public:
    int m_D = 30;
    B()
    {
        cout << "A中this指针是：" << this << endl;
        cout << "A中m_A指针是：" << &m_A << endl;
        cout << "A中m_B指针是：" << &m_B << endl;
        //cout << "A中m_C指针是：" << &m_C << endl;  // 私有无法访问
        cout << "A中m_D指针是：" << &m_D << endl;
    }
    void funcB()
    {
        cout << "m_D=" << m_D << endl;
    }
};

int main()
{
    cout << "基类占用内存的大小是：" << sizeof(A) << endl;
    cout << "派生类占用内存的大小是：" << sizeof(B) << endl;
    B* b = new B;
    b->funcA();  b->funcB();
    //memset(b, 0, sizeof(B));        // m_A m_B m_C m_D都被清零
    *((int*)b + 2) = 100;
    b->funcA();  b->funcB();
    delete b;
    
}

打印输出：

基类占用内存的大小是：12
派生类占用内存的大小是：16
申请到的内存地址是：00000240B7313490 size大小：16
A中this指针是：00000240B7313490
A中m_A指针是：00000240B7313490
A中m_B指针是：00000240B7313494
A中m_C指针是：00000240B7313498
A中this指针是：00000240B7313490
A中m_A指针是：00000240B7313490
A中m_B指针是：00000240B7313494
A中m_D指针是：00000240B731349C
m_A=5,m_B=10,m_C=15
m_D=30
m_A=5,m_B=10,m_C=100
m_D=30
释放了内存。

三、如何构造基类

（1）创建派生类对象时，程序首先调用基类构造函数，然后再调用派生类构造函数；
（2）如果没有指定基类构造函数，将使用基类的默认构造函数；
（3）可以用初始化列表指明要使用的基类构造函数；
（4）基类构造函数负责初始化被继承的数据成员，派生类构造函数主要用于初始化新增的数据成员；
（5）派生类的构造函数总是调用一个基类构造函数，包括拷贝构造函数。

#include 
using namespace std;

class A
{
public:
    int m_A;
private:
    int m_B;
public:
    A():m_A(0), m_B(0) {
        cout << "调用基类默认构造函数A()" << endl;
    }
    A(int a, int b) :m_A(a), m_B(b) {
        cout << "调用基类构造函数A(int a, int b)" << endl;
    }
    A(const A& a) :m_A(a.m_A), m_B(a.m_B) {
        cout << "调用基类拷贝构造函数A(int a, int b)" << endl;
    }
    void funcA()
    {
        cout << "m_A=" << m_A << ",m_B=" << m_B << endl;
    }
};

class B : public A
{
public:
    int m_C = 30;
    B():m_C(0) {
        cout << "调用基类默认构造函数B()" << endl;
    }
    B(int a, int b, int c) : A(a, b), m_C(c){
        cout << "调用基类构造函数B(int a, int b, int c)" << endl;
    }
    B(const A& a, int c) :A(a), m_C(c) {
        cout << "调用基类拷贝构造函数B(const A& a, int c)" << endl;
    }
    void funcB() {
        cout << "m_C=" << m_C << endl;
    }
};

int main()
{
    B b1;                   // 调用基类默认构造函数
    b1.funcA(); b1.funcB();

    B b2(1, 2, 3);          // 将调用基类两个参数的构造函数
    b2.funcA(); b2.funcB();

    A a(10, 20);
    B b3(a, 30);
    b3.funcA(); b3.funcB(); // 调用基类构造函数  
}

打印输出：

调用基类默认构造函数A()
调用基类默认构造函数B()
m_A=0,m_B=0
m_C=0
调用基类构造函数A(int a, int b)
调用基类构造函数B(int a, int b, int c)
m_A=1,m_B=2
m_C=3
调用基类构造函数A(int a, int b)
调用基类拷贝构造函数A(int a, int b)
调用基类拷贝构造函数B(const A& a, int c)
m_A=10,m_B=20
m_C=30

四、名字遮蔽与类作用域

（1）如果派生类中的成员（包括成员变量和成员函数）和基类中的成员重名，通过派生类对象或者在派生类的成员函数中使用该成员时，将使用派生类新增的成员，而不是基类的；
（2）基类的成员函数和派生类的成员函数不会构成重载，如果派生类有同名函数，那么就会遮蔽基类中的所有同名函数；
（3）类是一种作用域，每个类都有它自己的作用域，在这个作用域之内定义成员；
（4）在类的作用域之外，普通的成员只能通过对象（可以是对象本身，也可以是对象指针或对象引用）来进行访问，静态成员可以通过对象访问，也可以通过类访问；
（5）在成员前面加类名和域解析符可以访问对象的成员；
（6）如果不存在继承关系，域名和域解析符可以省略不写；
（7）当存在继承关系时，基类的作用嵌套派生类的作用域中，如果成员在派生类的作用域已经找到，就不会在基类作用域中继续查找，如果没有找到，则继续在鸡类作用域中查找。

五、继承的特殊关系

（1）如果继承方式是公有的，派生类对象可以使用基类成员；
（2）可以把派生类对象赋值给基类对象（包括私有成员），但是会舍弃非基类的成员；
（3）基类指针可以在不进行显示转换的情况下指向派生类对象；
（4）基类引用可以在不进行显示转换的情况下引用派生类对象。

注意：
（1）基类指针或引用只能调用基类的方法，不能调用派生类的方法；
（2）可以用派生类构造基类；
（3）如果函数的型参是基类，实参可以用派生类；
（4）C++要求指针和引用类型与赋给的类型匹配，这一规则对继承来说是例外。但是，这种例外只是单向的，不可以将基类对象和地址赋给派生类引用和指针（没有价值，没有讨论的必要）。