详解C++中单继承与多继承的使用

前言

C++的继承机制相对其他语言是比较复杂的一种，不同于java只支持单继承，C++不仅支持单继承，也支持多继承，对于多继承中的菱形问题会引发一系列的麻烦，C++的两个重要缺陷，一个是多继承，一个是垃圾回收器。本文将详细讲解C++的单继承和多继承，以及菱形继承的解决方法及原理。

1.继承的概念和定义

(1)继承的概念

继承是面向对象设计使代码可以复用的重要手段，它允许程序员在保持原有类的基础上进行扩展。被扩展的类称为基类或者父类，扩展生成的类叫做子类或者派生类，继承是类设计层次的复用。

继承的作用是使得子类中既包含父类的成员，也可以包含自己的成员。

(2)继承的定义方法

class Person
{
private:
	string _name;
	int _age;
};
class Student :public Person
{
private:
	int _id;
};

看这一段代码，其中子类Student继承了父类Person，Student后的public表示的是继承方式。

(2)继承后子类的成员类型

继承方式和父类的成员属性共同决定了子类中的成员属性。我们用一张表来表示三者之间的关系。

我们只需要两点来记忆这个表格：

1.基类的private成员在派生类中无论以什么方式继承都是不可见的。

2.子类中的成员属性取继承方式和父类成员属性中权限小的那个： public>protected>private

表格的说明：

1.不可见的意思不是没有被继承，而是不能使用，在底层继承下来比没有继承下来更方便。

2.在父类中private和protected没有区别，但是在子类中，protected成员可以在类内访问，而private不能，因此可以说protected是为了继承而存在的。

3.如果不写继承方式，如果子类是class定义的，那么默认为private继承，是struct定义的，默认是public继承。

4.不可见与private成员区别：不可见指的是在类内与类外都不能使用，private成员在类内可以使用，在类外不可以使用。

5.不想给子类访问的成员我们设成private。

2.基类与派生类的赋值转换

(1)派生类赋值给基类

我们定义了一个父类person和它的派生类student，以上是它们各自的成员。

当我们将一个派生类的对象赋值给基类的对象时，发生的过程我们称之为切片。即只将子类中父类成员赋值过去。当父类中有private成员时，同样会进行切片，只是不显示而已，因此继承中尽量不要定义私有成员。

注意，这种赋值兼容方式仅限于公有继承。

私有继承不支持切片，这是因为对于父类中的public成员，私有或保护继承之后会转变成private/protected类型，而赋值时会发生将派生类对象中的private/protected成员赋值给父类对象中的public成员的现象，但是private/protected成员在类外是不能被访问的，因此不支持私有继承。

	Person b;
	Student a;
	b = a;
	Person* ptr = &a;
	Person& ref = a;

注意一个细节，我们可以使用引用赋值，说明这里并不存在类型转换的行为，因为类型转换中间会产生临时变量，需要使用const引用。

double d;
const int& r=d;//发生了类型转换。

(2)基类给派生类

先说结论：

父类对象不可以直接赋值给子类对象。

这是因为子类对象中有父类不存在的类型，无法进行赋值。也不能通过所谓的强制类型转换进行赋值。

但是C++支持指针和引用的赋值：

	Person b;
	Student a;
	a = (Student)b;//不正确
	Student* ptr = (Student*)&b;//支持
	Student& ref = (Student&)b;//支持

虽然指针和引用可以，但是当指针向下访问的时候超过父类对象的时候会出现问题。

会出现指向空的情况。

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

在这段代码中，Person和Student分别定义了_num，当子类对象中的成员函数直接访问_num时，根据的是就近原则，访问的是子类中的_num，当要访问父类中的_num时，需要使用::来指定类域，就可以进行访问。父类中的_num与子类中的_num构成隐藏。

这段代码打印的结果是：

(2)例题

这里有一道小小的题目，是关于函数隐藏的：

class A
{
public:
	void func()
	{
		cout << "func" << endl;
	}
};
class B :public A
{
public:
	void func(int i)
	{
		A::func();
		cout << "func(int i)->" << i << endl;
	}
};
void Test()
{
	B b;
	b.func(10);
	b.func();
}

提问在Test中的两个函数能否调用成功?

b.func(10)可以调用成功，因为构成了隐藏。
b.func()不能调用成功，会发生变异报错，因为隐藏了调不动。

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

对于六大默认成员函数我们这里暂时先讨论4种重要的，即:构造函数，析构函数，拷贝构造，赋值运算符重载。

(1)默认生成的成员函数

当我们不在子类中书写时，编译器会默认生成。这里只需要记住一句话：

继承下来的成员调用父类的来处理，自己的按基本规则来处理。

以构造函数举例：派生类中的父类成员调用父类中的构造函数，自己的成员按照构造函数自动生成的规则来。

(2)自己写

自己写的情况

1.父类没有默认构造函数，需要我们自己写构造函数。

2.子类有资源需要释放，需要我们自己写析构函数。

3.如果子类涉及浅拷贝问题，需要自己写拷贝构造和赋值重载。

构造函数

父类成员调用对应的父类构造函数处理。子类成员按普通类处理。

举一个例子：

class Person
{
public:
	Person(string name , int num=2)
		:_name(name)
		,_num(num)
	{}
protected:
	string _name ;
	int _num ;
};
class Student :public Person
{
public:
	Student(int num,string _name,int _num)
		:_num(num)
		,Person(_name,_num)
	{}
protected:
	int _num;
};
int main()
{
	Student s1(2,"zhangsan",2);
}

看这一段代码，父类中没有默认构造函数（注意与默认成员函数区分），因此要初始化父类中的对象需要我们自己书写子类中的构造函数。在书写构造函数时，父类对象成员初始化使用父类中的构造函数，子类成员的初始化按正常方式书写即可。

拷贝构造和运算符重载函数

	Student(const Student& s)
		:Person(s)
		,_num(s._num)
	{}
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);//不指明类域的话会发生自己调自己的情况
			_num = s._num;
			return *this;
		}
	}
	int main()
{
	Student s1(2,"zhangsan",2);
	Student s2(s1);
	Student s3 = s2;
}

我们可以通过调试来查看结果：

析构函数

析构函数比较特殊，对于父类中的析构函数，我们不需要指定去书写，就像下面这种情况：

//父类中的析构
	~Person()
	{
		cout << "~Person" << endl;
	}
//子类中的析构
		~Student()
	{
		Person::~Person();
	}

注意，析构函数的名字在最后会被统一处理成destructor()，如果不指定类域的话，父类析构函数和子类析构函数会构成隐藏，因此需要指定类域。
对于上述int中的代码，需要析构三个子类对象，打印出的结果是：

我们发现调用了六次父类中的析构函数。这说明每个对象的父类成员都被析构了两次。如果需要释放空间，则一定会报错。

先说结论：我们自己实现子类构造函数时，不需要显示调用父类析构函数，我们显示调用一次，它还会自动调用一次。

下面简单说明一下，为什么程序需要自动调用：

我们知道变量的定义是发生在栈中的，因此就存在构造和析构的顺序问题，栈满足先入后出原则，因此先构造的需要后析构。

在构造的过程中，我们会先初始化父类成员，再初始化子类成员。因此我们需要先析构子类成员，再析构父类成员。

如果先析构父类会打乱栈的顺序，因此编译器会自动调用父类的析构函数。

5.友元与静态成员

这个只需要记住两点：

1.友元关系不能继承。

2.静态成员会被继承下来，无论继承多少，静态成员只有一个。

6.多继承

(1)概念

一个类有两个及以上父类时称这个继承关系为多继承。

class Student
{
public:
protected:
	int _id;
};
class Teacher
{
public:
protected:
	int _course;
};
class Assistant:public Student,public Teacher
{
public:
protected:
protected:
};

我们使用逗号表示分隔，即继承多个父类。可以通过调试来观察子类Assitant的内容：

(2)复杂的菱形继承

菱形继承是多继承的一种情况：

具有这样的继承关系的称为菱形继承。

菱形继承出现的问题：从对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。

数据冗余指的是类Assistant中会有两份Person的成员，二义性指的是这两份成员每一次调用不知道调用的的是哪一个，需要指定类域。

这段代码表示的就是菱形继承的关系：

class Person
{
public:
	string _name;
};
class Student:public Person
{
public:
protected:
	int _num;
};
class Teacher:public Person
{
public:
protected:
	int _id;
};
class Assistant:public Student,public Teacher
{
public:
protected:
protected:
	int _course;
};
int main()
{
	Assistant a;
}

我们通过调试可以观测a中的内容，发现会存在两份Person中的成员：

如果要对这两个Person成员赋值时，需要指定类域。

	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}

这就是所谓的二义性，在实际中一个人不能有两个名字，对于冗余性来说，如果Person中有一个很大的数组浪费的空间会很多。

(3)虚继承解决菱形继承问题

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

class Student:virtual public Person
{
public:
protected:
	int _num;
};
class Teacher:virtual public Person
{
public:
protected:
	int _id;
};

只需要在菱形的腰部两个父类加入virtual关键词即可。

注意要在菱形的腰部。

当加完之后，在Assistant的对象中，Person类的_name成员就只有一个了。无论是否指定类域，更改的变量都只有一个：

(4)虚继承的原理

内存演示

要研究虚继承的原理，我们给出一个简化的菱形继承结构，再借助内存窗口窗口观察对象成员的模型。

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;
};
int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

当没使用虚继承（即没有使用virtual时）

我们使用内存窗口来观察内容：

通过观察内存中的布局，我们发现d中的B父类对象和C父类对象中的内容分别是连续存放的，B中有父类A中成员_a的值是1，其自己成员_b的值是3，两者的内存是挨着的，C同理，对于D类中自己的成员_d，放在了内存的最后。

确定d中B类对象和C类对象的存储顺序是根据继承顺序决定的。由于上述代码是class D :public B, public C，因此B类的对象会存在C类的前面。
而当我们给腰部加上virtual构成虚继承之后：

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

使用virtual之后，我们发现已经将A中对象_a放入在了最后，因此无论指定不指定类域，改变的都是同一个_a的值。

但同时我们发现内存中多了两行，那么这两行是干什么的呢？

虚基表

从格式来看，这两行显然是都是地址。

我们再开辟一个内存2，向其中输入上面地址，我们发现地址中存储的内容是00 00 00 00，C类对象中同理，这里就不演示了。

这里00 00 00 00的意义在后面多态中会学习到，注意看它的下一个位置存放的是00 00 00 14

这里是十六进制，因此表示的是20这个数字。

再来看内存1：

两者的地址之差刚刚好是20个字节。

因此我们可以知道：在虚继承中，B类对象和C类对象的内存中新加入的是一个地址，分别用于寻找两者与A类型变量的偏移量。B类对象与A类对象的偏移量是20，同理可验证C类对象的偏移量是12。而内存2也有一个专有名词：虚基表

总结：A一般叫做虚基类，在D里面，A类成员放在一个公共的位置，有时B要找A，C要找A，就要通过虚基表中的偏移量进行计算。

比如，当我们再用B类和C类建立两个变量：

	B b = d;
	C c = d;

此时会发生切片处理，需要将d中的A类对象赋值到b和c中，此时就需要使用到虚基表来寻找。

再比如：

	B* pb = &d;
	pb->_a = 10;

pb指向了d的首地址，要更改d中的_a的值，指针pb也需要使用虚基表来进行寻找。

7.继承与组合

(1)两者区别

首先我们要对继承和组合进行区分：

继承表示的是子类继承父类，组合表示的是在一个类中定义了另一个类的成员变量。

//继承
class A
{
public:
	int _a;
};
class B:public A
{
public:
	int _b;
};
//组合
class C
{
public:
	int _c;
};
class D 
{
public:
	int _d;
	C _obj;
};

(2)继承与组合的区别

我们需要明确一点：类之间，模块之间最好是低耦合，高内聚的，因为方便维护。

低耦合：类之间依赖关系越弱越好。

高内聚：内部成员关系紧密。

1.继承对应于白盒：B可以直接使用A中的公有和保护成员，破坏了封装性。

2.组合对应于黑盒：D只能使用C的公有，不能直接使用保护成员。

举一个例子：

如果A中有5个public，5个protected

对于组合来说，非基类只能使用这5个public，基类中的其他成员随便修改都不会影响该非基类。

对于继承来说，基类中一切的改变都会影响子类。

那可以抛弃继承的语法吗？当然是不行的。

多态是建立在继承的基础上的。

(3)使用情况

1.如果B就是一个A，比如Student是一个Person，我们称这种关系为is-a关系，此时适合使用继承。

2.如果D被包含于C，比如head包含eyes，我们称这种关系为has-a关系，此时适合使用组合。

3.当遇到特殊情况，is-a和has-a都可以讲通时，优先使用组合。

8.总结

C++的语法复杂在于C++是第一个吃螃蟹的人，很多地方会考虑太多，拿多继承举例，有了多继承就有了菱形继承，有了菱形继承，就有了菱形虚拟继承，底层实现就更为复杂了，所以一般不建议设计多继承，设计了多继承也不建议设计菱形继承。

到此这篇关于详解C++中单继承与多继承的使用的文章就介绍到这了,更多相关C++单继承 多继承内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！