C++----继承

1 继承的概念

继承(inheritance)机制是⾯向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复用，继承是类设计层次的复用

下面我们看到没有继承之前我们设计了两个类Student和Teacher，Student和Teacher都有姓名/地址/电话/年龄等成员变量，都有identity身份认证的成员函数，设计到两个类里面就是冗余的。当然他们也有⼀些不同的成员变量和函数，比如老师独有成员变量是职称，学生的独有成员变量是学号；学生的独有成员函数是学习，老师的独有成员函数是授课。

class Student
{
public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 void identity(){// ...}// 学习 void study(){// ...}
protected:string _name = "peter"; // 姓名 string _address; // 地址 string _tel; // 电话 int _age = 18; // 年龄 int _stuid; // 学号 
};
class Teacher
{
public:
// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 void identity(){// ...}// 授课 void teaching(){//...}
protected:string _name = "张三"; // 姓名 int _age = 18; // 年龄 string _address; // 地址 string _tel; // 电话 string _title; // 职称 
};
int main()
{return 0;
}

下面我们公共的成员都放到Person类中，Student和teacher都继承Person，就可以复⽤这些成员，就不需要重复定义了，省去了很多麻烦。

class Person
{
public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 void identity(){cout << "void identity()" <<_name<< endl;}
protected:string _name = "张三"; // 姓名 string _address; // 地址 string _tel; // 电话 int _age = 18; // 年龄 
};class Student : public Person
{
public:// 学习 void study(){// ...}
protected:int _stuid; // 学号 
};
class Teacher : public Person
{
public:// 授课 void teaching(){//...}
protected:string title; // 职称 
};
int main()
{Student s;Teacher t;s.identity();t.identity();return 0;
}

2. 继承定义

2.1 定义格式

下⾯我们看到Person是基类，也称作⽗类。Student是派⽣类，也称作⼦类。(因为翻译的原因，所以既叫基类/派⽣类，也叫⽗类/⼦类)

2.2 继承基类成员访问⽅式的变化

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。
这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类
中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
根据上面的表格，我们总结一下会发现，基类的私有成员在派生类都是不可见的。

基类的其他成员在派生类的访问方式 == Min(成员在基类的访问限定符，继承方式)
public >protected>private

也就是说基类如果是公有的成员，但是我们派生类是以私有或者保护继承的基类，那么基类的公有成员在派生类的访问方式就变成了私有或者保护。

我们用关键字class时默认的继承方式是private，默认的访问限定符也是private，使用struct时默认的继承方式是public，默认的访问限定符也是public

在实际运用中⼀般使用都是public继承，几乎很少使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际一般都要在类外也要访问到。

2.3 继承类模板

namespace bit
{// stack和vector的关系，既符合is-a，也符合has-a template<class T>class stack : public std::vector<T>{public:void push(const T& x){// 基类是类模板时，需要指定⼀下类域， // 否则编译报错:error C3861: “push_back”: 找不到标识符 // 因为stack<int>实例化时，也实例化vector<int>了 // 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到 vector<T>::push_back(x);  //push_back(x);}void pop(){vector<T>::pop_back();}const T& top(){return vector<T>::back();}bool empty(){return vector<T>::empty();}};
}
int main()
{bit::stack<int> st;st.push(1);st.push(2);st.push(3);while (!st.empty()){cout << st.top() << " ";st.pop();}return 0;
}

3. 基类和派生类间的转换

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

2. 基类对象不能赋值给派生类对象。

3. 基类的指针或者引用可以通过强制类型转换赋值给派⽣类的指针或者引⽤。但是必须是基类的指针是指向派⽣类对象时才是安全的。

这里就是切割

class Person
{
protected :string _name; // 姓名 string _sex; // 性别 int _age; // 年龄 
};class Student : public Person
{
public :int _No ; // 学号 
};int main()
{Student sobj ;Person* pp = &sobj;  //派⽣类对象可以赋值给基类的指针/引⽤ Person& rp = sobj;// 派⽣类对象可以赋值给基类的对象是通过调⽤基类的拷⻉构造完成的 Person pobj = sobj;// 基类对象不能赋值给派⽣类对象，这⾥会编译报错 sobj = pobj;return 0;
}

4. 继承中的作用域

4.1 隐藏规则

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

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

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

4. 在实际中在继承体系里面最好不要定义同名的成员，否则很容易混淆。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
// Student的_num和Person的_num构成隐藏关系，这里的代码虽然能跑，但是常容易混淆 
class Person
{
protected:string _name ="李白"; // 姓名 int _num = 111; // ⾝份证号 
};
class Student : public Person
{
public:void Print(){cout << "姓名:" << _name<< endl;cout << "身份证号:"<<Person::_num << endl;cout << "学号:" << _num << endl;}
protected:int _num = 999; // 学号 
};
int main()
{Student s1;s1.Print();return 0;
};

4.2 考察继承作用域相关选择题

A和B类中的两个func构成什么关系（）
A.重载 B.隐藏 C.没关系

下⾯程序的编译运行结果是什么（）
A. 编译报错 B. 运行报错 C. 正常运行

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，因为如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

第二题选A，因为基类的成员函数被隐藏了，这里会编译报错说函数调用中的参数太少，因为编译是语法错误，这里参数不匹配从语法上就错了。

5. 派⽣类的默认成员函数

5.1 4个常⻅默认成员函数

4个常见的默认成员函数，默认的意思就是指我们不写，编译器会变我们自动生成⼀个，那么在派生类中，这几个成员函数是如何生成的呢？

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那⼀部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。需要注意的是派生类的
operator=隐藏了基类的operator=，所以显示调用基类的operator=，需要指定基类作用域

4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

7. 因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同，那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系。

5.2 总结：

默认情况下：

构造：子类成员 内置类型 (有缺省值就用，没有不确定) 和自定义类型 (默认构造) + 父类成员(必须调用父类默认构造)

拷贝构造：子类成员 内置类型(值拷贝)和自定义类型(这个类型拷贝构造) + 父类成员(必须调用父类拷贝构造)

赋值重载：子类成员 内置类型(值拷贝)和自定义类型(这个类型的赋值重载) + 父类成员(必须调用父类的赋值重载)

析构：子类成员 内置类型(不处理)和自定义类型(调用他的析构) + 父类成员(调用他的析构)
自己实现的话，注意不需要显示调用父类析构，子类析构函数结束后，会自动调用父类析构

5.3 基类

5.4 派生类

1. 这里就是基类没有默认构造，因为有参构造，我们自己写了有参构造，编译器就不会生成默认构造，所以这里必须在派生类构造函数的初始化列表阶段显示调用，否则报错，其它的一样。

实现⼀个不能被继承的类

方法1：基类的构造函数私有，派生类的构成必须调用基类的构造函数，但是基类的构成函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。

方法2：C++11新增了⼀个final关键字，final修改基类，派生类就不能继承了。

// C++11的⽅法 
class Base final
{
public:void func5() { cout << "Base::func5" << endl; }
protected:int a = 1;
private:// C++98的⽅法 /*Base(){}*/};class Derive :public Base 
{void func4() { cout << "Derive::func4" << endl; }
protected:int b = 2;
};
int main()
{Base b;Derive d;return 0;
}

继承与友元

友元关系不能继承，也就是说基类友元不能访问派⽣类私有和保护成员。

class Person
{
public:friend void Display(const Person& p, const Student& s);protected:string _name; // 姓名 
};class Student : public Person
{
public:
// friend void Display(const Person& p, const Student& s); //解决⽅案：Display也变成Student的友元即可 protected:int _stuNum; // 学号 
};void Display(const Person& p, const Student& s)
{cout << p._name << endl;cout << s._stuNum << endl; // 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员 //解决⽅案：Display也变成Student的友元即可 
}
int main()
{Person p;Student s;Display(p, s);return 0;
}

5. 继承与静态成员

基类定义了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;return 0;
}

6. 多继承及其菱形继承问题

6.1 继承模型

单继承：⼀个派生类只有⼀个直接基类时称这个继承关系为单继承。

多继承：⼀个派生类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是 先继承的基类在前面，后面继承的基类在后面，派生类成员在放到最后面。

菱形继承：菱形继承是多继承的一种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份。支持多继承就⼀定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。

6.11 单继承：

6.12 多继承

6.13 菱形继承

6.14 菱形继承的问题

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()
{Assistant a;a._name = "peter";  // 编译报错：error C2385: 对“_name”的访问不明确 // 需要显示指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题无法解决//因为会有两个name导致数据重复冗余a.Student::_name = "xxx";a.Teacher::_name = "yyy";return 0;
}

7. 虚继承

C++语法之所以复杂，其实多继承就是⼀个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有⼀些损失，所以最好不要设计出菱形继承。多继承可以认为是C++的缺陷之⼀，后来的⼀些编程语言都没有多继承，如Java。

class Person
{
public:string _name; // 姓名 
};// 使⽤虚继承Person类 
class Student : virtual public Person
{
protected:int _num; //学号 
};// 使用虚继承Person类 
class Teacher : virtual public Person
{
protected:int _id; //职工编号 
};// 教授助理 
class Assistant : public Student, public Teacher
{
protected:string _majorCourse; // 主修课程 
};int main()
{Assistant a;  //使用虚继承，可以解决数据冗余和⼆义性 a._name = "peter"; //相当于引用，都指向一块空间，所以就没有这些问题。 return 0;
}

我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，无论是使用还是底层都会复杂很多。当然有多继承语法支持，就⼀定存在会设计出菱形继承，所以后面像Java这种语言就不支持多继承了，也就避开了菱形继承。

8. 继承和组合

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; }
};template<class T> //stack和vector的关系，
class vector
{};template<class T>
class stack : public vector<T> //既符合is-a
{};template<class T>
class stack
{
public:vector<T> _v;  //也符合has-a 
};
int main()
{return 0;
}

多继承中指针偏移问题？下⾯说法正确的是()
A：p1 == p2 == p3
B：p1 < p2 < p3
C：p1 == p3 != p2
D：p1 != p2 != p3

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main()
{Derive d;Base1* p1 = &d;Base2* p2 = &d;Derive* p3 = &d;return 0;
}

根据类的对象模型：在内存中先声明的在前面，先继承的在前面，所以这里就是这样一个指向，父类指针会自动切取只属于父类的成员，也叫做切片，p2会自动偏移指向Base2。