1)继承

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

---

class Mike : public Mother, public Teacher, ...

解释：

1. ‘:’表示继承 ','表示继承多个父类
2. public表示继承方式
3. Mother，Teacher…表示父类

---

①继承父类成员访问方式的变化

private和protected的区别：
基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的

类成员/继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的protected成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可见

注意：

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它
2. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private
3. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式
4. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用 protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强

---

②父子类赋值转换

切片是天然行为，不存在类型转换(中间不会产生临时变量)

1. 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用
   (也就是切片，将属于父类的那一部分成员变量切割出来，不包括成员函数)
   注意：只适用于public继承方式，其他方式访问限定符变了，不能赋值
2. 基类对象不能赋值给派生类
3. 对象基类的指针可以通过强制类型转换赋值给派生类的指针，但是必须是基类的指针是指向派生类对象时才是安全的 这里基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换

Person p;
Student s;
//public继承
p = s;       //切片:父类对象=子类对象
Person* ptr = &s;//父类指针=子类对象
Person& ref = s; //父类引用=子类对象

---

③隐藏(重定义)

在继承体系中基类和派生类都有独立的作用域，当子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义

注意：

1. 如果是成员函数的隐藏，只需要函数名相同就构成隐藏
2. 如果想显式访问，可以 父类::父类成员，若未说明作用域，遵循局部优先，在自己的作用域搜索
3. 在实际中在继承体系里面最好不要定义同名的成员
4. 与重载区别：重载的条件是在在同一作用域

④子类的4个默认成员函数(const取地址略)

有一个Person父类和Student子类：

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:
	//4个默认成员函数
private:
	int _id;
	string _address;
};

子类构造函数

子类构造函数 – 我们不写，编译器默认生成

1. 继承的父类成员作为一个整体调用父类的默认构造函数初始化
2. 自己的自定义类型成员调用它的默认构造函数
3. 自己的内置类型成员不处理(除非给了声明时缺省值)

Student(const char* name, int id, const char* address)
	:Person(name)
	, _id(id)
	, _address(address)
{}

注意：

1. 当没写子类的默认构造函数，会生成默认构造函数去调用父类的默认构造函数(无参，全缺省，系统默认生成的)，当父类没有默认构造函数就会报错
2. 只要写了拷贝构系统就不会自动生成默认构造(复习)
3. 如果将Person(name)写为_name(name)编译器会报错，注意一定是作为一个整体
4. 当在初始化列表不写Person(name)的时候，仍然会自动调用Person父类的默认构造，参考C++初阶—类和对象(类的默认成员函数和其他) 初始化列表部分

子类拷贝构造

拷贝构造也是构造
子类拷贝构造函数 – 我们不写，编译器默认生成（子类涉及到深浅拷贝时需要自己写）

1. 继承的父类成员作为一个整体调用父类的拷贝构造
2. 自己的自定义类型成员调用它的拷贝构造
3. 自己的内置类型成员值拷贝

Student(const Student& s)
	:_id(s._id)
	, _address(s._address)
	, Person(s)
{}

注意：

1. 如果不写Person(s)，只会去调用父类的默认构造而不是拷贝构造
2. 父类的拷贝构造参数是const Person& p，子类Person(s)调用父类拷贝构造，本质是切片行为const Person& p = s

子类赋值重载

子类拷贝赋值函数 – 我们不写，编译器默认生成（一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝）

1. 继承的父类成员作为一个整体调用父类的拷贝赋值重载
2. 自己的自定义类型成员调用它的拷贝赋值重载
3. 自己的内置类型成员值拷贝

Student& operator=(const Student& s)
{
	if (this != &s)
	{
		_id = s._id;
		_address = s._address;
		Person::operator=(s); // 切片
	}
	return *this;
}

注意：

1. Person::operator=(s);如果不指定Person域会造成递归栈溢出
2. Person::operator=(s);本质也是切片行为
3. 不会默认调用父类的赋值运算符重载，这里必须显式调用

子类析构函数

子类析构函数 – 我们不写，编译器默认生成

1. 继承的父类成员作为一个整体调用父类的析构函数
2. 自己的自定义类型成员调用它的析构函数
3. 自己的内置类型成员不处理

~Student()
{
	//Person::~Person();
	// 清理自己的资源，自动调用父类的析构函数
}

注意：

1. 子类的析构函数在执行结束会后，会默认自动调用父类的析构函数(形成栈的特征，后进先出)，C++规定先构造父类再构造子类
2. 当要显式调用父类的析构函数必须加上Person::类域，编译期会对析构函数名做特殊处理，所有类的析构函数都会被处理为destructor()函数名，构成隐藏关系，同时显式调用父类的析构函数后会造成重复析构
3. 为什么编译期会对析构函数名做特殊处理？ 析构函数要构成多态重写

---

⑤友元

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

---

⑥静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例
静态成员初始化参考C++初阶—类和对象(类的默认成员函数和其他)中的static成员部分

---

⑦菱形继承

下图从左到右依次为单继承，多继承，菱形继承
菱形继承的问题：可以看出菱形继承有数据冗余和二义性的问题，grandson对象中father成员有两份

---

如下代码：有这样四个类（构成菱形继承）

class A {
public:
	int _a;
};
class B : public A {
public:
	int _b;
};
class C : public A {
public:
	int _c;
};
class D : public B ,public C{
public:
	int _d;
};

在main函数中这样调用会报错 (二义性)

D d;
d._a = 1;
d._b = 3;
d._c = 4;
d._d = 5;

而这样调用：

D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;

打开监视内存 (VS是小端机)，设置四字节为一行 ，单步调试，可以发现：

⑧虚继承(virtual)

虚继承可以解决菱形继承冗余问题

将菱形继承中的B C类改为虚继承：

class B : virtual public A {
public:
	int _b;
};
class C : virtual public A {
public:
	int _c;
};

可以发现_a到了底部，同时两次修改_a是修改的同一块内存


继续调试，最终可以发现内存是这样分布的

解释：

1. _a到了最下面，且_a只有一个
2. 不同于_d，对于_b和_c不仅仅只有值，还有上面两行数据，代表到_a的偏移量(offset)的地址
   另开两个内存监视窗口，设为8字节一行(注意这里是小端存储)，可以看到_b和_c的偏移量分别是十六进制的28和18，也就是十进制的40和24，_d相对_a偏移5行，_c相对_a偏移3行

我们可以把地址指向的那部分叫做虚基表
(00 00 00 00)
(28 00 00 00) _b的虚基表
–
(00 00 00 00)
(18 00 00 00)_c的虚基表
至于上面全零的部分也是存的偏移量，记录虚函数表指针和虚基表指针的相对位置偏移量(仅了解)

结论：
虚继承的派生类的对象、指针、引用，访问_ a都要取偏移量计算_ a的位置。可以看到虚继承后，解决菱形继承的问题 ，但同时，对象模型更复杂了，访问虚基类成员也需要付出一定效率代价

⑨组合

所谓组合就是在类中定义类，而不是继承类,如：

class A {
public:
	int _a;
};
class B {
public:
	A a;
};

组合与继承：

1. public继承是一种is-a的关系 也就是说每个派生类对象都是一个基类对象
2. 组合是一种has-a的关系 假设B组合了A，每个B对象中都有一个A对象

参考：优先使用对象组合，而不是类继承