C++ 继承 - 技术栈

1.继承的概念及定义

1.1继承的概念

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

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

cpp 复制代码

class Student
{
public:
	void identity()
	{}

	void study()
	{}

protected:
	string _name = "joker";
	string _address;
	string _tel;
	int _age = 18;

	int _stuid; //学号
};

class Teacher
{
public:
	void identity()
	{}

	void teaching()
	{}

protected:
	string _name = "zhangsan";
	string _address;
	string _tel;
	int _age = 18;

	int _title; //职称
};

下面我们公开的成员都放在了Person类中，Student和Teacher都是继承Person，就可以复用这些成员，就不需要重复定义了。

cpp 复制代码

class Person
{
public:
	void identity()
	{}
protected:
	string _name = "joker";
	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:
	int _title; //职称
};

int main()
{
	Student s;
	Teacher t;

	s.identity();
	t.identity();
	return 0;
}

1.2继承定义

1.2.1定义格式

我们看到Person是基类，也称作父类，Student是派生类，也叫做子类。

1.2.2继承基类成员访问方式的变化

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

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

1.2.3继承类模版

cpp 复制代码

namespace wxw
{
	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()
{
	wxw::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	return 0;
}

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

public继承 的派生类对象可以赋值给基类的指针/基类的引用。这里有个形象的说法切片或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。
基类对象不能赋值给派生类对象。
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTT（Run-Time Type Information）的dynamic_cast来进行识别后进行安全转换。

cpp 复制代码

#include<iostream>
using namespace std;

class Person
{
	virtual void P()//虚函数
	{}

protected:
	string _name;
	string _sex;
	int age;
};

class Student : public Person
{
protected:
	int _num;
};

int main()
{
	Student s;

	//派生类对象可以赋值给基类的对象/指针/引用
	Person p = s;
	Person* pp = &s;
	Person& rp = s;

	//基类对象不能赋值给派生类对象
	//s = p;

	//但基类的指针和引用强制类型转换可以指向派生类对象的指针和引用
	//Student* ps = (Student*)pp;

	//dynamic_cast指向父类转换失败，指向子类转换成功，转换成功返回正常的指针
	Student* ps1 = dynamic_cast<Student*>(pp);//要求是多态类型，必须加虚函数,指向子类转回子类可以
	cout << ps1 << endl;//返回正常的指针
	
	pp = &p;
	Student* ps2 = dynamic_cast<Student*>(pp);//指向父类转回子类就不可以
	cout << ps2 << endl;//返回空

	return 0;
}

3.继承中的作用域

3.1隐藏规则

在继承体系中基类和派生类都有独立的作用域。
派生类的基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派生类成员函数中，可以使用基类::基类成员显示访问）
需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏
注意在实际中在继承体系中最好不要定义同名的成员。

cpp 复制代码

class Person
{
protected:
	string _name = "小李子";//姓名
	int _num = 123456;//身份证号
};

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;
}

如上示代码，子类中的成员变量隐藏了父类中的成员变量，要使用父类中的成员变量则需要显示访问。

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

cpp 复制代码

class A
{
public:
    void func()
    {
    cout << "func()" << endl;
    }
};
class B : public A
{
public:
    void func(int i)
    {
    cout << "func(int i)" <<i<<endl;
    }
};
int main()
{
    B b;
    b.func(10);
    b.func();
    return 0;
};

1.A和B两个类中两个func构成隐藏（函数重载需要在同一作用域）

2.这个程序运行报错（隐藏了父类的func）

4.派生类的默认成员函数

4.1 4个常见默认成员函数

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

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
派生类的operator=必须要调用基类的拷贝构造完成基类的赋值，需要注意的是派生类的operator=隐藏了基类的operator=，所以显示调用基类的operator=，需要指定基类的作用域。
派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类对象再清理基类成员的顺序。
派生类对象初始化先调用基类构造再调派生类构造。
派生类对象析构清理先调用派生类析构再调基类的析构。
因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以基类的析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系。

cpp 复制代码

class Person
{
public:
	Person(const char* name)
		:_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
{
	Student(const char* name, int num, const char* address)
		:Person(name)//显示调用父类的构造
		,_num(num)
		,_address(address)
	{}

	//严格说Student拷贝构造默认生成的就够用了
	//如果要需要深拷贝的资源，才需要自己实现
	Student(const Student& s)
		:Person(s)//调用父类的拷贝构造
		,_num(s._num)
		,_address(s._address)
	{}

	//严格说Student赋值重载默认生成的就够用了
	//如果要需要深拷贝的资源，才需要自己实现
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			//父类和子类的operator=构成隐藏关系
			Person::operator=(s);

			_num = s._num;
			_address = s._address;
		}
		return *this;
	}

	//严格说Student析构默认生成的就够用了
	//如果要需要深拷贝的资源，才需要自己实现
	//析构函数都会被特殊处理成destructor()
	~Student()
	{
		//子类的析构和父类析构函数也构成隐藏关系
		//规定,不需要显示调用父类的析构，子类析构函数之后，会自动调用父类析构
		//这样保证析构顺序，先子后父
	}
protected:
	int _num;//学号
	string _address = "山西省大同市";
};

4.2 实现一个不能被继承的类

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

方法二：C++11新增一个final关键字，final修饰基类，派生类就不能继承了

cpp 复制代码

#include<iostream>
using namespace std;

class Base final//C++11的方法
{
public:
	void Print()
	{
		cout << "Print()" << endl;
	}
protected:
	int _a = 1;
private:
	//C++98的方法
	Base()
	{}
};

class Derive : public Base
{
public:

protected:
	int b = 0;
};

5.继承与友元

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

cpp 复制代码

class Student;//前置声明

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;
}

6.继承与静态成员

基类定义了一个static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类都只有一个static成员实例。

cpp 复制代码

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;

	cout << p._count << endl;
	cout << p._count << endl;
	return 0;
}

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

7.1继承模型

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

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

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

单继承和多继承

菱形继承

cpp 复制代码

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";//编译报错：对_name的访问不明确

	//需要显示指定访问哪个基类的成员可以解决二义性问题，但是数据冗余问题无法解决。
	a.Student::_name = "wxw";
	a.Teacher::_name = "yyy";


}

7.2虚继承

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

cpp 复制代码

class Person
{
public:
	string _name; // 姓名
	/*int _tel;
	int _age;
	string _gender;
	string _address;*/
	// ...
};

// 使⽤虚继承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;
}

我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，无论是使用还是底层都会复杂很多。

cpp 复制代码

class Person
{
public:
	Person(const char* name)
		:_name(name)
	{}

	string _name;
};

class Student : virtual public Person
{
public:
	Student(const char* name, int num)
		:Person(name)
		,_num(num)
	{}
protected:
	int _num;
};

class Teacher : virtual public Person
{
public:
	Teacher(const char* name, int id)
		:Person(name)
		, _id(id)
	{}
protected:
	int _id; // 职⼯编号
};

class Assistant : public Student, public Teacher
{
public:
	Assistant(const char* name1, const char* name2, const char* name3)
		:Person(name3)
		, Student(name1, 1)
		, Teacher(name2, 2)
	{}
protected:
	string _majorCourse; // 主修课程
};

int main()
{
	//这⾥a对象中_name是"王五"
	Assistant a("张三", "李四", "王五");
	return 0;
}

实现菱形虚拟继承后Assiatant对象中只有一个Person，这个Person即不存在与Student中也不存在于Teacher中，如下图所示

7.3

多继承中指针偏移问题？下⾯说法正确的是（）

p1和p3指向同一空间，所以p1 == p2 != p3

7.4IO库中的菱形虚拟继承

8.继承和组合

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用（white-box reuse）。术语"白箱"是相对可视性而言：在继承方式中，基类的内部细节对派生类可见。继承一定程度破坏了基类的封装，基类的改变对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的镀锡具有良好定义的接口。这种复用风格被称为黑箱复用（black-box reuse）,因为对象的内部细节是不可见的。对象只以"黑箱"的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于保持每个类被封装。
优先使用组合，而不是继承。实际尽量多去用组合，组合的耦合度低，代码维护性好。不过也不那么绝对，类之间的关系就适合继承（is-a）那就用继承，另外要实现多态，也必须要继承。类之间的关系即适合用继承也适合用组合，那就用组合。

黑盒测试：不了解底层实现，从功能角度测试

白盒测试：了解底层实现，从代码运行逻辑角度测试

cpp 复制代码

// 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; }
};