C++从入门到起飞之——继承下篇（万字详解） 全方位剖析！

🌈个人主页：秋风起，再归来~
🔥系列专栏：C++从入门到起飞          
🔖克心守己，律己则安

目录

1、派⽣类的默认成员函数

1.1 四个常⻅默认成员函数

 1.2 实现⼀个不能被继承的类

​编辑 2. 继承与友元

3. 继承与静态成员

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

5.1 继承模型

​编辑 5.2 虚继承

5.3 IO库中的菱形虚拟继承

5.4 多继承中指针偏移问题？

6. 继承和组合

7、完结散花

1、派⽣类的默认成员函数

1.1 四个常⻅默认成员函数

6个默认成员函数，默认的意思就是指我们不写，编译器会变我们⾃动⽣成⼀个，那么在派⽣类中，这 ⼏个成员函数是如何⽣成的呢？

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

>当父类有默认构造时：

class person
{
public:
	//有默认构造
	person(const int age= 18)
		:_age(age)
	{
		cout << "person(const int age= 18)" << endl;
	}

protected:
	int _age=18;
};

class student:public person
{
public:
	student(int num,const char* address)
		//实际上父类先走初始化列表
		//父类有默认构造则不会报错
		:_num(num)
		,_address(address)
	{
		cout << "student(int num,const char* address)" << endl;
	}
protected:
	//被继承下来的父类成员默认在声明的第一个位置
	int _num = 0;//学号
	string _address = "南昌市新建区";//地址
};

int main()
{
	student s1(1,"南昌市新建区");
	return 0;
}

 >当父类没有默认构造时：

究其原因则是子类继承下来的父类我们需要将它看作一个类似于类对象的整体，当子类调用构造函数时，会优先让父类走初始化列表（因为被继承下来的父类在子类声明处的第一个位置）， 如果父类有默认构造，则不显示调用父类构造没有问题。但如果父类没有默认构造，我们就一定要在子类的构造中显示调用父类的构造！

那怎么显示调用父类的构造呢？

student(int age,int num, const char* address)
	//实际上父类先走初始化列表
	//父类有默认构造则不会报错
	:_num(num)
	, _address(address)
	, person(age)
{
	cout << "student(int age,int num, const char* address)" << endl;
}

其实我们传一个匿名对象就可以了！虽然我们在初始化列表的第三个位置初始化父类，但我们之前就说过：初始化类成员的顺序和初始化列表的顺序无关，和类成员声明的位置有关（各位彦祖亦菲们还记得吗）！

2. 派⽣类的拷⻉构造函数必须调⽤基类的拷⻉构造完成基类的拷⻉初始化。

class person
{
public:
	//默认构造
	person(const int age)
		:_age(age)
	{
		cout << "person(const int age= 18)" << endl;
	}
	//拷贝构造
	person(const person& p)
		:_age(p._age)
	{
		cout << "person(const person& p)" << endl;
	}

protected:
	int _age=18;
};

class student:public person
{
public:
	student(int age,int num, const char* address)
		//实际上父类先走初始化列表
		//父类有默认构造则不会报错
		: person(age)
		,_num(num)
		, _address(address)
		
	{
		cout << "student(int age,int num, const char* address)" << endl;
	}

	// 严格说Student拷贝构造默认生成的就够用了
	// 如果有需要深拷贝的资源，才需要自己实现
	student(const student& s)
		: person(s)//直接用子类的对象赋值给父类
		,_num(s._num)
		, _address(s._address)
		
	{
		//深拷贝，但是如果一个子类成员还有深拷贝，那这个代码就比较复杂
		//可读性就很弱了，所以我们大多数情况下都不会设计出子类还有深拷贝的程序
	}

protected:
	//被继承下来的父类成员默认在声明的第一个位置
	int _num = 0;//学号
	string _address = "南昌市新建区";//地址
};

int main()
{
	student s1(18,1,"南昌市新建区");
	return 0;
}

>严格说Student拷贝构造默认生成的就够用了，如果有需要深拷贝的资源，才需要自己实现 。

但是如果一个子类成员还有深拷贝，那这个代码就比较复杂，可读性就很弱了，所以我们大多数情况下都不会设计出子类还有深拷贝的程序。

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

class person
{
public:
	//默认构造
	person(const int age)
		:_age(age)
	{
		cout << "person(const int age= 18)" << endl;
	}
	//拷贝构造
	person(const person& p)
		:_age(p._age)
	{
		cout << "person(const person& p)" << endl;
	}
	//赋值重载
	person& operator=(const person& p)
	{
		cout << "person& operator=(const person& p)" << endl;
		if (this != &p)
		{
			_age = p._age;
		}
		return *this;
	}

protected:
	int _age=18;
};

class student:public person
{
public:
	student(int age,int num, const char* address)
		//实际上父类先走初始化列表
		//父类有默认构造则不会报错
		: person(age)
		,_num(num)
		, _address(address)
		
	{
		cout << "student(int age,int num, const char* address)" << endl;
	}

	// 严格说Student拷贝构造默认生成的就够用了
	// 如果有需要深拷贝的资源，才需要自己实现
	student(const student& s)
		: person(s)//直接用子类的对象赋值给父类
		,_num(s._num)
		, _address(s._address)
		
	{
		//深拷贝，但是如果一个子类成员还有深拷贝，那这个代码就比较复杂
		//可读性就很弱了，所以我们大多数情况下都不会设计出子类还有深拷贝的程序
	}

	//赋值重载
	// 严格说Student赋值重载默认生成的就够用了
	// 如果有需要深拷贝的资源，才需要自己实现
	student& operator=(const student& s)
	{
		cout << "student& operator=(const student& s)" << endl;
		if (this != &s)
		{
			operator=(s);
			_num = s._num;
			_address = s._address;
		}
		return *this;
	}

protected:
	//被继承下来的父类成员默认在声明的第一个位置
	int _num = 0;//学号
	string _address = "南昌市新建区";//地址
};

int main()
{
	student s1(18,1,"南昌市新建区");
	student s2(20,1, "南昌市新建区");
	s1 = s2;
	return 0;
}

我们测试一下发现程序直接就崩溃了！ 

结合程序的无限循环调用子类赋值重载（看打印结果）的结果我们可以初步断定问题一定出现在子类的赋值重载部分！  

 我们调试一下看看问题到底在哪里！

通过调试我们发现，程序一直在循环调用子类的赋值重载，但为什么我们期望调用父类的赋值重载，却调到了子类当中呢？原因就是子类和父类的成员函数名相同，构成了隐藏！如果我们不突破类域访问父类的成员函数，那编译器就会调到子类当中！所以上面的程序在子类的赋值重载内部自己调用自己从而引发了死循环！

//赋值重载
// 严格说Student赋值重载默认生成的就够用了
// 如果有需要深拷贝的资源，才需要自己实现
student& operator=(const student& s)
{
	cout << "student& operator=(const student& s)" << endl;
	if (this != &s)
	{
		person::operator=(s);
		_num = s._num;
		_address = s._address;
	}
	return *this;
}

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

>如果我们在子类当中显示先调用父类的析构会发生什么呢？

~person()
{
	cout << "~person()" << endl;
}

// 严格说Student析构默认生成的就够用了
// 如果有需要显示释放的资源，才需要自己实现
// 析构函数都会被特殊处理成destructor() 
~student()
{
	// 子类的析构和父类析构函数也构成隐藏关系
	// 规定：不需要显示调用，子类析构函数之后，会自动调用父类析构
	// 这样保证析构顺序，先子后父，显示调用取决于实现的人，不能保证
	// 先子后父
	cout << "~student()" << endl;
	person::~person();
}

int main()
{
	student s1(18,1,"南昌市新建区");
	student s2(20,1, "南昌市新建区");
	s1 = s2;
	return 0;
}

 我们只定义了两个student对象，为什么父类的析构却调用了四次啊！

解析：子类在调用析构函数时会默认自动先调用自己的析构函数，然后再调用父类的析构函数。如果我们显示调用父类的析构函数的话，编译器会重复第二次调用父类的析构函数！

所以，我们一定要记住，无论在什么情况下，我们都不要显示调用父类的析构函数，多次析构可能会引起程序的崩溃！

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

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

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

 1.2 实现⼀个不能被继承的类

⽅法1：基类的构造函数私有，派⽣类的构成必须调⽤基类的构造函数，但是基类的构成函数私有化以 后，派⽣类看不⻅就不能调⽤了，那么派⽣类就⽆法实例化出对象。

class Base 
{
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()
{
	Derive d;
	return 0;
}

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

class Base final
{
public:
	void func5() { cout << "Base::func5" << endl; }
	Base()
	{}
protected:
	int a = 1;
private:
	//C++98的⽅法 
	/*Base()
	{}*/
};

class Derive :public Base
{
	void func4() { cout << "Derive::func4" << endl; }
protected:
	int b = 2;
};
int main()
{
	Derive d;
	return 0;
}

 2. 继承与友元

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

//前置声明
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;
}

 注意：由于C/C++追求效率的问题，编译器默认在编译时只会向上查找（如果每次都全部查找，C/C++的效率就会有所下降，而Java，Python等语言则是不需要前置声明的，这也就是C/C++为何高效的原因之一），因此这里我们在父类使用子类时要前置声明一下子类。只有这样编译器才会向下查找子类的定义！

3. 继承与静态成员

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

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

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

// 编译报错：error C2385: 对“_name”的访问不明确 
Assistant a;
//a._name = "peter";
// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决 
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
return 0;

 但是，这并没有解决数据冗余的问题啊！Assistant作为Person（身份证上的姓名，别扯什么小名）有两个名字本身就不合理。况且，如果数据过于冗余又会导致对象占用内存太大的问题！

下面我用虚继承（等下就会讲到）来解决一下数据冗余的问题，看看对象的大小：

 5.2 虚继承

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

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

通过调试发现，我们使用虚继承后，对象中只有一个name了！

使用虚继承时需要注意：

1、哪个类产生数据冗余和二义性，继承时用虚继承！

2、如上，一定要B,C同时使用虚继承才能解决菱形继承带来的问题！（就好比一个坐在轮椅上的残疾人，你给他一个拐杖，他还是不能站起来！）

3、最好不要玩虚继承！

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

 虚继承的底层远比我们想象的要复杂，这里在调试时，Assistant的构造函数中，初始化列表先走Person的默认构造将name先初始化，然后在走student和teacher的构造函数时不再初始化它们继承下来的name了！只初始化它们内部的原生成员变量！

我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，⽆论是使⽤还是底层 都会复杂很多。当然有多继承语法⽀持，就⼀定存在会设计出菱形继承，像Java是不⽀持多继承的， 就避开了菱形继承。

5.3 IO库中的菱形虚拟继承

虽然我们以后尽量避免写出菱形继承的的代码，但我们难免会遇到这样的代码。而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>
{};

5.4 多继承中指针偏移问题？

下⾯说法正确的是()

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

 base1和base2在对象d中存储的顺序和他们继承的先后顺序有关，先继承的则存储在上面。而我们把子类的地址给父类放指针时则和父类和子类之间的转换有关（上篇有详细讲解）

所以这题的答案是C 

6. 继承和组合

• public继承是⼀种is-a的关系。也就是说每个派⽣类对象都是⼀个基类对象。

• 组合是⼀种has-a的关系。假设B组合了A，每个B对象中都有⼀个A对象。

• 继承允许你根据基类的实现来定义派⽣类的实现。这种通过⽣成派⽣类的复⽤通常被称为⽩箱复⽤ (white-box reuse)。术语“⽩箱”是相对可视性⽽⾔：在继承⽅式中，基类的内部细节对派⽣类可 ⻅。继承⼀定程度破坏了基类的封装，基类的改变，对派⽣类有很⼤的影响。派⽣类和基类间的依 赖关系很强，耦合度⾼。

• 对象组合是类继承之外的另⼀种复⽤选择。新的更复杂的功能可以通过组装或组合对象来获得。对 象组合要求被组合的对象具有良好定义的接⼝。这种复⽤⻛格被称为⿊箱复⽤(black-box reuse)， 因为对象的内部细节是不可⻅的。对象只以“⿊箱”的形式出现。组合类之间没有很强的依赖关 系，耦合度低。优先使⽤对象组合有助于你保持每个类被封装。

• 优先使⽤组合，⽽不是继承。实际尽量多去⽤组合，组合的耦合度低，代码维护性好。不过也不太 那么绝对，类之间的关系就适合继承(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>
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;
}

7、完结散花

好了，这期的分享到这里就结束了~

如果这篇博客对你有帮助的话，可以用你们的小手指点一个免费的赞并收藏起来哟~

如果期待博主下期内容的话，可以点点关注，避免找不到我了呢~

我们下期不见不散~~

​​​​