C++进阶继承-创新互联

作者：@小萌新
专栏：@C++进阶
作者简介：大二学生 希望能和大家一起进步！
本篇博客简介：简单介绍C++中继承的概念

成都创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：做网站、成都做网站、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的太平网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

• 继承的概念及定义
• • 继承的概念
• 继承的定义
• • 定义格式
  • 继承方式和访问限定符
  • 默认继承方式
• 基类和派生类的赋值转换
• 继承中的作用域
• 派生类的默认成员函数
• 继承与友元
• 继承与静态成员
• 继承方式
• • 单继承
  • 多继承
  • 菱形继承
  • 菱形的虚拟继承
  • 菱形虚拟继承的原理
  • 继承与组合
• 笔试面试题
• 总结

继承是一种面向对象编程的概念，它指的是一个类（称为子类）可以从另一个类（称为父类）中继承属性和方法。这意味着子类可以获得父类中定义的所有属性和方法，并且可以在不改变父类代码的情况下扩展或修改这些属性和方法。

那么这么做的优点是什么呢？

很显然的一点 可以增强代码的复用性 减少冗余代码

用代码来举个例子

class person
{public:
	void Print()
	{cout<< "name : "<< _name<< endl;
		cout<< "age : "<< _age<< endl;
	}
protected:
	string _name = "zhangsan";
	int _age = 18;
};

// 学生类
class student :public person
{public:
private:
	int _stuid;
};
// 教师类
class teacher :public person
{public:
private:
	int _jobid;
};

从而达到一个这样子的效果

继承之后父类的所有成员 包括成员变量和方法 都会成为子类的一部分

继承的定义方式如下

我们都知道 访问限定符有三种

1. public访问
2. protected访问
3. private访问

继承的方式也有三种

1. public继承
2. protected继承
3. private继承

基类当中被不同访问限定符修饰的成员，以不同的继承方式继承到派生类当中后，该成员最终在派生类当中的访问方式将会发生变化。

如下图

实际上稍作观察之后我们就能发现

在子类中的访问访问方式遵循以下规则

1. 当父类的访问方式为protected或者public时 在子类中它会变成继承方式和父类访问方式中权限更小的值

什么意思呢？ 比如说父类的访问方式是public 子类使用protected继承 那么它在子类中的访问方式就变成protected了

如果父类的访问方式是protected 子类使用public继承 那么它在子类中的访问方式还是protected

2. 当父类的访问方式是privated时 不管子类使用何种继承方式 都是不可见的

那么不可见又是什么意思呢？

我们写出下面的一段代码

class person
{public:
	void Print()
	{cout<< "name : "<< _name<< endl;
		cout<< "age : "<< _age<< endl;
	}
protected:
	string _name = "zhangsan";
	int _age = 18;
private:
	string _add = "chenghuadadao";
};

// 学生类
class student :public person
{public:
	void testerr()
	{cout<< this->_add<< endl;
	}

我们可以发现 在学生类中 我们是无法访问父类中的_add的

事实上这里的编译器也直接给了我们红线报错

这里其实也从侧面说明了protected访问限定符为什么会出现

它的作用就是为了不想让类外部访问 而想让子类访问

但是 我们在实际写代码的过程中一般都是用public继承

这也是C++被人诟病的语法缺点之一 后续的python语言甚

至都没有继承方式这一说了

这里我们不推荐使用默认继承方式 所以也就不多讲了

我们只需要知道两点

class的默认继承方式是 private

struct的默认继承方式是 public

派生类对象可以赋值给基类的对象 基类的指针 基类的引用

在这个过程当中会发生基类和派生类对象之间的赋值转换

我们来看代码

class person
{public:
	string _name;
	string _sex;
	int age;
};

class student : public person
{private:
	int _stuid;
};

像上面的代码 我们写下下面这些操作全部是合法的

student s;
	person p = s;
	person* ptr = &s;
	person& ref = s;

对于我们上面的操作 C++中给了一个比较专业的名词叫做切片

意思就是将子类中继承基类的那部分切出来 赋值给基类

对象赋值

指针赋值

引用赋值

那么这个时候我们再想一下 基类对象能否赋值给子类呢

我们写出上面的代码 结果发现报错了

其实想想也能明白 基类相对于子类来说会少一些东西

所以肯定是不能切片赋值的

但是子类的指针和引用可以通过强制类型转换的方式来赋值

代码和显示效果如下

student* ptrs = (student *)&p;
	student& refs = (student&)p;

同样的 我们知道有这个方式存在就好 不建议使用！

接下来我们要学习的是C++继承中的又一大缺陷（bushi） 特性之一

还是一样 我们先来看代码

//父类
class Person
{protected:
	int _num = 111;
};
//子类
class Student : public Person
{public:
	void fun()
	{cout<< _num<< endl;
	}
protected:
	int _num = 999;
};
int main()
{Student s;
	s.fun(); 
	return 0;
}

我们如果敲上上面的一段代码 并且调用fun函数的话 由于函数的局部性原理 我们会得到子类中的num值 如下图

这个时候如果我们想要访问父类中的num就需要使用域操作符

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

在继承体系中的基类和派生类都有独立的作用域。若子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。

需要注意的是，如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

还是拿上面的代码距离 我们给父类中加上一个fun函数

class Person
{public:
	void fun()
	{cout<< _num<< endl;
	}

像这样 如果我们要调用父类里面的person函数只能加上一个域操作符 如下图

特别的 这两个函数不构成函数重载 因为构成函数重载的两个函数一定要在同一作用域

我们在真正写代码的时候应该避免重名的问题

我们都知道 类有六大默认成员函数

下面我们看看派生类当中的默认成员函数，与普通类的默认成员函数的不同之处。

其实这里只要记住一点就好

凡是与基类相关的部分 都要调用基类的相关函数

接下来我们来看代码

这是基类person的代码

//基类
class Person
{public:
	//构造函数
	Person(const string& name = "peter")
		:_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;
	}
private:
	string _name; //姓名
};

这是子类student的代码

//派生类
class Student : public Person
{public:
	//构造函数
	Student(const string& name, int id)
		:Person(name) //调用基类的构造函数初始化基类的那一部分成员
		, _id(id) //初始化派生类的成员
	{cout<< "Student()"<< endl;
	}
	//拷贝构造函数
	Student(const Student& s)
		:Person(s) //调用基类的拷贝构造函数完成基类成员的拷贝构造
		, _id(s._id) //拷贝构造派生类的成员
	{cout<< "Student(const Student& s)"<< endl;
	}
	//赋值运算符重载函数
	Student& operator=(const Student& s)
	{cout<< "Student& operator=(const Student& s)"<< endl;
		if (this != &s)
		{	Person::operator=(s); //调用基类的operator=完成基类成员的赋值
			_id = s._id; //完成派生类成员的赋值
		}
		return *this;
	}
	//析构函数
	~Student()
	{cout<< "~Student()"<< endl;
		//派生类的析构函数会在被调用完成后自动调用基类的析构函数
	}
private:
	int _id; //学号
};

是不是发现完全符合我们上面的推论

这里有两个特殊结论

派生类对象初始化时，会先调用基类的构造函数再调用派生类的构造函数。
派生类对象在析构时，会先调用派生类的析构函数再调用基类的析构函数。

所以说我们在派生类的析构函数中不需要在显示调用基类的析构函数了

我们可以发现 假设我们显示的调用基类的析构函数的话 就会析构两次

这在一些情况（开辟释放内存）下会发生错误

此外还有以下三个注意点

1. 派生类和基类的赋值运算符重载函数因为函数名相同构成隐藏，因此在派生类当中调用基类的赋值运算符重载函数时，需要使用作用域限定符进行指定调用。
2. 由于多态的某些原因，任何类的析构函数名都会被统一处理为destructor();。因此，派生类和基类的析构函数也会因为函数名相同构成隐藏，若是我们需要在某处调用基类的析构函数，那么就要使用作用域限定符进行指定调用。
3. 在派生类的拷贝构造函数和operator=当中调用基类的拷贝构造函数和operator=的传参方式是一个切片行为，都是将派生类对象直接赋值给基类的引用。

这里还是记住一点就好 友元关系不可以继承

比如说

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函数不能访问student

要想访问的话必须要在student中也声明友元

class Student : public Person
{public:
	//声明Display是Student的友元
	friend void Display(const Person& p, const Student& s);
protected:
	int _id; //学号
};

这个时候我们就可以使用dis函数访问它们的内容了

我们都知道 静态变量是储存在静态区里面的 那么不管我们派生出多少个子类 实际上它们的静态变量储存地址都是一样的

我们可以使用下面的代码来证明

class person
{public:
	static int _count ;
};

int person::_count = 0;
class student :public person
{public:
	void test()
	{_count++;
	}
};

我们试着调用子类中的函数让_count++

之后打印子类和父类中的_count看看是不是都是1

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

比如下面这种方式

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

比如说下面这样子

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

从上面的图我们不难看出 菱形继承一定存在着数据冗余和二义性的问题

比如说我们来看下面的代码

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

我们运行上面的代码之后就会发生一个这样子的问题

对于二义性问题 我们可以通过指定作用域来解决

Assistant a;
	a.Student::_name = "peter"; 
	a.Teacher::_name = "peter2";

但是数据冗余的问题缺一定解决不了 如下图

这个时候就轮到我们的虚继承出场了

这种继承方式就是为了专门解决菱形继承的二义性还有数据冗余问题被发明出来的

我们只需要在上面的继承方式前加上这段代码

class Person
{public:
	string _name; //姓名
};
class Student : virtual public Person //虚拟继承
{protected:
	int _num; //学号
};
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;
}

这个时候我们便发现不会报错了

此时 不管你是访问teacher还是student中的name 都是访问的一个地址

我们首先看看 如果我们不适用菱形虚拟继承 那么这几个类在内存中会是怎么样分布的

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

接下来我们打开内存窗口

我们可以发现 它在内存中的分布是这样子的
（重点观察_a 两个a的地址不一样）

接下来我们看看虚继承会是什么样子的

#includeusing namespace std;
class A
{public:
	int _a;
};
class B : virtual public A
{public:
	int _b;
};
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;
}

还是一样 我们来打开内存窗口

这个时候我们可以看到 _a被存放到了最后 而一开始存放_a的两个数据则被两个奇怪的数据代替了

实际上呢 这两个奇怪的数据就是指针

它们被叫做虚基表指针

分别指向一个虚基表 而我们通过虚基表则能够找到_a的地址

如下图

很多人都说C++语法复杂，其实多继承就是一个体现。有了多继承，就可能存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出菱形继承，否则代码在复杂度及性能上都容易出现问题，当菱形继承出问题时难以分析，并且会有一定的效率影响。

那么这个时候我们的组合就出现了

继承和组合的区别有什么呢？

继承是一种is-a的关系，也就是说每个派生类对象都是一个基类对象；而组合是一种has-a的关系，若是B组合了A，那么每个B对象中都有一个A对象。

比如说我们看下面的代码

车和保时捷就是一种is a的关系 我们可以说 保时捷是一辆车

所以说这种情况使用继承好一点

class  Car
{protected:
	string _colour; //颜色
	string _num; //车牌号
};
class Porsche : public Car
{;
};

但是呢 像车轮胎和保时捷 就是一种has a的关系了

我们只能说保时捷有车轮胎 不能说保时捷是车轮胎

class Tire
{protected:
	string _brand; //品牌
	size_t _size; //尺寸
};
class Car
{protected:
	string _colour; //颜色
	string _num; //车牌号
	Tire _t; // 这里就使用了一个包含关系
};

若是两个类之间既可以看作is-a的关系，又可以看作has-a的关系，则优先使用组合。

1. 继承允许你根据基类的实现来定义派生类的实现，这种通过生成派生类的复用通常被称为白箱复用(White-box
   reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对于派生类可见，继承一定程度破坏了基类的封装，基类的改变对派生类有很大的影响，派生类和基类间的依赖性关系很强，耦合度高。
2. 组合是类继承之外的另一种复用选择，新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口，这种复用风格被称之为黑箱复用(Black-box reuse)，因为对象的内部细节是不可见的，对象只以“黑箱”的形式出现，组合类之间没有很强的依赖关系，耦合度低，优先使用对象组合有助于你保持每个类被封装。
3. 实际中尽量多使用组合，组合的耦合度低，代码维护性好。不过继承也是有用武之地的，有些关系就适合用继承，另外要实现多态也必须要继承。若是类之间的关系既可以用继承，又可以用组合，则优先使用组合。

1. 什么是菱形继承？菱形继承的问题是什么？

菱形继承是多继承的一种特殊情况，两个子类继承同一个父类，而又有子类同时继承这两个子类，我们称这种继承为菱形继承。
菱形继承因为子类对象当中会有两份父类的成员，因此会导致数据冗余和二义性的问题。

2. 什么是菱形虚拟继承？如何解决数据冗余和二义性？
   

菱形虚拟继承是指在菱形继承的腰部使用虚拟继承(virtual)的继承方式，菱形虚拟继承对于D类对象当中重复的A类成员只存储一份，然后采用虚基表指针和虚基表使得D类对象当中继承的B类和C类可以找到自己继承的A类成员，从而解决了数据冗余和二义性的问题。

3. 继承和组合的区别？什么时候用继承？什么时候用组合？

1 继承是一种is-a的关系，而组合是一种has-a的关系。如果两个类之间是is-a的关系，使用继承；
2 如果两个类之间是has-a的关系，则使用组合；
3 如果两个类之间的关系既可以看作is-a的关系，又可以看作has-a的关系，则优先使用组合。

本篇博客主要介绍了C++继承的一些相关知识

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧