C++知识点52——多重继承

最新推荐文章于 2022-06-02 13:29:06 发布
原创 最新推荐文章于 2022-06-02 13:29:06 发布 · 690 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #类 #继承 #面向对象编程

本文介绍了C++多重继承的概念、规则及问题。多重继承允许一个类有多个基类，其构造与析构函数、拷贝构造与operator=规则和单继承类似。但多重继承会出现二义性错误，可通过添加作用域或在子类实现同名函数避免。

一、概念

C++允许一个类拥有多个基类，所以就有了多重继承。多重继承和单一继承很多方面都是类似的。

示例

class zooanimal
{
public:
	zooanimal(){cout<<__func__<<endl;}
	virtual ~zooanimal(){cout<<__func__<<endl;}
};

class bear:public zooanimal
{
public:
	bear(){cout<<__func__<<endl;}
	~bear(){cout<<__func__<<endl;}
};

class endangered
{
public:
	endangered(){cout<<__func__<<endl;}
	~endangered(){cout<<__func__<<endl;}
};
class panda:public bear, public endangered
{
public:
	panda(){cout<<__func__<<endl;}
	~panda(){cout<<__func__<<endl;}	
};

上述代码中panda就是继承了bear和endanger

 

二、规则

1、多重继承的构造函数与析构函数

和单继承一样，子类对象是由每个基类和子类特有的部分共同组成的，上述代码中，子类panda对象的结构如下

当创建一个panda对象时，各个类构造函数和析构函数的执行顺序和单继承的规则一样：根据基类在派生列表中出现的顺序，依次进行构造，派生列表中第一个出现的是bear类，所以先创建bear对象，又发现bear是zooanimal的子类，所以先创建zooanimal的对象，然后创建bear对象。第二个出现在派生列表中的类是endangered，所以创建endangered类对象，最后创建panda中独有的部分，之后，整个panda对象生成完毕。析构函数的调用顺序和构造函数相反

上述代码只是隐式使用bear和endangered的构造函数，可以显示调用

class panda:public bear, public endangered
{
public:
	panda():bear(),endangered(){cout<<__func__<<endl;}
	~panda(){cout<<__func__<<endl;}
};

 

2.多重继承的拷贝构造与operator=

和单继承一样，如果不显示调用基类的拷贝构造，那么在拷贝初始化子类对象时，只会调用基类的构造函数

class zooanimal
{
public:
	zooanimal(){cout<<__func__<<endl;}
	zooanimal(const zooanimal &t) {cout<<"zooanimal(const zooanimal &t)"<<endl;}
	~zooanimal(){cout<<__func__<<endl;}
};

class bear:public zooanimal
{
public:
	bear(){cout<<__func__<<endl;}
	bear(const bear &t) {cout<<"bear(const bear &t)"<<endl;}
	~bear(){cout<<__func__<<endl;}
};

class endangered
{
public:
	endangered(){cout<<__func__<<endl;}
	endangered(const endangered &t) {cout<<"endangered(const endangered &t)"<<endl;}
	~endangered(){cout<<__func__<<endl;}
};

class panda:public bear, public endangered
{
public:
	panda():bear(),endangered(){cout<<__func__<<endl;}
	panda(const panda &t){cout<<"panda(const panda &t)"<<endl;}
	~panda(){cout<<__func__<<endl;}
};

int main(int argc, char const *argv[])
{
	panda t;
	panda t2=t;
	return 0;
}

可见，上图中，只调用了子类对象的拷贝构造函数，而没有调用各个基类的拷贝构造函数

显示调用基类中的拷贝构造函数后，拷贝初始化子类对象时就会调用各个基类的拷贝构造

class zooanimal
{
public:
	zooanimal(){cout<<__func__<<endl;}
	zooanimal(const zooanimal &t) {cout<<"zooanimal(const zooanimal &t)"<<endl;}
	~zooanimal(){cout<<__func__<<endl;}
};

class bear:public zooanimal
{
public:
	bear(){cout<<__func__<<endl;}
	bear(const bear &t):zooanimal(t) {cout<<"bear(const bear &t)"<<endl;}
	~bear(){cout<<__func__<<endl;}
};

class endangered
{
public:
	endangered(){cout<<__func__<<endl;}
	endangered(const endangered &t) {cout<<"endangered(const endangered &t)"<<endl;}
	~endangered(){cout<<__func__<<endl;}
};

class panda:public bear, public endangered
{
public:
	panda():bear(),endangered(){cout<<__func__<<endl;}
	panda(const panda &t):bear(t),endangered(t){cout<<"panda(const panda &t)"<<endl;}
	~panda(){cout<<__func__<<endl;}
};

如果panda没有显示定义拷贝构造函数，那么在对panda对象进行拷贝初始化时，会使用编译器提供的拷贝构造函数，此时也会调用基类的拷贝狗构造函数，将上述代码的29行注释掉后，输出结果如下

可见，使用编译器提供的拷贝构造函数时，会调用子类的拷贝构造函数

 

operator=也是一样，如果各个基类显示定义了operator=，那么如果子类也定义了operator=，那么要在子类中显示调用基类的operator=，否则只会调用子类的operator=

class zooanimal
{
public:
	zooanimal(){cout<<__func__<<endl;}
	zooanimal &operator=(const zooanimal &t) {cout<<__func__<<"zooanimal"<<endl;return *this;}
	~zooanimal(){cout<<__func__<<endl;}
};

class bear:public zooanimal
{
public:
	bear(){cout<<__func__<<endl;}
	bear &operator=(const bear &t) {cout<<__func__<<"bear"<<endl;return *this;}
	~bear(){cout<<__func__<<endl;}
};

class endangered
{
public:
	endangered(){cout<<__func__<<endl;}
	endangered &operator=(const endangered &t) {cout<<__func__<<"endangered"<<endl;return *this;}
	~endangered(){cout<<__func__<<endl;}
};

class panda:public bear, public endangered
{
public:
	panda():bear(),endangered(){cout<<__func__<<endl;}
	panda &operator=(const panda &t) {cout<<__func__<<"panda"<<endl;return *this;}
	~panda(){cout<<__func__<<endl;}
};

int main(int argc, char const *argv[])
{
	panda t;
	panda t2;
	t2=t;
	return 0;
}

上述输出结构是子类定义了operator=，但是没有显示调用的结果，显示调用后的代码和输出结果如下

class zooanimal
{
public:
	zooanimal(){cout<<__func__<<endl;}
	zooanimal(const zooanimal &t) {cout<<"zooanimal(const zooanimal &t)"<<endl;}
	zooanimal &operator=(const zooanimal &t) {cout<<__func__<<"zooanimal"<<endl;return *this;}
	~zooanimal(){cout<<__func__<<endl;}
};

class bear:public zooanimal
{
public:
	bear(){cout<<__func__<<endl;}
	bear(const bear &t):zooanimal(t) {cout<<"bear(const bear &t)"<<endl;}
	bear &operator=(const bear &t) {
		cout<<__func__<<"bear"<<endl;
		zooanimal::operator=(t); 
		return *this;
	}
	~bear(){cout<<__func__<<endl;}
};

class endangered
{
public:
	endangered(){cout<<__func__<<endl;}
	endangered(const endangered &t) {cout<<"endangered(const endangered &t)"<<endl;}
	endangered &operator=(const endangered &t) {cout<<__func__<<"endangered"<<endl;return *this;}
	~endangered(){cout<<__func__<<endl;}
};

class panda:public bear, public endangered
{
public:
	panda():bear(),endangered(){cout<<__func__<<endl;}
	panda(const panda &t):bear(t),endangered(t){cout<<"panda(const panda &t)"<<endl;}
	panda &operator=(const panda &t) {
		cout<<__func__<<"panda"<<endl;
		bear::operator=(t);
		endangered::operator=(t);
		return *this;
	}
	~panda(){cout<<__func__<<endl;}
};

如果子类没有显示定义operator=，那么，一般情况，编译器也会自动生成一个operator=，此时对子类对象进行赋值时，也会调用基类的operator=，将上述代码的operator=注释掉的输出结果如下

3.多重继承的问题

和单一继承一样，因为多重继承，所以子类很多个基类，所以，子类对象可以切割转换成任意基类对象，任意基类的指针或引用都可以指向子类。但是可访问的成员依然是由对象，指针，和引用的静态类型决定

访问成员时，查找成员的顺序也和单一继承一样，见博客https://blog.youkuaiyun.com/Master_Cui/article/details/109849186

但是，因为有很多个基类，当不同基类中出现了同名函数时，会出现二义性错误

class zooanimal
{
public:
	zooanimal(){cout<<__func__<<endl;}
	~zooanimal(){cout<<__func__<<endl;}
};

class bear:public zooanimal
{
public:
	bear(){cout<<__func__<<endl;}
	void func() {cout<<__func__<<endl;}
	~bear(){cout<<__func__<<endl;}
};

class endangered
{
public:
	endangered(){cout<<__func__<<endl;}
	void func() {cout<<__func__<<endl;}
	~endangered(){cout<<__func__<<endl;}
};

class panda:public bear, public endangered
{
public:
	panda():bear(),endangered(){cout<<__func__<<endl;}
	~panda(){cout<<__func__<<endl;}
};

int main(int argc, char const *argv[])
{
	panda t;
	t.func();
	return 0;
}

上述代码中，endangered和bear都定义了func，所以，子类对象无法确定该调用哪个，所以出现二义性错误

想避免这种二义性，有两种办法：

1.添加作用域

将上述代码中的34行改为如下

t.bear::func();

此时，指定了func的作用域，指定调用bear中的func，此时不会出现二义性

2.在子类中实现一个同名函数

在子类中实现一个func

void func() {cout<<__func__<<endl;}

此时也不会报错，因为查找func时，会先在子类panda中查找，找到了就不找了，所以不会报错

此外，和单一继承一样，不要让子类和基类中出现名字相同但形参列表不同的函数。示例见博客https://blog.youkuaiyun.com/Master_Cui/article/details/109849186

 

参考

《C++ Primer》

 

欢迎大家评论交流，作者水平有限，如有错误，欢迎指出

C++基础知识 - 多重继承
骆驼胡杨的博客
02-17 533
什么是多重继承 多继承/多重继承: 一个派生类可以有两个或多个基类(父类)。 多重继承在中小型项目中较少使用，在Java、C#等语言中直接取消多继承, 以避免复杂性.     多重继承的用法 将多个基类用逗号隔开. 实例: 例如已声明了类A、类B和类C，那么可以这样来声明派生类D： class D: public A, private B, protected C{ //类D自己新增加的成员 }; D 是多继承形式的派生类， D 有3个父类(基类) 以公有的方式继承 A 类
【C++】继承
HenryBlog
02-24 1242
一、继承的概念及定义 二、父类和子类对象赋值转换 三、继承的作用域 四、派生类的默认成员函数 五、继承和友元 六、继承与静态成员 七、菱形继承和菱形虚拟继承
设计模式：原型模式，c/c++，避免new关键字和构造函数的clone方法
ganfanren00001的博客
10-01 537
设计模式：原型模式在c/c++中的实现方法，实现避免new关键字和构造函数的clone()函数 设计模式之原型模式： 实现一个clone()方法用来拷贝自己的现成数据，用于对同一份内容有极大需求量或构造某对象有极大成本时，c++里面图方便也能实现在拷贝构造函数里。 一、原型模式的作用： 1.资源优化 类初始化需要消耗非常多的资源，包括数据、硬件等 2.性能与安全要求 通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可用原型模式 3.一个对象多个修改者 一个对象需要提供给其他对象访问，且各个调用着可
C++类多重继承与构造函数使用
u010737039的专栏
02-24 1542
/*当建立一个对象时，首先调用基类的构造函数，然后调用下一个派生类的 构造函数，依次类推，直至到达派生类次数最多的派生次数最多的类的构造函数为止。 简而言之，对象是由“底层向上”开始构造的。因为，构造函数一开始构造时，总是 要调用它的基类的构造函数，然后才开始执行其构造函数体，调用直接基类构造函数时， 如果无专门说明，就调用直接基类的默认构造函数。在对象析构时，其顺序正好相反。 下面的这
3.15：C++11继承构造函数 多重继承
qq_41543888的博客
05-08 1697
继承的构造函数 https://blog.youkuaiyun.com/qq_40794602/article/details/98437671 https://blog.youkuaiyun.com/craftsman1970/article/details/82971774 https://blog.youkuaiyun.com/qq_32285693/article/details/89197799 详情转载：http...
C++易错知识点（十二）纯虚函数与抽象类，多重继承，菱形继承与虚继承
weixin_42445051的博客
01-13 354
1，纯虚函数与抽象类 纯虚函数是指一种特殊的虚函数，在许多情况下，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。这就是纯虚函数的作用。存在纯虚函数的类就是抽象类。 在类里纯虚函数的声明： virtual void test() = 0; 2，多重继承 一般的子类都有唯一一个父类，多重继承是指一个子类可以继承多个父类。例如： 如下所示：son作为子类，继承了父类Parent1与Parent2。 class Parent1{ private: int Paren
C++类继承与多重继承作业详解——Person与Teacher类实现
资源摘要信息: "类的继承第二次作业（多重继承与虚基类）参考答案_C++_teacher_" 在C++编程语言中，类的继承是面向对象编程的一个核心概念，它允许程序员创建一个类（称为子类或派生类）来继承另一个类（称为基类或...
C++实验：继承与派生——教师和干部类的多重继承
3. 多重继承：实验中提到`Teacher_Cadre`类从`Teacher`和`Cadre`两个基类派生，这是多继承的例子。多继承允许一个类从多个基类继承特性。 4. 成员函数声明与定义：在类体中声明成员函数，然后在类外部定义其具体...
c++————————笔记
01-12
根据提供的文档内容，我们可以归纳出一系列关于C++的重要知识点，这些知识点主要涵盖了C++的基础语法、数据类型、内存管理、程序结构以及高级特性如类、继承与多态等。下面将详细阐述这些知识点： ### 1. 引言 C++...
C++多重继承实现方法详解
#### 例程名称：实例001——实现C++类的多重继承 #### 实例目标 - 设计两个基类，一个包含表示颜色的属性和方法，另一个包含表示形状的属性和方法。 - 创建一个派生类，通过多重继承同时继承这两个基类。 - 实现...
C++ Primer 5th笔记（chap 18 大型程序工具） 多重继承之构造函数、析构函数
thefist的专栏
11-30 259
1. 继承的构造函数与多重继承 如果从多个基类中继承了相同的构造函数（即形参列表完全相同），则程序将产生错误 struct Basel { Basel () = default; Basel (const std::strings); Basel (std::shared_ptr<int>); }; struct Base2 { Base2() = default; Base2(const std::strings); Base2(int) ; }; // 错误
C++ 多重继承，虚析构确定
芝兰生于深谷，不以无人而不芳
02-05 1524
来个例子就明了了： #include using namespace std; class Base1 { public: virtual ~Base1(){ cout<<"Base1"<<endl; } }; class Base2 { public: virtual ~Base2(){ cout<<"Base2"<<endl;
C++学习(38)：多重继承 派生类析构函数
超级大洋葱的博客
08-19 528
示例代码： #include<iostream> using namespace std; /* //多重继承方式一 class A { public: A( ) { cout << "A构造函数！" << endl; } ~A() { cout << "A析构函数！" << endl; } }; class B: public A { public: B( ) { cout << "B构造
C++基础学习-26继承的构造函数、多重继承、虚继承
weixin_43548583的博客
06-02 727
继承的构造函数、多重继承、虚继承
C++之多重继承派生类的构造函数
wrc_nb的博客
05-30 1784
#include &lt;iostream&gt;using namespace std;class Teacher{ public: Teacher(string nam,int a,string t):name(nam),age(a),title(t){} void display() { cout&lt;&lt;"name:"&lt;&lt;name&lt;&lt;endl; ...
C++ 多继承
weixin_45743799的博客
03-14 1486
派生类都只有一个基类，称为单继承（Single Inheritance）。除此之外，C++也支持多继承（Multiple Inheritance），即一个派生类可以有两个或多个基类。 多继承的语法也很简单，将多个基类用逗号隔开即可。例如已声明了类A、类B和类C，那么可以这样来声明派生类D： class D: public A, private B, protected C{ //类D新增加...
C++学习(37)：多重继承 派生类构造函数
超级大洋葱的博客
08-19 1771
示例代码： #include<iostream> using namespace std; //多重继承方式一 class A { public: A(int a1) { cout << "A构造函数！" << endl; a = a1; } public: int a; }; class B : public A { public: //用初始化列表构造父类带参数的构造函数 B(int a1,int b1): A(a1) { cout &
c++语言类的基础（3）——类的多继承及其构造函数和析构函数
m0_46198325的博客
10-03 1577
C++ 语言类的继承 1、 继承（Inheritance）可以理解为一个类从另一个类获取成员变量和成员函数的过程。例如类 B 继承于类 A，那么 B 就拥有 A 的成员变量和成员函数。 2、继承机制是面向对象程序设计是代码复用的重要手段，它允许程序员在保持类原有特性基础下，进行扩展增加功能。这样产生新的类，称为派生类，继承体现了面向对象设计的层次结构，体现了由简单到复杂的认知过程。 3、在C++中...
《C++继承篇》之多继承、多重继承与虚继承
ZJ卑微小媛的博客
06-21 645
在学习过程中，知识点的总结都是由发现问题到解决问题的过程中对知识理解和认识的升华。闲话少叙，下面围绕具体的栗子详细介绍C++学习之继承篇（多继承、多重继承与虚继承） 目录：1-1多继承1-2多继承代码2-1多重继承2-2多重继承代码3-1虚继承3-2虚继承代码 1-1多继承 基础知识：多继承是指一个子类继承多个父类。多继承对父类的个数没有限制，继承方式可以是公共继承、保护继承和私有继承。 不写继承方式，则默认是private继承。 直接给出多继承的模板格式太过死板，也不利于读者理解，下面通过一个栗子来引出
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值