C++ 面向对象三大特性：继承

二、基类和派生类的转换

（一）基类转换派生类

1、基类对象不能赋值给派生类对象。 2、基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用 RTTI(Run-Time Type Information) 的 dynamic_cast 来进行识别后进行安全转换。

（二）派生类转换基类

1、public 继承的派生类对象 可以赋值给基类的指针/基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。

值得注意的是，之前在隐式类型转换时会生成临时变量，因此在应用时需要加上 const，而在切片时不会生成中间的临时变量。

class Person {
protected:
    string _name; // 姓名
    string _sex; // 性别
public:
    int _age = 18; // 年龄
};

class Student : public Person {
public:
    int _No; // 学号
};

int main() {
    string s1 = "11111";
    const string& s2 = "11111";
    Student sobj; // 赋值兼容转换，特殊处理
    // 1.派生类对象可以赋值给基类的指针/引用
    Person* pp = &sobj;
    Person& rp = sobj;
    rp._age++;
    return 0;
}

接下来通过下面的例子发现，继承后的基类私有变量虽然访问不到，但是我们可以发现它在派生类的对象中依旧占据相应的空间，而经过赋值兼容转换变量的大小为基类的大小。

接下来更加深层的来了解赋值兼容，发现基类的指针或引用在调用重名函数的时候，调用的是父类的函数，而派生类调用时因为隐藏的特点，派生类对象调用的是派生类的函数。

class A {
public:
    void func() {
        cout << "A::func()" << endl;
    }
protected:
    int _a;
    int _b;
private:
    int _c;
};

class B : public A {
public:
    void func() {
        cout << "B::func()" << endl;
    }
public:
    int _d;
};

int main() {
    B obj_b;
    A* ptr_a = &obj_b;
    A& ref_a = obj_b;
    obj_b.func();
    ptr_a->func();
    ref_a.func();
    return 0;
}

2、子类的变量可以复制给父类。

Person pobj = sobj;

三、几个重要细节

（一）继承与作用域

1、作用域

在继承体系中基类和派生类都有独立的作用域。

2、隐藏

派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏（在派生类成员函数中，可以使用基类::基类成员 显式访问）

需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

（二）继承与友元

在继承时，友元关系是不接受继承的。所以如果友元函数需要访问派生类的成员，需要重新声明友元。

（三）继承与静态成员

在继承后，静态成员变量始终只有基类在定义的这一份。通过下面的代码可以发现，我们可以用类域加静态变量的方式来访问静态变量，但是打印的地址是同一份。

class Person {
public:
    string _name;
    static int _count;
};

int Person::_count = 0;

class Student : public Person {
protected:
    int _stuNum;
};

int main() {
    Person p;
    Student s;
    cout << &p._count << endl;
    cout << &s._count << endl;
    cout << Person::_count << endl;
    cout << Student::_count << endl;
    return 0;
}

四、继承中派生类的构造函数

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。基类没有默认的构造函数必须在派生类构造函数的初始化列表阶段显示调用。派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。派生类的 operator= 必须要调用基类的 operator=。需要注意的是派生类的 operator= 隐藏了基类的 operator=，所以指定基类作用域显示调用基类的 operator= 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。才能保证先清理派生类成员再清理基类成员。因为多态中一些场景析构函数需要构成重写。,那么编译器会对析构函数名进行特殊处理，处理成 destructor()，所以基类析构函数不加 virtual 的情况下，派生类析构函数和基类析构函数构成隐藏关系。

class Person {
public:
    Person(const char* name) : _name(name) {
        cout << "Person()" << endl;
    }
    Person(const Person& p) : _name(p._name) {
        cout << "Person(const Person& p)" << endl;
    }
    Person& operator=(const Person& p) {
        cout << "Person operator=(const Person& p)" << endl;
        if (this != &p) _name = p._name;
        return *this;
    }
    // destructor()
    ~Person() {
        cout << "~Person()" << endl;
    }
protected:
    string _name; // 姓名
};

class Student : public Person {
public:
    Student(int num, const char* address, const char* name) : _num(num), _address(address), Person(name) {
        cout << "Student()" << endl;
    }
    Student(const Student& s) : Person(s), _num(s._num), _address(s._address) {
        cout << "Student(const Student& s)" << endl;
    }
    Student& operator=(const Student& s) {
        cout << "Student& operator= (const Student& s)" << endl;
        if (this != &s) {
            _num = s._num;
            _address = s._address;
            Person::operator=(s);
        }
        return *this;
    }
    // destructor()
    ~Student() {
        // 不需要写，子类析构函数结束后，会自动调用父类析构
        // Person::~Person(); 
        cout << "~Student()" << endl;
    }
protected:
    int _num; // 学号
    string _address;
};

五、多继承与菱形继承

（一）多继承

单继承：一个派生类只有一个直接基类时称为单继承 多继承：一个派生类有两个或以上直接基类时称为多继承

多继承的指针偏移问题

多继承对象在内存中的模型是，先继承的基类在前面，后面继承的基类在后面，派生类成员在放到最后面

通过上面的例子，我们可以清晰的认识到基类在派生类的储存情况。

（二）菱形继承

菱形继承：菱形继承是多继承的一种特殊情况，有数据冗余和二义性的问题

class Person {
public:
    string _name; // 姓名
};

class Student : public Person {
protected:
    int _num; // 学号
};

class Teacher : public Person {
protected:
    int _id; // 职工编号
};
// 给类加上 virtual 关键字，解决菱形继承造成的二义性和数据冗余。
// class Student : virtual public Person
// {
// protected:
//     int _num; // 学号
// };
//
// class Teacher : virtual public Person
// {
// protected:
//     int _id; // 职工编号
// };

class Assistant : public Student, public Teacher {
protected:
    string _majorCourse; // 主修课程
};

int main() {
    Assistant obj;
    obj.Student::_name = "张三";
    obj.Teacher::_name = "李四";
    return 0;
}

通过调试窗口，可以发现我们在继承时同时继承了来自 Person 和来自 Teacher 的 _name 我们在写代码时无法处理这个二义性，同时也形成了数据冗余。

（三）虚继承

为了解决这个现象，我们只需要在继承同一个基类成员的派生类加上一个 virtual 关键字，底层会自行加工，使得我们后面访问的 _name 只是一份数据。

class Person {
public:
    string _name; // 姓名
};
// 给类加上 virtual 关键字，解决菱形继承造成的二义性和数据冗余。
class Student : virtual public Person {
protected:
    int _num; // 学号
};

class Teacher : virtual public Person {
protected:
    int _id; // 职工编号
};

class Assistant : public Student, public Teacher {
protected:
    string _majorCourse; // 主修课程
};

int main() {
    Assistant obj;
    obj.Student::_name = "张三";
    obj.Teacher::_name = "李四";
    return 0;
}

下列窗口显示出来的 _name 实则是同一份数据，最开始指定类域 Student:: 初始化 _name 为张三

我们通过 Teacher:: 修改数据为李四，那么数据被修改为李四。

切记，尽量不用使用菱形继承，因为 virtual 关键字在解决问题的同时造成了效率的降低，代价有点大。

六、继承和组合

我们可以发现，组合的好处要大于继承，在两种都可以的情况下，优先使用组合，而不是继承。实际尽量多用组合，组合的耦合度低，代码维护性好。