C++：继承机制详解
目录
一.继承的概念及定义
一）.继承的概念
二）.继承定义
1.定义格式
2.继承类型
3.继承类模板
二.基类和派生类间的转换
三.继承中的作用域
四.派生类的默认成员函数
一）.4个常见默认成员函数
二）.不可被继承的类
五.友元与静态成员
一）.友元
二）.静态成员
六.多继承及其菱形继承
一）.继承模型
二）.虚继承
七. IO库中的菱形虚拟继承
八.继承和组合
一.继承的概念及定义
一）.继承的概念
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复用，继承是类设计层次的复用。
我们公共的成员都放到Person类中，Student和teacher都继承Person，就可以复用这些成员，就不需要重复定义了，省去了很多麻烦
#include <iostream>
#include <string>using namespace std;class Person
{
public:void identity(){cout << "void identity()" << _name << endl;cout << _age << endl;}
protected:string _name = "张三"; // 姓名string _address; // 地址string _tel; // 电话
private:int _age = 18; // 年龄
};class Student : public Person //继承
{
public:void study(){//}
private:int _stuid; // 学号
};class Teacher : public Person //继承
{
public:// 授课void teaching(){//}
protected:string title; // 职称
};int main()
{Student s;Teacher t;s.identity();t.identity();return 0;
}二）.继承定义
1.定义格式
Person是基类，也称作父类。Student是派生类，也称作子类
2.继承类型
| 子类继承方式 | 父类public成员 | 父类protected成员 | 父类private成员 |
|---|---|---|---|
| public继承 | public | protected | 不可访问 |
| protected继承 | protected | protected | 不可访问 |
| private继承 | private | private | 不可访问 |
1.基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2.基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3.实际上面的表格我们进行一下总结会发现，基类的私有成员在派生类都是不可见。基类的其他成员在派生类的访问方式 == Min(成员在基类的访问限定符，继承方式)，
public > protected >private。
4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
5.在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
class Base {
public:void func() {}
};class Derived : private Base { // 私有继承
public:void useBase() {func(); // 正确：在派生类内部可访问基类public成员}
};int main() {Derived d;d.func(); // 错误：Base::func()在Derived中变为private
}3.继承类模板
//#define CONTAINER std::vector
//#define CONTAINER std::list
#define CONTAINER std::dequenamespace bit
{template<class T>class stack : public CONTAINER<T>{public:void push(const T& x){// 基类是类模板时，需要指定⼀下类域，// 否则编译报错:error C3861: “push_back”: 找不到标识符// 模版是按需实例化，push_back等成员函数未实例化，所以找不到//push_back(x);CONTAINER<T>::push_back(x);}void pop(){CONTAINER<T>::pop_back();}};
}二.基类和派生类间的转换
1.public继承的派生类对象 可以赋值给 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。
2.基类对象不能赋值给派生类对象。
3.基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换。
class Person
{
protected:virtual void func(){}
public:string _name; // 姓名string _sex; // 性别int _age; // 年龄
};class Student : public Person
{
public:int _No; // 学号
};int main()
{Student sobj;// 1.子类对象可以赋值给父类对象/指针/引用Person pobj = sobj; //这里类型转换没有产生临时对象Person* pp = &sobj;Person& rp = sobj;rp._name = "张三";//2.父类对象不能赋值给子类对象，这里会编译报错//sobj = (Student)pobj;Student* ps1 = dynamic_cast<Student*>(pp);cout << ps1 << endl;//3.不是安全的操作C++20----ps2的地址为00000000，C++11会报错pp = &pobj;Student* ps2 = dynamic_cast<Student*>(pp);cout << ps2 << endl;return 0;
}三.继承中的作用域
1. 在继承体系中基类和派生类都有独立的作用域。
2. 派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派生类成员函数中，可以使用 基类::基类成员 显示访问）。
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 注意在实际中在继承体系里面最好不要定义同名的成员。
// Student的_num和Person的_num构成隐藏关系。
class Person
{
protected:string _name = "小李子"; // 姓名int _num = 111; // 身份证号
};class Student : public Person
{
public:void Print(){cout << _num << endl;//cout << Person::_num << endl;}
protected:int _num = 999; // 学号
};int main()
{Student s;s.Print(); //999return 0;
}
小试牛刀
1.下图中A和B类中的两个fun构成什么关系 （）
A.继承 B.隐藏 C.没关系
答案：B.隐藏。函数重载需要在同一作用域里
2.结合上面的代码，运行这段程序会发生什么（）
A.编译报错 B.运行报错 C.正常运行
答案：A.编译报错。B对A的fun函数进行了隐藏，B类中无无参的fun函数。正确用法A::fun()。
四.派生类的默认成员函数
一）.4个常见默认成员函数
1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2.派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化 。
3.派生类的operator=必须要调用基类的operator=完成基类的复制。需要注意的是派生类的operator=隐藏了基类的operator=，所以显示调用基类的operator=，需要指定基类作用域
4.派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5.派生类对象初始化先调用基类构造再调派生类构造。
6.派生类对象析构清理先调用派生类析构再调基类的析构。
7.因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同，，那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系。
class Person
{
public:Person(const char* name = "xxx"): _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;}~Person(){cout << "~Person()" << endl;}
protected:string _name; // 姓名
};class Student : public Person
{
public:Student(const char* name, int num, const char* addrss):Person(name), _num(num), _addrss(addrss){}// 严格说Student拷贝构造默认生成的就够用了// 如果有需要深拷贝的资源，才需要自己实现Student(const Student& s):Person(s), _num(s._num), _addrss(s._addrss){// 深拷贝}// 严格说Student赋值重载默认生成的就够用了// 如果有需要深拷贝的资源，才需要自己实现Student& operator=(const Student& s){if (this != &s){// 父类和子类的operator=构成隐藏关系Person::operator=(s);_num = s._num;_addrss = s._addrss;}return *this;}// 严格说Student析构默认生成的就够用了// 如果有需要显示释放的资源，才需要自己实现// 析构函数都会被特殊处理成destructor() ~Student(){// 子类的析构和父类析构函数也构成隐藏关系// 规定：不需要显示调用，子类析构函数之后，会自动调用父类析构// 这样保证析构顺序，先子后父，显示调用取决于实现的人，不能保证// 先子后父//Person::~Person();//delete _ptr;}
protected:int _num = 1; //学号string _addrss = "西安市高新区";int* _ptr = new int[10];
};int main()
{Student s1("张三", 1, "西安市");Student s2(s1);Student s3("李四", 2, "咸阳市");s1 = s3;/*Person* ptr = new Person;delete ptr;*/return 0;
}二）.不可被继承的类
方法一：基类的构造函数私有，派生类的构成必须调用基类的构造函数，但是基类的构成函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象
class Base
{
public:void func5() { cout << "Base::func5" << endl; }
protected:int a = 1;
private:///C++98的⽅法Base(){}
};方法二：C++11新增了一个final关键字，final修改基类，派生类就不能继承了
class Base final // C++11 禁止被继承
{
public:void func5() { cout << "Base::func5" << endl; }
protected:int a = 1;
};五.友元与静态成员
一）.友元
友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员
//前置声明
class Student;class Person
{
public:// 友元关系不能被继承friend void Display(const Person& p, const Student& s);
protected:string _name; // 姓名
};class Student : public Person
{//friend void Display(const Person& p, const Student& s);
protected:int _stuNum; // 学号
};void Display(const Person& p, const Student& s)
{cout << p._name << endl;cout << s._stuNum << endl;
}int main()
{Person p;Student s;// 编译报错：error C2248: “Student::_stuNum”: 无法访问 protected 成员// 解决方案：Display也变成Student 的友元即可Display(p, s);return 0;
}二）.静态成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类，都只有⼀个static成员实例
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;// 这里的运行结果可以看到非静态成员_name的地址是不一样的// 说明子类继承下来了，父子类对象各有一份cout << &p._name << endl;cout << &s._name << endl;// 这里的运行结果可以看到静态成员_count的地址是一样的// 说明子类和父类共用同一份静态成员cout << &p._count << endl;cout << &s._count << endl;// 公有的情况下，父子类指定类域都可以访问静态成员cout << Person::_count << endl;cout << Student::_count << endl;Person::_count++;cout << p._count << endl;cout << s._count << endl;return 0;
}六.多继承及其菱形继承
一）.继承模型
单继承：一个派生类只有一个直接基类时称这个继承关系为单继承。
多继承：一个派生类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后面继承的基类在后面，派生类成员在放到最后面。
菱形继承：菱形继承是多继承的一种特殊情况，菱形继承有数据冗余和二义性的问题。支持多继承就一定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。
解决方法：
class A
{
public:int data;
};class B : public A {};
class C : public A {};
class D : public B, public C {}; // D包含两份A的成员int main()
{D d;// d.data = 10; // 错误：歧义d.B::data = 10; // 明确指定路径d.A::data = 20;// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
}二）.虚继承
C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有一些损失，所以最好不要设计出菱形继承。
class A
{
public:int data;
};
class B : virtual public A {}; // 虚继承
class C : virtual public A {};
class D : public B, public C {}; // 只含一份A的成员int main()
{D d;d.data = 10; // 正确：无歧义
}小试牛刀
下面程序中多继承中指针偏移问题？下面说法正确的是（）
A：p1 == p2 == p3 B：p1 < p2 < p3
C：p1 == p3 != p2 D：p1 != p2 != p3
答案：C：p1 == p3 != p2 。
七. IO库中的菱形虚拟继承
template<class CharT, class Traits = std::char_traits<CharT>>
class basic_ostream : virtual public std::basic_ios<CharT, Traits>
{//
};
template < class CharT, class Traits = std::char_traits<CharT>>
class basic_istream : virtual public std::basic_ios<CharT, Traits>
{//
};八.继承和组合
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
继承允许你根据基类的实现来定义派生类的实现。在继承方式中，基类的内部细节对派生类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
优先使用组合，而不是继承。实际尽量多去用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承(is-a)也适合组合(has-a)，就用组合。
// Tire(轮胎)和Car(⻋)更符合has-a的关系class Tire {
protected:string _brand = "Michelin"; // 品牌size_t _size = 17; // 尺⼨
};
class Car {
protected:string _colour = "⽩⾊"; // 颜⾊string _num = "陕ABIT00"; // ⻋牌号Tire _t1; // 轮胎Tire _t2; // 轮胎Tire _t3; // 轮胎Tire _t4; // 轮胎
};
class BMW : public Car
{
public:void Drive() { cout << "好开-操控" << endl; }
};// Car和BMW/Benz更符合is-a的关系
class Benz : public Car {
public:void Drive() { cout << "好坐-舒适" << endl; }
};// stack和vector的关系，既符合is-a，也符合has-atemplate<class T>
class vector
{};template<class T>
class stack : public vector<T>
{};template<class T>
class stack
{public :vector<T> _v;
};