感谢大佬的光临各位，希望和大家一起进步，望得到你的三连，互三支持，一起进步
收入专栏：C++_LaNzikinh篮子的博客-CSDN博客
前言
我们前面讲了模板进阶的全部内容，今天我们要进入C++里面更深层的内容了，今天我们来讲解C++的继承
一.什么是继承
继承的概念
继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，以前我们接触的函数层次的复用，继承是类设计层次的复用。
什么是复用呢？我们以前在实现栈与队列的时候，头插尾插时我们就用了复用这个概念，我们实现了随机一个地方插入或者随机一个地方删除的时候，那么头差和尾差就可以利用调用这两个函数去实现，就不需要我再写代码了，这个就是函数的复用。那么类的复用呢？该如何复用呢？继承就是有关于类的复用。
继承举例
比如说现在我需要定义一个学生和一个老师的嘞，我该如何定义呢？
这里只举一个简单的例子，其实还有很多的行为，比如说住房地址，电话号码等等这里我就列举一点点
class Student
{
public:
// 学习
void study()
{
// ...
}
protected:
string _name = "黄姨妈";
int _age = 18;
//特殊的
int _stuid; // 学号
};
class Teacher
{
public:
// 授课
void teaching()
{
//...
}
protected:
string _name = "文字间";
int _age = 18;
//特殊的
string _title; // 职称
};这样子你就会发现，其实代码非常的冗余，如果我的个人性质再多一点的话，这样子写的就很复杂，所以这个时候我可以单拿出一个类用来继承，比如是我定义一个人的类
class Person
{
protected:
string _name = "张三";
int _age = 18; // 年龄
};
然后写法就可以用继承的方式去复用了，只需要写自己特别的就可以了
class Student : public Person
{
public:
// 学习
void study()
{
// ...
}
protected:
//特殊的
int _stuid; // 学号
};
class Teacher : public Person
{
public:
// 授课
void teaching()
{
//...
}
protected:
//特殊的
string title; // 职称
};二.继承定义
格式
Person是基类，也称作父类。Student是派生类，也称作子类
继承基类成员访问方式
我们在这个地方需要明白继承方式和访问限定服的区别，他们两个是两种概念
1.基类private成员在派生类中无论以什么方式继承都是不可见的。
2.基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3.实际上面的表格我们进行一下总结会发现，基类的私有成员在派生类都是不可见。基类的其他成员 在派生类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。这句话怎么理解呢？就是说基类的成员，他的访问方式是什么，去对比派生类的继承方式，哪个小那么基类在派生内中的访问方式就是哪个。
4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
我们实现栈与队列的时候，我们就可以直接要栈去继承vector了
三.继承中的作用域
隐藏规则
1. 在继承体系中基类和派生类都有独立的作用域。
2. 派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派生类成员函数中，可以使用基类::基类成员显示访问）
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 注意在实际中在继承体系里面最好不要定义同名的成员。
注意：他和重载的区别，重载是要在一个作用域里面的，而他是在两个独立的作用域里面的，一旦基类被隐藏了，就无法通过派生类去访问到基类。
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
cout << "func(int i)" <<i<<endl;
}
};
int main()
{
B b;
b.fun(10);
b.fun();
return 0;
};这个程序就会出现编译报错，因为子类和父类的函数名相同，所以构成隐藏，B对象无法通过子类去访问到父类，所以就会编译报错。
四.子类的默认成员函数
1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。需要注意的是派生类的 operator=隐藏了基类的operator=，所以显示调用基类的operator=，需要指定基类作用域
4. 派生类的析构函数会在被调用完成后，自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理，派生类成员再清理基类成员的顺序。派生类对象析构清理先调用派生类析构再调基类的析构
5. 派生类对象初始化先调用基类构造再调派生类构造。
class Person
{
public :
//构造
Person(const char* name = "peter")
: _name(name )
{
}
//拷贝构造
Person(const Person& p)
: _name(p._name)
{
}
//赋值
Person& operator=(const Person& p )
{
if (this != &p)
_name = p ._name;
return *this ;
}
//析构
~Person()
{
}
protected :
string _name ; // 姓名
};
class Student : public Person
{
public :
//构造
Student(const char* name, int num)
: Person(name)
, _num(num )
{
}
//拷贝构造
Student(const Student& s)
: Person(s)
, _num(s ._num)
{
}
//赋值
Student& operator = (const Student& s )
{
if (this != &s)
{
// 构成隐藏，所以需要显⽰调⽤
Person::operator =(s);
_num = s ._num;
}
return *this ;
}
//析构
~Student()
{
}
protected :
int _num ; //学号
};
int main()
{
Student s1 ("jack", 18);
Student s2 (s1);
Student s3 ("rose", 17);
s1 = s3 ;
return 0;
}
基类和派生类间的转换
public继承的派生类对象可以赋值给基类的指针/基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。基类对象不能赋值给派生类对象。
class Person
{
protected :
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public :
int _No ; // 学号
};
int main()
{
Student sobj ;
// 1.派⽣类对象可以赋值给基类的指针/引⽤
//切片
Person* pp = &sobj;
Person& rp = sobj;
//子类对象可以赋值给基类的对象，是通过调⽤基类的拷⻉构造完成的
Person pobj = sobj;
//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错
sobj = pobj;
return 0;
}
五.不能被继承的类
如果我要一个类，无法被其他的类继承，该怎么做了？
方法1：基类的构造函数私有，派生类的构成必须调用基类的构造函数，但是基类的构成函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。
class Base
{
protected:
int a = 1;
private:
Base()
{}
};
//不能
class Derive :public Base
{
}方法2：C++11新增了⼀个final关键字，final修改基类，派生类就不能继承了。
class Base final
{
public:
void func5() { cout << "Base::func5" << endl; }
protected:
int a = 1;
};
//不能
class Derive :public Base继承与友元
友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员
class Person
{
public:
friend void Display(const Person& p, const Student& s);
protected:
string _name; // 姓名
};
class Student : public Person
{
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成员实例。
六.多继承及其菱形继承问题
单继承：一个派生类只有一个直接基类时称这个继承关系为单继承
多继承：一个派生类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后⾯继承的基类在后面，派生类成员在放到最后面。
菱形继承：菱形继承是多继承的一种特殊情况。从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，支持多继承就一定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型。
class Person
{
public:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _num; //学号
};
class Teacher : public Person
{
protected:
int _id; // 职⼯编号
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse; // 主修课程
};
int main()
{
// 编译报错：error C2385: 对“_name”的访问不明确
Assistant a;
a._name = "peter";
// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
return 0;
}解决方式：
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在 Student和Teacher的继承 Person时使用虚拟继承（继承方式前面加 virtual），即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。
// 使⽤虚继承Person类
class Student : virtual public Person
{
protected:
int _num; //学号
};
// 使⽤虚继承Person类
class Teacher : virtual public Person
{
protected:
int _id; // 职⼯编号
};
注意：哪个类产生了数据冗余和二义性，继承时用虚继承！！！
class 派生类名：virtual 继承方式 基类名
七.继承和组合
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
黑盒测试：不了解底层，实现从功能角度测试。
白盒测试：了解底层，实现从代码运行逻辑角度测试。
继承-—>白盒复用，依赖关系高，耦合度高。
组合-—>黑盒复用，依赖关系低，耦合度低。
优先使用组合，而不是继承。实际尽量多去用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承(is-a)也适合组合(has-a)，就用组合。
举例
有一个轮胎和车子的话，肯定更符合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; // 轮胎
};有一个车子品牌和车子的话，肯定更符合is-a的继承关系，每个车子品牌都具有车子的性质
stack和vector的关系，既符合is-a，也符合has-a，所以都可以使用
//is-a
template<class T>
class stack : public vector<T>
{};
//has-a
template<class T>
class stack
{
public:
vector<T> _v;
};
总结
继承机制是面向对象程序设计使代码可以复用的最重要的手段，下一节我们要讲解面向对象程序设计的第三个机制，多态。