继承
1.继承
(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) 继承定义
<1> 定义格式
下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。(因为翻译的原因，所以既叫父类/子类，也叫基类/派生类)
<2> 继承父类成员访问方式变化
1. 父类private成员在子类中无论以什么方式继承都是不可见的。这里的不可见是指父类的私有成员还 是被继承到了子类对象中，但是语法上限制子类对象不管在类里面还是类外面都不能去访问它。2. 父类private成员在子类中是不能被访问，如果父类成员不想在类外直接被访问，但需要在子类中能 访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。3. 实际上面的表格我们进行一下总结会发现，父类的私有成员在子类都是不可见。父类的其他成员在子 类的访问方式 == Min(成员在父类的访问限定符，继承方式)，public > protected > private。4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示 的写出继承方式。5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用 protetced/private继承，因为protetced/private继承下来的成员都只能在子类的类里面使用，实际 中扩展维护性不强。
(3) 继承类模版
● 当基类是类模板时，需要指定类域，否则会编译报错。因为stack<int>实例化时，也会实例化vector<int>（构造函数实例化），但是模版遵循按需实例化，如果不指定类域，vector中的push_back等成员函数未实例化，所以会报错。
namespace zyt
{
//template<class T>
//class vector
//{};
// 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()
{
zyt::stack<int> st;
st.push(1);
st.push(2);
st.push(3);
while (!st.empty())
{
cout << st.top() << " ";
st.pop();
}
return 0;
}● 继承类模版可以用多种 容器/容器适配器 来继承，用宏来实现。
//用继承实现栈我们可以定义宏来方便使用多种容器继承
//#define CONTAINER std::vector
//#define CONTAINER std::list
#define CONTAINER std::deque
namespace zyt
{
template<class T>
class stack : public CONTAINER<T>
{
public:
void push(const T& x)
{
CONTAINER<T>::push_back(x);
}
void pop()
{
CONTAINER<T>::pop_back();
}
const T& top()
{
return CONTAINER<T>::back();
}
bool empty()
{
return CONTAINER<T>::empty();
}
};
}
int main()
{
zyt::stack<int> st;
st.push(1);
st.push(2);
st.push(3);
while (!st.empty())
{
cout << st.top() << " ";
st.pop();
}
return 0;
}2.父类和子类对象赋值兼容转换
① public继承的子类对象可以赋值给 父类的对象 / 父类的指针 / 父类的引用。这里有个形象的说法叫切片或者切割。寓意把子类中父类那部分切来赋值过去。② 父类对象不能赋值给子类对象。③ 父类的指针或者引用可以通过强制类型转换赋值给子类的指针或者引用。但是必须是父类的指针是指向子类对象时才是安全的。这里父类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换。（ps：类型转换再讲解）
class Person
{
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._age = 10;//子类可以修改父类
//上述&不产生临时对象
int a = 0;
//double& b = a;
//error:产生了临时对象,而临时对象具有常性(这里引用的是临时对象),发生了权限放大，所以要用const修饰
const double& b = a;
//2.基类对象不能赋值给派生类对象，但是指针/引用强转后可以
//sobj = (Student)pobj;
Student* ps = (Student*)pp;
return 0;
}3.继承中的作用域
(1) 隐藏规则
● 在继承体系中父类和子类都有独立的作用域。● 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏。（在用类成员函数中，可以使用父类::父类成员 显示访问）● 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。● 注意在实际中在继承体系里面最好不要定义同名的成员。
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;
};(2) 考察继承作用域相关选择题
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(); // error
return 0;
};1. A和B类中的两个func构成什么关系（B）A. 重载 B. 隐藏 C.没关系2. 下面程序的编译运行结果是什么（A）A. 编译报错 B. 运行报错 C. 正常运行// 函数名相同就构成隐藏，子类成员将屏蔽父类对同名成员的直接访问，而main函数第三行调用函数并未传参，所以是编译报错。
4.子类的默认成员函数
6个默认成员函数，默认的意思就是指我们不写，编译器会变我们自动生成一个，那么在子类中，这几个成员函数是如何生成的呢？
默认生成构造函数的行为
1、内置类型 ---> 不确定
2、自定义类型 ---> 调用默认构造
3、新添加：继承父类成员看做一个整体对象，要求调用父类的默认构造。
(1) 四个常见的默认成员函数
① 子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。如果父类没有默认的构造函 数，则必须在子类构造函数的初始化列表阶段显示调用。② 子类的拷贝构造函数必须调用父类的拷贝构造完成父类的拷贝初始化。③ 子类的operator=必须要调用父类的operator=完成父类的复制。需要注意的是子类的operator=隐 藏了父类的operator=，所以显示调用父类的operator=，需要指定父类作用域④ 子类的析构函数会在被调用完成后自动调用父类的析构函数清理父类成员。因为这样才能保证子类 对象先清理子类成员再清理父类成员的顺序。⑤ 子类对象初始化先调用父类构造再调子类构造。⑥ 子类对象析构清理先调用子类析构再调父类的析构。⑦ 因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们多态章节会讲 解)。那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。
class Person
{
public:
Person(const char* name = "peter")
: _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)
: Person(name)// 当父类没有可用的默认构造时,显示调用(与构造匿名函数类似)
, _num(num)
{
cout << "Student()" << endl;
}
// 严格是不用写的默认生成的就足够，但当需要进行资源的深拷贝时，就得显示实现
Student(const Student& s)
: Person(s)// 没有给父类成员的参数，用到父类和子类对象赋值兼容转换
, _num(s._num)
{
cout << "Student(const Student& s)" << endl;
}
// 需要深拷贝才实现
Student& operator = (const Student& s)
{
cout << "Student& operator= (const Student& s)" << endl;
if (this != &s)
{
// 构成隐藏，所以需要显⽰调⽤
Person::operator =(s);//切片
_num = s._num;
}
return *this;
}
// 需要释放资源才实现
~Student()
{
// 子类的析构与父类的析构构成隐藏关系(编译器会对所有的析构函数名特殊处理成destructor()...)
// 规定：不需要显示多用，子类析构之后，会自动调用父类析构
// 这样可以保证析构顺序是先子后父(后定义的要先析构)
// 若是显示调用了，就取决于实现的人
//Person::~Person();
cout << "~Student()" << endl;
}
protected:
int _num; // 学号
};
int main()
{
Student s1("jack", 18);
Student s2(s1);
Student s3("rose", 17);
s1 = s3;
return 0;
}
(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;
}
5.继承与友元
友元关系不能继承，也就是说父类友元不能访问子类私有和保护成员。
// 前置声明
class Student;
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);
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;
}6.继承与静态成员
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;//0000007E7AB6F748
cout << &s._name << endl;//0000007E7AB6F788
// 这里的运行结果可以看到静态成员_count的地址是⼀样的
// 说明子类和父类共用同一份静态成员
cout << &p._count << endl;//00007FF7D60E0440
cout << &s._count << endl;//00007FF7D60E0440
// 公有的情况下，父子类指定类域都可以访问静态成员
cout << Person::_count << endl;//0
cout << Student::_count << endl;//0
return 0;
}7.多继承及其菱形继承问题
(1) 继承模型
① 单继承：一个子类只有一个直接父类时称这个继承关系为单继承② 多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承，多继承对象在派生类内存中的模型是，先继承的父类在前面，后面继承的父类在后面，子类成员在放到最后面。③ 菱形继承：菱形继承是多继承的一种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份。支持多继承就一 定会有菱形继承，像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()
{
Assistant a;
// 编译报错：error C2385: 对“_name”的访问不明确
a._name = "peter";
// 需要显⽰指定访问哪个⽗类的成员可以解决二义性问题，但是数据冗余问题⽆法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
return 0;
}(2) 虚继承（解决数据冗余和二义性）
使用虚继承相当于将基类成员公有！
注意：规定派生类初始化要调用基类，所以初始化列表要指定直接父类，但是基类成员公有后，编译器不走虚继承派生类中的父类构造。
// 不要实现菱形继承
class Person
{
public:
Person(const char* name)
:_name(name)
{}
public:
string _name; // 姓名
};
// 使用虚继承Person类(相当于将基类成员公有)
class Student : virtual public Person
{
public:
Student(const char* name,int num = 0)
:Person(name) // 必须写但编译器不走
,_num(num)
{}
protected:
int _num; //学号
};
// 使用虚继承Person类
class Teacher : virtual public Person
{
public:
Teacher(const char* name, int id = 1)
:Person(name) // 必须写但编译器不走
, _id(id)
{}
protected:
int _id; // 职工编号
};
// 教授助理
class Assistant : public Student, public Teacher
{
public:
Assistant(const char* name1,const char* name2,const char* name3)
:Student(name1)// 但不能不写直接父类，规定子类初始化是要调用父类
,Teacher(name2)
,Person(name3)// 只会调用Person的
{}
protected:
string _majorCourse; // 主修课程
};
int main()
{
// 使⽤虚继承，可以解决数据冗余和二义性
Assistant a("zs", "ls", "ww");
//a._name = "peter";
return 0;
}(3) 多继承中的指针偏移问题
下列说法正确的是 (C)
A:p1 == p2 == p3 B: p1 < p2 < p3 C: p1 == p4 !== 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; // 0x0000002722cffc18
Base2* p2 = &d; // 0x0000002722cffc1c
Derive* p3 = &d; // 0x0000002722cffc18
return 0;
}先继承的基类成员会在派生类对象的内存中排在前面（只适用于非虚继承） 。
如果将继承顺序交换：
class Derive : public Base2, public Base1 { public: int _d; };那么其内存顺序就会是：
▶ 需要注意的是，折中内存布局的顺序值适用于非虚继承。在虚继承中，最顶部的基类（即被虚继承的基类）的成员会在派生类对象的内存布局中排到最前面，以确保只有一个基类成员的实例存在。其他通过虚继承得到的基类成员会根据它们在派生类中的声明顺序排列，但它们不会影响最顶部基类成员的位置。
(4) 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>
{};8.继承和组合
// 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>
class vector
{};
// stack和vector的关系，既符合is-a，也符合has-a
//继承
template<class T>
class stack : public vector<T>
{};
template < class T>
// 组合(推荐)
class stack
{
public:
vector<T> _v;
};
int main()
{
return 0;
}