【C++】从零开始认识继承

送给大家一句话：
其实我们每个人的生活都是一个世界，即使最平凡的人也要为他生活的那个世界而奋斗。 – 路遥 《平凡的世界》

✩◝(◍⌣̎◍)◜✩✩◝(◍⌣̎◍)◜✩✩◝(◍⌣̎◍)◜✩
✩◝(◍⌣̎◍)◜✩✩◝(◍⌣̎◍)◜✩✩◝(◍⌣̎◍)◜✩
✩◝(◍⌣̎◍)◜✩✩◝(◍⌣̎◍)◜✩✩◝(◍⌣̎◍)◜✩

---

1 前言

在我们日常的编程中，继承的应用场景有很多。它可以帮助我们节省大量的时间和精力，避免重复造轮子的尴尬。同时，它也让我们的代码更加模块化，易于维护和扩展。可以说，继承技术是C++的灵魂。

那么，继承技术的起源又是什么呢？这得追溯到遥远的过去，当时的程序员们发现，许多类的属性和方法都是相似的，于是他们想出了一个绝妙的主意：为什么不把这些相似的部分提取出来，形成一个"父类"，而其他的类则通过"继承"这个父类来获得这些属性和方法呢？这个想法，就是继承技术的雏形。

如今，继承技术已经成为C++编程中不可或缺的一部分。它让我们能够站在巨人的肩膀上，创造出更加高效、简洁的代码。当然，继承技术也不是万能的，它也有自己的局限性和注意事项。但是，这并不妨碍我们欣赏它的优雅，感受它带来的便利。

在这篇博客中，我将带你深入探讨C++继承技术的奥秘，让你能够更好地掌握这一强大的工具。准备好了吗？让我们一起踏上这场探索之旅，开启编程的新篇章 — C++进阶！！！

2 什么是继承

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

通过继承联系在一起的类构成一种层次关系，通常在层次关系的根部有一个基类（base class）,其他类则是直接或间接地从基类继承过来的，这些继承来的类成为派生类（derived class）。基类负责定义在层次关系中所有类共同拥有的成员，而每个派生类都有各自特定的成员。

举个例子：加入我们需要一个学校管理系统，那么成员包括学生，老师，保安，宿管…不管是什么身份，总得是个人吧，是人就会有名字，年龄，家庭住址等基础信息，那么我们就可以把这些共同的部分提炼出来作为基类。

#include<iostream>

using namespace std;
//共同特性
class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "peter"; // 姓名
	int _age = 18; // 年龄
};

class Student : public Person
{
protected:
	int _stuid; // 学号
};

class Teacher : public Person
{
protected:
	int _jobid; // 工号
};
int main()
{
	Student s;
	Teacher t;
	s.Print();
	t.Print();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

运行一下：

3 开始使用继承

3.1 继承的语法格式

class Student : public Person 这样就是继承的语法

继承方式在这里有三种:public , protected ， private。不同的继承方式与不同的类成员组合，会是不同的权限：

总结起来：

1. 基类private成员在派生类中无论以什么方式继承都是不可见的！！！派生类无法直接访问基类的私有成员（可以间接访问），类外也无法访问。
2. 如果基类的成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
4. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced / private继承，因为protetced / private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强
5. 基类的其他成员在子类的访问方式 等于(成员在基类的访问限定符，继承方式) 较小的那一个权限，public > protected> private。
6. 通过继承的特性，基类一般都定义为public 和 protected，不使用private。

3.2 基类与派生类的赋值转换

在之前的学习中，我们知道相近类型的类型可以相互转换：

int i = 1 ;
double d = i;
string s = "111111";
const string& s = "111111";//类型转换会产生临时变量，临时变量具有常性
1
2
3
4

不相关的类型就无法进行转换。
那么在继承中，子类与父类可不可以进行赋值转换呢？可以！
只有公有继承才能进行转换！！！

Student st;
Person p = st;
1
2

在public继承中，有一个is-a概念：每个子类对象都是一个特殊的父类对象。父类 = 子类，会对子类进行切片，把父类的部分给基类进行赋值。

也可以使用引用和指针，同样也是通过切片来进行赋值。都可以对派生类进行修改。

1. 引用
   引用就是创建一个子类中基类部分的别名。
2. 指针
   指针就是将子类中基类的地址赋值给基类指针。

注意：

• 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
• 基类对象不能赋值给派生类对象。
• 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。

3.3 继承中的作用域

通过对C语言的C++的学习，我们知道有域这个概念。域分为局部域和全局域，相同的域不能有同名变量与同名函数（重载除外）。局部域与全局域会影响生命周期。而C++ 中又有了类域！类域不影响生命周期：

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

我们就来看看隐藏是怎么个事儿！

只要派生类中出现与基类相同的变量名，那么就会把父类的变量隐藏，想要访问父类的该变量，就需要加上限定域名：

#include<iostream>

using namespace std;

class Person
{
public:
	Person(int age = 18, int sex = 1, int num = 0)
		:_age(age),
		_sex(sex),
		_num(num)
	{}
	void Print()
	{
		cout<< _sex <<endl;
	}
protected:
	int _age;
	int _sex;
	//设置一个变量
	int _num;
};

class Student: public Person
{
public:
	Student(int num = 0)
		:_num(num)
	{

	}
	void Print()
	{
		cout <<"_num : " << _num << endl;
		cout <<"Person::_num : " << Person::_num << endl;

	}
protected:

	//设置一个变量
	int _num;
};

int main()
{
	Student s(1111);
	s.Print();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

来看现象：

也就是基类变量和派生类变量具有不同的作用域，如果存在同名变量，派生类想要访问基类的变量就需要指明作用域。

函数也是同样的道理！！！如果有相同函数名，使用基类成员时要表明作用域。

3.4 派生类的默认成员函数

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

构造函数

首先派生类的成员可以分为以下几种：父类成员 ， 子类成员 ， 内置类型，自定义类型。
对于子类的成员，规则和普通的类一样（内置类型不做处理，自定义类型调用其构造函数）。如果没有默认构造，就会报错！！！

#include<iostream>

using namespace std;

class Person
{
public:
	//因为不是全缺省函数没有默认构造
	Person(const char* name )
		: _name(name)
	{
		cout << "Person()" << endl;
	}
protected:
	string _name; // 姓名
};
class Student : public Person
{
public:
protected:
	int _num; //学号
};
void Test()
{
	Student s1;
}

int main()
{
	Test();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

因为没有写Student的构造函数，内置类型会不处理，自定义类型会调用其构造函数。
但是我们写了一个基类Person的全缺省构造函数，这里就会在没有传参的时候没有默认构造函数匹配，这时派生类Student就会报错：

为了避免这样的错误，我们可以增添派生类Student的构造函数：

class Student : public Person
{
public:
	Student(int num , const char* str ,const char* name)
		:_name(name),
		_num(num),
		_str(str)
	{

	}
protected:
	int _num; //学号
	string _str;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

可是？？？为什么这样

因为这里的继承的Person相当于我们有一个Person成员变量，就是一个整体，我们要调用它的整体：

class Student : public Person
{
public:
	Student(int num , const char* str ,const char* name)
		:Person(name),
		_num(num),
		_str(str)
	{

	}
protected:
	int _num; //学号
	string _str;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

把基类当做一个整体就可以了！！！，类似以下结构：

class BB
{
public:
	BB(int num , const char* str ,const char* name)
		:_p(name),
		_num(num),
		_str(str)
	{}
protected:
	Person _p
	int _num; //学号
	string _str;
};
1
2
3
4
5
6
7
8
9
10
11
12
13

拷贝构造函数

再来看拷贝构造，拷贝构造的基类是如何处理的呢？
依然采取：对于子类的成员，规则和普通的类一样（内置类型不做处理，自定义类型调用其拷贝构造函数）
如果没有就默认生成（浅拷贝）！！！涉及深拷贝要写哦，一般不需要写。
写的规则与构造函数类似：

class Student : public Person
{
public:
	Student(int num , const char* str ,const char* name)
		:Person(name),
		_num(num),
		_str(str)
	{}
	Student(const Student& s)
		:Person(s)//会进行切片，子类对象可以赋值给父类  ->复用
		,_num(s._num)
		,_str(s._str)
	{}
protected:
	int _num; //学号
	string _str;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Person(s) 会进行切片（子类对象可以赋值给父类 ） ，这样是对基类代码的复用！

赋值构造函数

赋值构造函数operator=怎样进行操作呢？
默认生成的赋值构造也是差不多的逻辑：对于子类的成员，规则和普通的类一样（内置类型不做处理，自定义类型调用其赋值构造函数 operator=）
那要是存在深拷贝，需要我们来自己写：

class Student : public Person
{
public:
	Student(int num , const char* str ,const char* name)
		:Person(name),
		_num(num),
		_str(str)
	{}
	Student& operator=(const Student& s)
	{
		//不能自己赋值自己
		if(this != &s)
		{
			//注意标明作用域 ， 否则会无限递归
			Person::operator=(s); //进行切片来对父类进行赋值拷贝 ->复用
			_num = s._num;
			_str = s._str;//调用string的构造
		}
	}
protected:
	int _num; //学号
	string _str;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

子类的赋值构造会隐藏父类的赋值构造！！！
一定一定注意Person::operator=(s);一定一定指明作用域，不然会就近原则调用派生类的operator=函数，然后无限递归，最终导致栈溢出！！！

class Student : public Person
{
public:
	Student(int num , const char* str ,const char* name)
		:Person(name),
		_num(num),
		_str(str)
	{}
	~Student(int num , const char* str ,const char* name)
	{
		~Person();
		cout<<" ~Student() "<<endl;
	}
protected:
	int _num; //学号
	string _str;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

析构函数

析构函数是可以主动调用的。那么我们很自然的想到在派生类析构函数中调用基类析构：

但是报错了？？？
因为子类的析构也会隐藏父类的析构！！！对于以后多态的需要，一般析构函数名都会统一处理为destructor
想要调用就标明作用域：Person::~Person(),但是像上述这样写，会有一个问题，基类的析构会调用两次！！！

那怎么办呢？？？
其实，派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。所以我们不必在派生类的析构函数中进行调用基类的析构函数，不然就会重复释放同一块空间，导致报错！

因为析构必须要按先子后父的顺序，父亲没了何谈子呢？父亲析构了，如果子类还要访问父类成员，那子类中对父类的访问就会出现问题，野指针什么的问题接踵而至！！！

总结

派生类的默认成员函数的注意事项：

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调派生类构造。
6. 派生类对象析构清理先调用派生类析构再调基类的析构。
7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系

4 继承与友元

一句话：友元关系不能继承！！！
一句话：友元关系不能继承！！！
一句话：友元关系不能继承！！！

就是说基类友元不能访问子类私有和保护成员，打个比方：爸爸的朋友，能说成是你的朋友吗？

来个看个样例：

#include<iostream>
#include<string>

using namespace std;

class Son;
class Dad 
{
public:
	Dad(int money = 100  , const char* house = "homeless")
		:_money(money)
		,_house(house)
	{}

	friend void show(const Dad& d, const Son& s);

protected:
	int _money;
	string _house;
};

class Son : public Dad
{
public:
	Son(int homework = 100  )
		:_homework(homework)
	{}
	//friend void show(const Dad& d, const Son& s);
protected:
	int _homework;;
};

void show(const Dad& d , const Son& s)
{
	cout << d._money << endl;
	cout << d._house << endl;
}

int main()
{
	Dad d(10000, "翻斗花园");
	Son s(12);
	show(d,s);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

这里友元函数可以访问Dad类的变量：

但是如果要访问Son的变量就会报错：

在Son同样设置一个友元就可以解决这个问题了。

5 继承与静态变量

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

我们可以来验证一下：

#include<iostream>
using namespace std;
class A
{
public:
	static int _a ;
};
int A::_a = 1;

class B : public A
{
public:

protected:
	int b;
};

int main()
{
	B b1;
	B b2;
	B b3;
	cout << &b1._a << endl;
	cout << &b2._a << endl;
	cout << &b3._a << endl;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

运行一下会发现，他们的地址都是一致的：

也就说明他们共用一个_a变量，所以无论派生出多少个子类，都只有一个static成员实例
这个特性可以用来统计一个又多少个类被实例化，也就可以统计数量,只需在构造函数中加入一个增加该静态变量的语句即可：

#include<iostream>
#include<string>

using namespace std;

class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};
int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum; // 学号
};

void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;

	cout << " 人数 :" << Person::_count << endl;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
}

int main()
{
	TestPerson();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

运行一下：

我们就可以知道有多少个该继承体系中实例化了多少个类了！！！

6 复杂的菱形继承及菱形虚拟继承

首先说明一下，由于C++的历史缘故，其一致行走在语言发展的前端，一直在尝试新的内容。在发展过程中，有些内容加入到C++的时候，还没有发现其弊端。而后来发现的时候，为了向上兼容，只能打补丁，所以不开避免的不会有一些弊端，会有复杂的语法和复杂的特性。但这也是C++语言 “我不入地狱,谁入地狱!!! ”的豪迈气息 。总要有先驱者走前前面，而C++就是！！！

1. 单继承
   单继承很好理解，即继承关系是单线的：
   
   这样的继承关系就叫做单继承！！！
2. 多继承
   多进程也很好理解，应该类具有多个属性，就可以使用多继承：
   

而什么是菱形继承呢？？？就是形成一个类似菱形关系的继承关系：

定睛一看，好像不会出什么错误。
但是菱形继承存在这样的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。
在SDU的对象中university成员会有两份,存在二义性和数据冗余的问题！！！
访问的时候就无法确定变量到底属于那一个了：

#include<iostream>
#include<string>

using namespace std;

class university
{
public:
	string _name; // 大学名字
};

class uni211 : public university
{
protected:
	int _num; //编号
};
class uni985 : public university
{
protected:
	int _id; // 编号
};
class  SDU : public uni211, public uni985
{
protected:
	string _address;
};
void Test()
{
	// 这样会有二义性无法明确知道访问的是哪一个
	SDU a;
	a._name = "peter";
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.uni211::_name = "xxx";
	a.uni985::_name = "yyy";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

这样虽然可以解决二义性的问题，但是数据冗余的问题没有解决啊！？一个大学不需要两个名字啊！！！

那这怎么解决呢？？？虚拟继承这不就来了吗！！！

虚拟继承（virtual）可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在uni985和uni211的继承university时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用!!!

#include<iostream>
#include<string>

using namespace std;

class university
{
public:
	string _name; // 大学名称
};

class uni211 : virtual public university
{
protected:
	int _num; //编号
};
class uni985 : virtual public university
{
protected:
	int _id; //编号
};
class  SDU : public uni211, public uni985
{
protected:
	string _address;//地址
};
void Test()
{
	// 这样就只有一个_name了，不存在二义性的问题了
	SDU a;
	a._name = "peter";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

这是什么原理呢？？？
这里需要我们打开内存窗口来查看了，非常的巧妙！！！
我们先来看不使用虚拟继承的情况

#include<iostream>
#include<string>

using namespace std;

class A
{
public:
	int _a;
};
 class B : public A
//class B : virtual public A
{
public:
	int _b;
};
 class C : public A
//class C : virtual public A
{
public:
	int _c;
};
class D : public B, public C
{
public:
	int _d;
};
int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

来看调试的过程：

通过这个逐语句调试的内存变化，我们可以确定大致的内存情况：

不使用虚拟继承就是这样的内存情况，也好理解为什么同名变量的两份是如何储存的了。
接下来我们来看虚拟继承下的菱形继承是怎么个情况：

看起来像是这样：

_a储存在最下面，而B,C部分的原有储存_a的位置现在是什么呢？？？
其实是个指针，那我们来看看指针指向的空间储存着什么吧：

？？？怎么对应位置是00 00 00 00为什么是零？哈哈往下看一个看看奥：
分别储存着16进制数字20 12，然后对应B,C原本的指针位置加上这个值（偏移量），都会指向到A _a的空间！！！这个00 00 00 00到多态的部分再来进行讲解，知道原地址加上下面的值就是A _a的空间就可以了！！！

这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。
即原本B,C中_a的位置储存这一个指针，指针指向的位置有一个偏移量，原位置的地址加上偏移量就会指向A的空间！！！

那这样进行拷贝切片的时候是怎样的呢？一样是把D中B对象的部分切片，然后通过上述方式来找到_a。但这样也带来了一些代价：（PS：内存中的储存顺序就是声明的顺序，先继承谁，谁就在前面）

我们进行一个切片，如果我们执行以下操作：

B* pb = &d;
C* pc = &d;

pb->_a++;
pc->_a++;

1
2
3
4
5
6

这样每次访问都要进行寻找偏移量，加上偏移量才能找到_a进行操作。让操作就变得复杂了！！！

总结：实践中可以设计多继承，但是切记不要设计菱形继承！！！因为太复杂了，容易出各种问题！！！
如果B进行了虚拟继承，那么B的所有的实例类都会按照菱形继承中的方式进行访问！！！因为要保持一致，应该类不应出现两种访问方式。

7 继承的总结和思考

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2. 多继承可以认为是C++的缺陷之一，很多后来的很多语言都没有多继承，如Java。
3. 继承和组合（优先使用组合）
   • public继承是一种is-a（谁是什么）的关系。也就是说每个派生类对象都是一个基类对象。
   • 组合是一种has-a（谁有什么）的关系。假设B组合了A，每个B对象中都有一个A对象（也就是把A作为B的成员变量）。
   • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse 能看见，不安全，耦合度高)。术语 “白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
   • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse 不能能看见，安全，耦合度低)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
   • 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

8 有关继承的经典面试题

1. C++有多继承，为什么java等语言没有？
   历史原因！C++是先驱者（人的直觉认为多继承很合理，我感觉正常人都会想到多继承），并且c++中的多继承处理起来十分复杂，访问基类变量的过程就会很复杂！！！java等后来发展的语言见到c++中多继承的复杂，就干脆放弃了。

2. 什么是菱形继承？多继承的问题是什么？
   菱形继承如字面意思（两个父类的父类是同一个类就会发生菱形继承），多继承本身没什么问题，真正的问题是有多继承就可能发生菱形继承。菱形继承就有问题了：变量的二义性和继承冗杂。解决办法很简单就是虚拟继承，但是这样就会大大降低效率。

3. 继承和组合的区别？什么时候用继承？什么时候用组合？
   继承：通过扩展已有的类来获得新功能的代码复用方法
   组合：新类由现有类的对象合并而成的类的构造方式

   • 如果二者间存在一个“是”的关系，并且一个类要对另外一个类公开所有接口，那么继承是更好的选择
   • 如果二者间存在一个“有”的关系，那么首选组合
   • 能用组合就用组合！！！能用组合就用组合！！！能用组合就用组合！！！

Thanks♪(･ω･)ﾉ谢谢阅读！！！

下一篇文章见！！！