C++继承[万字详解]

目录

一.继承的介绍

1.1、继承的概念

1.2、继承的定义

1.2.1、定义格式

 1.2.2、继承关系和访问限定符

1.2.3、继承基类成员后，在子类中成员访问方式的变化

二.基类和派生类对象赋值转化

三.继承中的作用域

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

★派生类的构造函数

派生类的拷贝构造函数

派生类中的operator=赋值运算符重载

★派生类中的析构函数

五.继承与友元

六.继承与静态成员

七.复杂的菱形虚拟继承及菱形虚拟继承

单继承与多继承

关于继承的几个小问题

1.如何设计一个不能被继承的类?

 2.多继承中指针偏移问题，根据这段代码，正确选项是( )

菱形继承

菱形虚拟继承

八.继承的总结和反思

继承和组合

---

一.继承的介绍

我们知道C++主要有三大特性：继承、多态、封装.

本章我们将详细讲解C++中的继承，多态将在下一章讲解.

1.1、继承的概念

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

先来代码看一下继承是怎么用的.

//定义一个person类
class person
{
public:
	void print()
	{
		cout << name << endl;
		cout << id << endl;
	}
protected:
	string name = "hyx";
	int id = 2023;
};

//Student 继承了person类，
//继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。相当于是子类包括父类所有的(成员+函数)和它原来本身所有的(成员+函数).
class Student : public person
{
protected:
	int stuid;//学号
};

那么为什么要有继承呢？

可以用例子来解释，比如有三个类：学生类，工人类，教师类.

如果单独写的话，需要分别写三个类代码可能会很长冗余.

但是我们仔细想可以发现，这些类都有共同的特点，比如姓名，年龄，性别等等

我们可以把它们共有的特征提出来单独构建一个类，然后再分别用这三个类继承它.这样代码量就减少了很多.

为了验证以上所说的，我们测试一下，子类中是否可以用父类中的函数.

int main()
{
	person p;
	Student s;
	p.print();
	s.print();

	return 0;
}

运行结果：

可以看到子类对象也成功调用了父类的print()函数.

1.2、继承的定义

1.2.1、定义格式

定义格式如下：

 1.2.2、继承关系和访问限定符

继承关系

 访问限定符

访问限定符中：public成员可以被外部以及继承访问.

protected成员，不可以被外部访问但可以被继承访问.

private成员，外部和继承都不可以被访问.

1.2.3、继承基类成员后，在子类中成员访问方式的变化

我们上面可以看到定义继承的时候，有个继承方式，这个是什么呢？

这个继承方式和基类中成员的访问方式决定了在子类中父类成员的访问类型.

这个是表格对其总结.

看起来很复杂，这里有个规律就是：子类成员中的父类成员的访问类型 = 父类访问类型和继承方式中访问权限最小的一个.访问权限从小到大为private < protected < public.

但是有个特殊：就是当父类中成员访问类型是private时，无论子类以什么方式继承，最后在子类中的成员都是不可见的.

这个不可见的含义是：类内，类外都不可以访问.

记得和private的区分：private的是类内可以访问，类外不可以访问

下面是对上面的一种总结.

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

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

3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。

4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式

5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强

二.基类和派生类对象赋值转化

 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

基类对象不能赋值给派生类对象。

看下面的例子来理解下：

class Person
{
protected:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};
class Student : public Person
{
public:
	int _num; // 学号
};
void Test()
{
	Student sobj;
	// 1.子类对象可以赋值给父类对象/指针/引用
    //注意：这里虽然是不同类型，但不是隐式类型转化（切割后不会影响子类本身，会将切片复制一份拷贝给子类）
    //这算是一个特殊支持，语法天然支持
	Person pobj = sobj;
	Person* pp = &sobj;
	Person& rp = sobj;
}

2.

	//2.基类对象不能赋值给派生类对象
	sobj = pobj;//错误赋值

图示可如下：

三.继承中的作用域

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

用下面这段程序来理解一下：

class Person
{
protected:
	string _name = "小郝"; // 姓名
	int _num = 111; // 身份证号
};
//Student类与Person类中都有_num,但是子类(Student类)会把父类中的_num隐藏，此时再访问子类中的_num,便是子类的_num=999
class Student : public Person
{
public:
	void Print()
	{
		cout << " 姓名:" << _name << endl;
		cout << " 学号:" << _num << endl;
        cout << " 身份证号:" << Person::_num << endl;
	}
protected:
	int _num = 999; // 学号
};
void Test()
{
	Student s1;
	s1.Print();
};

我们来验证一下，学号是不是子类的999，而父类的111被隐藏了。

要想访问父类的_num，是不是前面得加上父类的域.

可以看到结果符合我们的预期.

然后再来看下面一段程序，对上面所说的函数隐藏理解加深一下.

class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		A::fun();
		cout << "func(int i)->" << i << endl;
	}
};
void Test()
{
	B b;
    //由于B类中fun()与父类A类中fun()重名，所以调用的是B类的fun()函数.
    //想调用A类中的fun(),必须加上作用域
	b.fun(10);
};
int main()
{
	Test();

	return 0;
}

运行结果应该是先调用B类中fun(),既调用A中的fun(),再cout一下i.

结果和预想的一样.

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

我们知道普通的类有6个默认成员函数，但是如果我们继承了某个类之后，这个子类的6个默认成员函数会做什么呢？

“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员又分别有什么作用呢？

★派生类的构造函数

在派生类的构造函数中，一共有两个行为：

1.自己成员，跟平常的构造函数一样

2.继承的父类成员，必须调用父类的构造函数初始化

顺序是：先调用父类构造函数，再调用子类的构造函数.

在2中，如果子类没有显式调用父类构造函数，那么系统会自动调用父类的默认构造函数，（默认构造函数有两种：1.没有写，系统自动生成 2. 写了，但是没有参数 3.写了，但是参数是全缺省的）    

可以看下面这段例子：

class Person
{
public:
    //父类的默认构造函数
	Person(const string& name = "hyx")
		:_name(name)
	{
		cout << "Person()" << endl;
	}
protected:
	string _name;
};
class Student:public Person
{
public:
	Student()
		:_num(1)
	{
		cout << "Student()" << endl;
	}
private:
	int _num;

};
int main()
{
	Student s;
	return 0;
}

这个例子子类没有显式调用父类的构造函数，所以系统会先自动调用的父类的默认构造函数，然后再调用子类的构造函数.

看一下运行结果：

结果正如我们所料. 

 父类和子类的成员变量也都初始化了.

但是如果父类没有默认构造函数，而子类也没有显式调用，那该怎么初始化呢？

我们先看一下父类没有默认构造函数的情况下，子类不显式调用会发生什么

此时把默认构造的缺省值去掉：

运行之后： 

 直接报错，错误原因是：父类没有合适的默认构造

确实如我们所想，那我们该怎么显式调用它呢？

正确的办法是用一种类似于匿名对象的方法，在子类初始化列表进行初始化，如下：

class Student:public Person
{
public:
	Student()
		:_num(1)
		,Person("hyx")//注意不能是_name = name,可以这样理解：子类中会把父类当做一个整体来调用，而不是单独的类成员.
	{
		cout << "Student()" << endl;
	}
private:
	int _num;

};

这里一定要注意上面的注释所写的.

总结下来就是：

派生类的构造函数 必须调用基类的构造函数 初始化 基类 的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显式调用

派生类的拷贝构造函数

在派生类的拷贝构造函数中，也是需要完成两个行为：

1.对于子类自己的成员，直接调用自己的拷贝构造（内置类型拷贝，自定义类型调用它的拷贝构造）

2.对于继承的父类成员，将调用父类的拷贝构造函数初始化.

在2中，情况和构造函数一样，如果没有显式调用，则系统会自动调用父类的拷贝构造函数.

可以先看一下在不显式调用情况下的结果：

 父类中添加拷贝构造函数:

	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

子类不做处理.

运行一下：

可以发现自动调用了父类的拷贝构造函数.

显式调用需要特别说明一下怎么调用. 

如下代码：

	Student(const Student& s)
		//注意这里是显式调用，一般情况下我们不需要显式调用，默认生成的就够用，除非在需要深拷贝的情况下，才需要显式调用父类所写的拷贝构造函数
        //至于为什么可以用子类对象构造父类对象，这不是不可以的吗？其实这里是切片，将子类中父类的部分切除下来并且拷贝给子类.
        :Person(s)
		, _num(s._num)
	{};

注意一定要注意文中注释所说的.

当然如果没有切片的话，我们也可以将Student*强转为Person*，然后再解引用就可以取出数据内容.这种方法基本不用，只是一种假设没有切片的情况下，一般我们都使用切片.

派生类中的operator=赋值运算符重载

和上面的几乎完全一致.在派生类中使用“=”运算符，也会有两个行为完成.

1.子类调用自身的“=”运算符重载

2.自动调用父类的"="的运算符重载

一般对内置类型不用处理，对于自定义类型需要

当显式调用的时候，一定要加上上父类的类域，因为子类的“=”运算符重载会将父类的“=”运算符隐藏，进而无限递归.

代码如下：

//Person类:父类“=”运算符重载
		Person& operator=(const Person& p)
		{
			cout << "Person& operator=(const Person& p)" << endl;
			if (this != &p)
				_name = p._name;

			return *this;
		}
//Student类:子类“=”运算符重载
	Student& operator= (const Student & s)
	{
		if (this != &s)
		{
			//注意不要直接写operator=(s),因为子类的会隐藏父类的拷贝构造，进而造成无限递归，栈溢出
			Person::operator=(s);
			_num = s._num;
		}
	}

★派生类中的析构函数

规则同上，但顺序不同：

1.先调用派生类的析构函数

2.再调用基类的析构函数

如果不写，则会默认生成析构函数，对于内置类型不做处理，自定义类型调用对应的析构函数.

	~Person()
	{
		cout << "~Perosn()" << endl;
	}
    //student类不写析构函数

可以看到虽然子类没写构造函数，但是三个类对象也都调用了基类的析构函数.

但是如果我们想显式调用析构函数该怎么办呢？（注意析构函数不可以显式调用基类的，是错误的！这里这是为了引出一个结论，后面会细讲）

我们在子类中写一个析构函数，并且调用基类析构函数：

 

 可以看到跑不起来，报错了，错误原因竟然是：没有合适的析构函数可用！

我调用析构函数和构造函数有啥关系呢？

这是因为析构函数在这里是一个非常特殊的函数.

因为子类析构的函数跟父类的析构函数构成隐藏！

所以这里的报错应该是找不到~Person()函数

这里出现构造函数，是由于编译器自己的原因，就是由各种语法，特性缠绕在一起，产生了一个与真实问题完全不相干的问题.

既然构成隐藏，直接加上作用域就可以了.

 可是有个问题就是，隐藏的要求不是作用域不同，而函数名不同才可以构成吗?这俩函数名也不相同啊，怎么就隐藏了呢？

其实这是由于后面多态的需要，析构函数名字会被统一处理成destructtor().

下面再来说析构函数调用顺序问题：

可以看到析构函数是先调用子类自己的，再调用父类的.

这是由于子类继承父类，因为是父类先构造初始化的，子类最后再构造的.

所以符合后定义的先析构，先定义的后析构，子类后定义，所以子类先被析构.

因为这些变量存储在栈里面，在局部栈帧中，先进后出，后进先出.

所以为了保证这个顺序，如果自己显式调用析构，则这个顺序就无法保证，所以系统会自动调用.

自己不需要显式调用父类的析构函数，每个子类的析构函数后面会自动调用父类的析构函数.

所以显式调用的话会有重复，重复的话，普通的变量没什么，但是如果是一个指针，连续被释放两次，一定会出错的.

对以上的几个派生类中的成员函数进行一个总结.

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调派生类构造。
6. 派生类对象析构清理先调用派生类析构再调基类的析构。

五.继承与友元

这一节比较容易理解，总结下来就一句话：

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

一个代码例子就可以理解：

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;
}
void main()
{
	Person p;
	Student s;
	Display(p, s);
}

可以看到虽然子类继承了父类，而父类的友元函数Display只能访问父类的成员，而子类的却不可以被访问 （但是子类依然可以调用父类的成员）.

六.继承与静态成员

也是一句话可以解释它：

用以下代码可以验证：

class Person
{
public:
	Person() {}
protected:
	string _name; // 姓名
public:
	int _count = 0;//普通count变量
	static int _staticcount; // 静态成员count
};
int Person::_staticcount = 0;
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
	string _seminarCourse; // 研究科目
};
void Test()
{
	Person p;
	Student s;
	Graduate g;
	p._count++; p._staticcount++;
	s._count++; s._staticcount++;
	g._count++; g._staticcount++;

	cout << "Person: 普通count：" << p._count << "           " << "Person: 静态count：" << p._staticcount << endl;
	cout << "Student: 普通count：" << s._count << "           " << "Student: 静态count：" << s._staticcount << endl;
	cout << "Graduate: 普通count：" << g._count << "           " << "Geaduate: 静态count：" << g._staticcount << endl;
}
int main()
{
	Test();
}

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

可以看到普通的count每一个都是独立的，而静态的count只有一份，无论哪一个子类，加的都是同一个staticcount.

七.复杂的菱形虚拟继承及菱形虚拟继承

单继承与多继承

先来介绍一下什么是单继承，什么是多继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承.

我们上面写的都是单继承，图示如下：

 多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承.

就是说一个子类继承了多个父类，如下图所示：

即Assistant类继承了Student类和Teacher类.

 菱形继承后面我们讲.

先来说几个问题：

关于继承的几个小问题

1.如何设计一个不能被继承的类?

答：将父类的构造函数私有化（private），这样在子类中是不可见的。当子类对象实例化时，会无法调用构造函数.

以上是C++98的实现方法，但只能在实例化的时候才能看出来.

但是在C++11中，增添了final关键字，可以将当前类设置为不可被继承，无论是否实例化，一旦有继承它的会立即报错.

 2.多继承中指针偏移问题，根据这段代码，正确选项是( )

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

A：p1 == p2 == p3    B：p1 < p2 < p3    C：p1 == p3 != p2    D：p1 != p2 != p3 

这段程序首先是两个类，分别为Base1和Base2.

然后Derive类继承了Base1和Base2类（多继承）

然后程序是创建一个Derive类对象，然后取其地址分别赋为Base1类型的指针，Base2类型的指针，和Derive本身类型.

在这我们用图来解释一下:

这里还是需要特殊说明一下：在多继承中，在内存中的位置先后取决于继承时的先后顺序.

 例如将

class Derive : public Base1, public Base2 { public: int _d; };

改为

class Derive : public Base2, public Base1 { public: int _d; };

则Base2则会在Base1上面，答案就会变为p2==p3!=p1.

但这只是指针的比较，类对象中的存储位置地址还是先申请的地址低，后申请的地址高.

即在地址中的大小_d > _b2 > _b1.

菱形继承

 接下来正式介绍菱形继承：

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

看如下图示

 这么继承是菱形继承，但是会存在一些问题：数据冗余和二义性.

数据冗余

Student类和Teacher类都继承了Person类的成员，Assistant类再继承Student和Teacher，则在Assistant类中会有两份Person的成员，调用两次构造函数，造成数据冗余.

二义性

当Assistant的对象调用Person中的对象时，编译器不知道调用的是Student和Teacher中哪一个类中的.

看下面的例子

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; // 主修课程
};
void Test()
{
	// 这样会有二义性无法明确知道访问的是哪一个
	Assistant a;
	a._name = "peter";
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}

虽然可以指定访问哪个父类中的成员，可以解决二义性问题，但是数据冗余问题依然无法解决.

那我们该如何解决这个数据冗余的问题呢？

菱形虚拟继承

这个时候就需要菱形虚拟继承，即用关键字virtual来修饰多继承中被继承的父类.

 这样三个类中访问到的成员都是同一个:

执行：

	a._name = "peter";

 执行：

	a.Student::_name = "xxx"

 可以看到改变一个，其它的变量也都跟着改变.

至于虚继承的实现原理，比较复杂，大致是公共成员变量放在地址的公共区域中，每个父类中在地址中不仅存储自身成员的位置，还存储与公共成员变量的距离(偏移量）,这样可以找到这个公共的成员变量，然后再进行操作.

总的来说，菱形继承能不用就不用！是非常不推荐使用的！

八.继承的总结和反思

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。

2. 多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承，如Java。

继承和组合

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

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

继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用
(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

我对上面的进行一个总结：使用继承方法会一定程度破坏基类的封装，因为它可以访问基类的内部细节.

这是类继承：

//is - a
class Car
{
protected:
	string _color = "白色";
};
class Bez : public Car
{
	void Drive()
	{
		cout << "舒适-好开" << endl;
	}
};

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

进行一个总结：对象组合只能使用组合对象的接口，其内部细节不可见，能维持类的包装.

这是组合：

//has - a
class Tire {
protected:
	string _brand = "Michelin"; // 品牌
};
class Car {
protected:
	string _colour = "白色"; // 颜色
	Tire _t; // 轮胎（复用了Tire）
};

一些类型既可以认为是is-a，也可以认为是has-a，实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适
合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就
用组合.

这就是C++继承的全部内容了.如果有错误或不明白的地方，欢迎指正或者提问哦.