C++ day26 代码重用（二） 多重继承（MI, multiple inheritance，主要研究多重公有继承）

最新推荐文章于 2022-08-07 16:01:06 发布
最新推荐文章于 2022-08-07 16:01:06 发布
阅读量313 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36607894/article/details/105405782
版权

文章目录

多重继承

前面说的都是单继承，即只有一个基类。多重继承是有两个甚至更多的基类。

公有单继承和公有多重继承（基类都用public修饰）都表示is-a关系。

私有继承和保护继承描述的都是has-a关系。

多重继承带来的两个主要问题

反正和单继承相比，多重继承肯定是更难的，很容易出现问题。因此有很多C++程序员希望删除多重继承特性，但也有一部分人觉得MI对于一些比较特殊的工程来说是特别有用的，必不可少的，所以MI被保留了，但是一定要谨慎地使用。。。

从两个不同基类继承同名方法

从两个或者更多相关基类继承同一个类的多个实例

示例 多重公有继承

worker是一个抽象基类，即有纯虚函数的基类。用它派生出singer类和waiter类，再从singer和waiter类中派生出SingingWaiter类
在这里插入图片描述

代码

先不写SingingWaiter类

//Worker.h
#ifndef WORKER_H_
#define WORKER_H_
#include <string>
class Worker// an abstract base class，不可以创建抽象基类的对象
{
private:
	std::string fullname;//包含
	long id;
public:
	Worker():fullname("no one"), id(0L){}
	explicit Worker(const std::string & st):fullname(st), id(0L){}
	explicit Worker(long ID):fullname("no one"), id(ID){}
	Worker(const std::string & st, long ID):fullname(st), id(ID){}
	//纯虚析构函数，基类的析构函数必须是虚的，抽象基类至少有一个纯虚函数，在派生类中抽象基类的纯虚函数自动成为虚函数
	virtual ~Worker() = 0;
	virtual void Set();
	virtual void Show() const;
};

class Waiter:public Worker // 公有继承，继承了一个Worker组件
{
private:
	int panache;
public:
	//默认参数在构造函数中的好处：一个构造函数相当于两个
	explicit Waiter(int pa = 0):Worker(), panache(pa){}//Worker()是调用基类Worker的默认构造函数，不给参数
	explicit Waiter(const std::string & st, int pa = 0):Worker(st), panache(pa){}
	explicit Waiter(long ID, int pa = 0):Worker(ID), panache(pa){}
	//有默认参数就不需要Waiter(const std::string & st, long ID):Worker(st, ID), panache(0){}了
	Waiter(const std::string & st, long ID, int pa = 0):Worker(st, ID), panache(pa){}
	Waiter(const Worker & wk, int pa = 0):Worker(wk), panache(pa){}//虽然抽象基类不可有对象，但是可以在形参这么写，会进行类型转换
	~Waiter(){}//和不写一样，会自动调用Worker的析构函数
	void Set();
	void Show() const;
};

class Singer:public Worker//继承了一个Worker组件
{
protected://把一些整型常量定义为保护数据成员，即对于派生链条上的类而言相当于公有数据成员，对于外界相当于私有成员
	enum {other, alto, contralto, soprano, bass, baritone, tenor};
	enum {Vtypes = 7};
private:
	//静态私有成员是类的所有对象共享的，不属于任何一个对象
	static const char *pv[Vtypes];//char指针数组,每个char指针指向一个字符串，表示一个声音类型
	int voice;
public:
	Singer(int vo = 0):Worker(), voice(vo){}
	Singer(const std::string & st, long ID, int vo = other):Worker(st, ID), voice(vo){}//vo的默认值写0或other都可以，最好写other
	Singer(const Worker & wk, int vo = 0):Worker(wk), voice(vo){}
	void Set();
	void Show() const;
};
#endif

//Worker.cpp
#include <string>
#include <iostream>
#include "Worker.h"
using std::cin;
using std::cout;
using std::string;
using std::endl;

//Worker methods
//虚析构函数必须实现，即使是纯虚析构
Worker::~Worker(){}

void Worker::Set()//定义不写virtual关键字
{
	cout << "Enter worker's full name:\n";
	getline(cin, fullname);//iostream类的函数
	cout << "Enter worker's ID:\n";
	cin >> id;
	//清空输入缓冲
	while (cin.get() != '\n')
		;
}

void Worker::Show() const
{
	cout << "Worker Name: " << fullname << endl;
	cout << "Worker ID: " << id << endl;
}

//Waiter methods
void Waiter::Set()
{
    cout << "Worker Category: Waiter\n";
	Worker::Set();
	cout << "Enter waiter's panache rating:\n";
	cin >> panache;
	while (cin.get() != '\n')
		;
    cout << endl;
}

void Waiter::Show() const
{
	/*
	*错误代码：派生类不可以直接访问基类的私有成员，只可以用基类的公有方法去访问
	*cout << "Waiter Name: " << fullname << endl;
	*cout << "Waiter ID: " << id << endl;
	*/
	cout << "Worker Category: Waiter\n";
	Worker::Show();
	cout << "Panache rating: " << panache << endl;
	cout << endl;
}

//Singer methods
//先给静态char指针数组赋值，虽然不是函数，但也可以写在实现文件中
 const char * Singer::pv[] = {"other", "alto", "contralto", "soprano", "bass", "baritone", "tenor"};//一定要用类名限定！！！像方法一样

void Singer::Set()
{
    cout << "Worker Category: Singer\n";
	Worker::Set();
	cout << "Enter singer's voice type (integer 0 - 6):\n";
	//展示给用户看所有可供选择的类型
	int i;
	for (i = 0; i < Vtypes; ++i)
	{
		cout << i << ": " << pv[i] << "  ";
	}
	cout << endl;
	//保证输入正确
	while (cin >> voice && (voice >= Vtypes || voice < 0))
		cout << "Please enter a value >= 0 and < " << Vtypes << endl;
	//清空输入队列
	while (cin.get() != '\n')
		;
    cout << endl;
}

void Singer::Show() const
{
    cout << "Worker Category: Singer\n";
	Worker::Show();
	cout << "Singer's voice type: " << pv[voice] << endl;
	cout << endl;
}

#include <iostream>
#include "Worker.h"
const int LIM = 4;
using std::cout;

//使用一个多态指针数组调用同名方法
int main()
{
    Waiter bob("Bob Apple", 123L, 4);
	Singer mary("Mary Smith", 156L, 2);
	Waiter anna;
	Singer amy;

	Worker *pw[LIM] = {&bob, &mary, &anna, &amy};//抽象基类的指针数组,bob和mary只是把他们的Worker组件（基类对象）的地址赋给了指针
	int i;
	for (i = 2; i < LIM; ++i)
		pw[i]->Set();
	for (i = 0; i < LIM; ++i)
		pw[i]->Show();
		
    return 0;
}

输出

Worker Category: Waiter
Enter worker's full name:
Anna Drop
Enter worker's ID:
456
Enter waiter's panache rating:
4

Worker Category: Singer
Enter worker's full name:
Sia Taylor
Enter worker's ID:
1268
Enter singer's voice type (integer 0 - 6):
0: other  1: alto  2: contralto  3: soprano  4: bass  5: baritone  6: tenor
3

Worker Category: Waiter
Worker Name: Bob Apple
Worker ID: 123
Panache rating: 4

Worker Category: Singer
Worker Name: Mary Smith
Worker ID: 156
Singer's voice type: contralto

Worker Category: Waiter
Worker Name: Anna Drop
Worker ID: 456
Panache rating: 4

Worker Category: Singer
Worker Name: Sia Taylor
Worker ID: 1268
Singer's voice type: soprano
出现的问题
  • 在派生类中企图使用基类的私有变量。。。必须要用基类公有方法才可以访问到，除非是保护成员变量
  • Singer(const std::string & st, long ID, int vo = other):Worker(st, ID), voice(vo){}中的, voice(vo)忘记写，导致了Singer mary(“Mary Smith”, 156L, 2);没有成功构造出想要的对象，但是这种情况不会在编译时发现，只会在运行时出错，刚开始还不知道为啥，调试发现voice的值打印不出来才想到这边出问题了。
  • 忘记写const char * Singer::pv[] = {“other”, “alto”, “contralto”, “soprano”, “bass”, “baritone”, “tenor”};中的类名限定符，在方法定义文件中定义静态变量，必须和方法一样，用类名限定起来，不然编译器不知道pv到底是哪个类的，尽管头文件包含此信息，但是编译器就是要你写清楚。
做的好的地方
  • const char * Singer::pv[] = {“other”, “alto”, “contralto”, “soprano”, “bass”, “baritone”, “tenor”};中书上代码没有const,于是报7个警告（一个词语一个），说C++禁止把string constant转换为char *类型，我就明白了，这属于const赋给非const的情况，当然会报错，于是这么改了就好了（头文件中也要加const：static const char *pv[Vtypes];）。
    在这里插入图片描述
学到或加深印象的地方
  • 基类指针数组实现多态，其中基类甚至可以是抽象基类。
  • 用enum枚举定义整型常量
  • 指针数组
  • 静态数据成员可以在方法文件中赋值
  • 基类的析构函数必须是虚函数，且虚析构函数必须要实现，即使是纯虚析构函数！
  • 检查输入是否正确（voice的输入必须是0-6）

由SingingWaiter类的问题引出虚基类

SingingWaiter类的问题：将继承两个Worker对象，使多态调用方法时因二义性而不可行

这里并不是真的说有Worker对象，因为毕竟抽象基类是不可以创建对象的，这么说仅仅是为了便于表达，不过还是说组件吧更严谨。

class SingingWorker:public Singer, public Waiter//必须每个基类都用public修饰，因为默认的是private
{...};

由于 Waiter类和Singer类都继承了一个Worker组件，所以SingingWaiter有两个Worker组件，但是其实只需要一个Worker组件就好了，因为Singer类和Waiter类的Worker组件都一样又没区别。另外，这会在多态调用时造成二义性，使得程序出错：

SingingWaiter ed;
Worker *pw = &ed;//ed包含两个Worker组件，即有两个地址，于是编译器不知道要让pw指向谁

在这里插入图片描述

解决这种二义性要依靠类型转换：

Worker * pw1 = (Waiter *) &ed;//指向Waiter中的Worker组件
Worker * pw2 = (Singer *) &ed;

所以这种多重继承使得利用基类指针引用不同类的对象的多态性变复杂了。要多加一个类型转换才行。

但是光做个类型转换确实解决了这里的二义性问题，但只是解决了皮毛，并不釜底抽薪之举，因为如前所述，根本不需要两个Worker组件啊，再多的Worker组件都是一毛一样的，我们只需要一个！SingingWaiter类的对象应该只拥有一个Worker组件，即只有一个名字和一个ID。

这该怎么办呢？

于是C++迫不得已，专门为多重继承引入一个新技术——虚基类（virtual base class）。

虚基类

虚基类专门针对上面说的这种情况：让两个继承同一个基类（第一代类）的类（第二代类）共同派生的类（第三代类）的对象只有一个基类（第一代类）对象。

class Singer:virtual public Worker{...}; 
class Waiter:public virtual Worker{...};
class SingingWaiter: public Singer, public Waiter{...};//则SingingWaiter对象只包含一个Worker组件的一个副本，即Singer类和Waiter类实际上共享了同一个Worker组件，而不是各自都引入一个Worker对象副本

public 和 virtual的顺序无所谓

在这里插入图片描述

需要注意的几点：

  • 虚基类中的"虚"和虚函数的“虚”不是一回事，没有关系。由于C++用户墙裂反对再引入新的关键字（已经够多了），所以就用了virtual。这实际上是一种关键字重载。
  • 有时候可能真的需要基类对象的多个副本，于是就不需要使用虚基类。这种情况虽然少，也是有的。

虚基类的构造函数在派生链条中不可以自动传递信息

以前的非虚基类：

class A
{
private:
	int a;
public:
	A(int m = 0):a(m){}
};

class B: public A
{
private:
	int b;
public:
	B(int m = 0, int n = 0):A(m), b(n){}
};

class C:public B
{
private:
	int c;
public:
	C(int m = 0, n = 0, q = 0):B(m, n), c(q){}
};

可以看到，非虚基类中, B继承了A, C继承了B，在这个继承链条中，C只可以调用B的构造函数，不可以调用A的构造函数，因为B会自动调用A的构造函数。其中C把信息传给了B，B又把信息传给了A，相当于B是中间类，C通过中间了自动地把信息传给了基类A。

但是在虚基类中，这种在派生链条中通过中间类自动传递信息将不再行得通：

SingingWaiter(const Worker & wk, int pa = 0, int vo = Singer::other):Waiter(wk, pa), Singer(wk, vo){};

这句代码中，如果可以通过中间类自动传递信息，则Waiter和Singer的构造函数都会自动调用Worker类的构造函数，所以有2条不同路径都会把wk传给Worker基类，会造成冲突。

所以C++就规定：当基类是虚的时，禁止信息通过中间类自动传递给基类。所以上面的代码只会初始化panache和voice两个参数，那基类对象的那个组件怎么办呢？答案是：编译器调用Worker的默认构造函数去创建。
那如果不想用默认构造函数呢？则：

SingingWaiter(const Worker & wk, int pa = 0, int vo = Singer::other):Worker(wk), Waiter(wk, pa), Singer(wk, vo){};

注意这里相当于在第三代类的构造函数中使用了第一代类的构造函数，这在非虚基类是绝对不可以的！（非虚基类只允许在构造函数中调用派生链条中相邻的基类的构造函数）。

用虚基类写SingingWaiter类

前面三个类的代码也做了一些改动

//Worker.h
#ifndef WORKER_H_
#define WORKER_H_
#include <string>
class Worker// an abstract base class，不可以创建抽象基类的对象
{
private:
	std::string fullname;//包含
	long id;
protected:
	virtual void Data() const;
	virtual void Get();
public:
	Worker():fullname("no one"), id(0L){}
	explicit Worker(const std::string & st):fullname(st), id(0L){}
	explicit Worker(long ID):fullname("no one"), id(ID){}
	Worker(const std::string & st, long ID):fullname(st), id(ID){}
	//纯虚析构函数，基类的析构函数必须是虚的，抽象基类至少有一个纯虚函数，在派生类中抽象基类的纯虚函数自动成为虚函数
	virtual ~Worker() = 0;
	virtual void Set() = 0;
	virtual void Show() const = 0;
};

class Waiter:virtual public Worker // 公有继承
{
private:
	int panache;
protected:
	void Data() const;
	void Get();
public:
	//默认参数在构造函数中的好处：一个构造函数相当于两个
	explicit Waiter(int pa = 0):Worker(), panache(pa){}//Worker()是调用基类Worker的默认构造函数，不给参数
	explicit Waiter(const std::string & st, int pa = 0):Worker(st), panache(pa){}
	explicit Waiter(long ID, int pa = 0):Worker(ID), panache(pa){}
	//有默认参数就不需要Waiter(const std::string & st, long ID):Worker(st, ID), panache(0){}了
	Waiter(const std::string & st, long ID, int pa = 0):Worker(st, ID), panache(pa){}
	Waiter(const Worker & wk, int pa = 0):Worker(wk), panache(pa){}//虽然抽象基类不可有对象，但是可以在形参这么写，会进行类型转换
	~Waiter(){}//和不写一样，会自动调用Worker的析构函数
	void Set();
	void Show() const;
};

class Singer: virtual public Worker
{
protected://把一些整型常量定义为保护数据成员，即对于派生链条上的类而言相当于公有数据成员，对于外界相当于私有成员
	enum {other, alto, contralto, soprano, bass, baritone, tenor};
	enum {Vtypes = 7};
	void Data() const;
	void Get();
private:
	//静态私有成员是类的所有对象共享的，不属于任何一个对象
	static const char *pv[Vtypes];//char指针数组,每个char指针指向一个字符串，表示一个声音类型
	int voice;
public:
	Singer(int vo = 0):Worker(), voice(vo){}
	Singer(const std::string & st, long ID, int vo = other):Worker(st, ID), voice(vo){}//vo的默认值写0或other都可以，最好写other
	Singer(const Worker & wk, int vo = 0):Worker(wk), voice(vo){}
	void Set();
	void Show() const;
};

class SingingWaiter: public Singer, public Waiter
{
protected:
	void Data() const;
	void Get();
public:
    SingingWaiter(){}
	SingingWaiter(const std::string & st, long ID, int vo = Singer::other, int pa = 0)
        : Worker(st, ID), Singer(st, ID, vo), Waiter(st, ID, pa){}
	SingingWaiter(const Worker & wk, int vo = Singer::other, int pa = 0)
        : Worker(wk), Singer(wk, vo), Waiter(wk, pa){}
	SingingWaiter(const Waiter & wa, int vo = other):Singer(vo), Waiter(wa){}//必须先写Singer,否则警告（这个顺序必须按照声明类时的public Waiter, public Singer来）
	SingingWaiter(const Singer & si, int pa = 0):Singer(si), Waiter(pa){}
	void Show() const;
	void Set();
};
#endif

//Worker.cpp
#include <string>
#include <iostream>
#include "Worker.h"
using std::cin;
using std::cout;
using std::string;
using std::endl;

//Worker methods
//虚析构函数必须实现，即使是纯虚析构
Worker::~Worker(){}
void Worker::Data() const
{
	cout << "Worker Name: " << fullname << endl;
	cout << "Worker ID: " << id << endl;
}

void Worker::Get()
{
	cout << "Enter worker's full name:\n";
	getline(cin, fullname);//iostream类的函数
	cout << "Enter worker's ID:\n";
	cin >> id;
	//清空输入缓冲
	while (cin.get() != '\n')
		;
}

//Waiter methods
void Waiter::Data() const
{
	cout << "panache rating: " << panache << endl;
}

void Waiter::Get()
{
    cout << "Enter waiter's panache rating:\n";
	cin >> panache;
	while (cin.get() != '\n')
		;
}

void Waiter::Set()
{
    cout << "Worker Category: Waiter\n";
	Worker::Get();
	Get();
    cout << endl;
}

void Waiter::Show() const
{
	cout << "Worker Category: Waiter\n";
	Worker::Data();
	Data();
	cout << endl;
}

//Singer methods
//先给静态char指针数组赋值，虽然不是函数，但也可以写在实现文件中
const char * Singer::pv[] = {"other", "alto", "contralto", "soprano", "bass", "baritone", "tenor"};//一定要用类名限定！！！像方法一样

void Singer::Data() const
{
	cout << "Singer's voice type: " << pv[voice] << endl;
}

void Singer::Get()
{
	cout << "Enter singer's voice type (integer 0 - 6):\n";
	//展示给用户看所有可供选择的类型
	int i;
	for (i = 0; i < Vtypes; ++i)
	{
		cout << i << ": " << pv[i] << "  ";
	}
	cout << endl;
	//保证输入正确
	while (cin >> voice && (voice >= Vtypes || voice < 0))
		cout << "Please enter a value >= 0 and < " << Vtypes << endl;
	//清空输入队列
	while (cin.get() != '\n')
		;
}

void Singer::Set()
{
    cout << "Worker Category: Singer\n";
	Worker::Get();
	Get();
    cout << endl;
}

void Singer::Show() const
{
    cout << "Worker Category: Singer\n";
	Worker::Data();
	Data();
	cout << endl;
}

//SingingWaiter methods
void SingingWaiter::Data() const
{
	Singer::Data();
	Waiter::Data();
}

void SingingWaiter::Get()
{
	Singer::Get();
	Waiter::Get();
}

void SingingWaiter::Set()
{
	cout << "Worker Category: Singing Waiter\n";
	Worker::Get();
	Get();
}

void SingingWaiter::Show() const
{
	cout << "Worker Category: Singing Waiter\n";
	Worker::Data();
	Data();
}

#include <iostream>
#include <cstring>
#include "Worker.h"
const int SIZE = 5;
using std::cout;
using std::cin;

//使用一个多态指针数组调用同名方法
int main()
{
    SingingWaiter amy("Amy Smith", 152L, 2, 3);
	amy.Waiter::Show();//不用类名限定会导致二义性，因为SingingWaiter的两个基类Singer类和Waiter类都有Show()方法，自己又没定义Show()方法
	amy.Singer::Show();

	Worker *pw[SIZE];
	int ct;
	for (ct = 0;ct < SIZE; ++ct)
	{
		char choice;
		cout << "Enter the employee category:\n";
		cout << "w: waiter  s: singer\n"
			 << "t: singing waiter q: quit\n";

		while (cin >> choice && (std::strchr("wstq", choice) == NULL))
		{
			cout << "Please enter w, s, t, or q: ";
		}
		if (choice == 'q')
			break;
		switch(choice)
		{
			case 'w':
				pw[ct] = new Waiter; break;
			case 's':
				pw[ct] = new Singer; break;
			case 't':
				pw[ct] = new SingingWaiter; break;
		}
		cin.get();//这句必不可少！！！cin >> choice把输入队列的字母给了choice，但是仍然还在输入队列中，要用cin.get()才可以读掉，否则后面没法输入名字
		pw[ct]->Set();

	}

	cout << "Here is your staff:\n";
	int i;
	for (i = 0; i < ct; ++i)
		{
			pw[i]->Show();
			cout << '\n';
		}
	for (i = 0; i < ct; ++i)
		delete pw[i];

    return 0;
}

输出

Worker Category: Waiter
Worker Name: Amy Smith
Worker ID: 152
Singer's voice type: contralto
panache rating: 3

Worker Category: Singer
Worker Name: Amy Smith
Worker ID: 152
Singer's voice type: contralto
panache rating: 3

Enter the employee category:
w: waiter  s: singer
t: singing waiter q: quit
w
Worker Category: Waiter
Enter worker's full name:
Anna Smith
Enter worker's ID:
343
Enter waiter's panache rating:
2

Enter the employee category:
w: waiter  s: singer
t: singing waiter q: quit
s
Worker Category: Singer
Enter worker's full name:
Joy Sue
Enter worker's ID:
4245
Enter singer's voice type (integer 0 - 6):
0: other  1: alto  2: contralto  3: soprano  4: bass  5: baritone  6: tenor
5

Enter the employee category:
w: waiter  s: singer
t: singing waiter q: quit
t
Worker Category: Singing Waiter
Enter worker's full name:
Mary Hellon
Enter worker's ID:
125
Enter singer's voice type (integer 0 - 6):
0: other  1: alto  2: contralto  3: soprano  4: bass  5: baritone  6: tenor
4
Enter waiter's panache rating:
6
Enter the employee category:
w: waiter  s: singer
t: singing waiter q: quit
q
Here is your staff:
Worker Category: Waiter
Worker Name: Anna Smith
Worker ID: 343
panache rating: 2


Worker Category: Singer
Worker Name: Joy Sue
Worker ID: 4245
Singer's voice type: baritone


Worker Category: Singing Waiter
Worker Name: Mary Hellon
Worker ID: 125
Singer's voice type: bass
panache rating: 6

MI的其他复杂问题

混合使用虚基类和非虚基类会导致派生类对象中有几个基类组件

比如类A被作为虚基类派生出类B和C，又被作为非虚基类派生出类D和E，然后类B,C,D,E共同派生了类F。那么F类的对象中有几个A类的组件（对象）呢？

答案是3个。因为B和C由于把A当做虚基类继承，所以F中从BC这里只会得到一个A的对象组件，BC共享这一个组件；而DE是非虚基类继承，则每人都有一个A类对象组件，于是在F类中一共就有三个A类的对象组件。

反正看有几条路径。每个非虚基类都提供一条路径，所有虚基类一起提供一条路径。

一般情况下，这种基类的多个对象组件副本都是棘手的问题，而不是所希望的；只有极少数的特殊编程问题中才需要多个基类对象副本，以后遇到再说。

虚基类略改变了C++解析二义性的方式

怎么改变的呢？之前是只有类名限定，现在是先用优先顺序，优先顺序无法消除二义性才上类名限定。

如果是只用非虚基类，那么如果类从不同的类中继承了两个或更多的同名方法或同名数据，那么只需要使用类名限定就可以消除调用这个方法的二义性了。

如果在非虚基类中，其实问题可以更简单一丁点：即有时候不需要类名限定也没有二义性的问题，这是因为虚基类会使得同名方法之间有个优先顺序！只要优先顺序可以消除二义性就不需要类名限定了；有时候（优先顺序一样，消除不了二义性）则还是和非虚基类一样，需要类名限定以消除二义性。

注意只有虚基类才有同名方法之间的优先顺序哦，非虚基类没有这个说法。并且虽然用优先顺序可以消除二义性的时候不需要类名限定，但是这需要自己很清楚优先顺序的判断，别搞错了。

什么优先顺序？一个成员名如何优先于另一个成员名？
答案：派生类的名称优先于直接或间接祖先类（隔代亲，隔一代或多代）中的相同名称。

举个栗子：

class B
{
public:
	short q();
};

class C: virtual public B//把B当做虚基类继承，只要这里使用virtual,则基类B成为虚基类
{
public:
	long q();
	int omg();
};

class D: public C
{};

class E: virtual public B
{
private:
	int omg();
};

class F: public D, public E
{};

草画了一个继承图
在这里插入图片描述
F类的q()方法: F类从D，E两条路径都集继承到了名为q的方法，我们要分析优先性。先看D路径，D类没有新方法，其q()方法来自于公有继承C类的公有q()方法；再看E路径，E的q()来自于虚公有继承B类的公有q()方法。看继承图发现，C类的q()优先于B类的q()，所以F类中调用q()方法没有二义性，相当于C::q()。但是如果你真的想用B类的，则用B::q()即可。

F类的omg()方法：F类从D，E两条路径都集继承到了名为omg的方法，我们要分析优先性。先看D路径，D类没有新方法，其omg()方法来自于公有继承C类的公有omg()方法；再看E路径，E的omg()是自己的私有方法。看继承图发现，C类和E类不是派生和被派生的关系，所以他们的同名方法没有优先顺序一说，所以F类中调用omg()方法有二义性，虽然不可以在F类中使用E的私有方法，但使用omg()还是要必须明确指出C::omg()。

总之，使用虚基类会增加一点复杂性，多判断一个优先顺序，主要是多重继承中的最终派生类会通过多条途径继承同一个基类引起的。总之，使用MI要慎之又慎，一定要注意类名限定和虚基类的优先规则。

doubleslow;
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Multiple Inheritance in C++ - C++ 中的多重继承
既然选择了远方 便只顾风雨兼程 - 永强
02-20 753
Multiple Inheritance in C++ - C++ 中的多重继承 1. Multiple Inheritance in C++ Inheritance can be done in a number of ways. 继承可以通过多种方式完成。 The different types of inheritances which we have come across are: 我们遇到的不同类型的继承是： 1.1 Single Inheritance In single inheritan
多重继承(MI)
qq_36314864的博客
12-14 1330
worker0.h #ifndef WORKER0_H_ #define WORKER0_H_ #include <string> class Worker { private: std::string fullname; long id; public: Worker() : fullname("no one"), id(0L) {} Worker(const std::string & s, long n) : fullname(s), id(n) {} virtu
C++ - 多重继承(multiple inheritance) 的 名称歧义(name ambiguity)
Mystra
01-10 3657
多重继承(multiple inheritance) 的 名称歧义(name ambiguity) 本文地址: http://blog.csdn.net/caroline_wendy/article/details/18077235 在多重继承中, 如果多个基类包含相同名字的成员函数, 则在派生类使用时, 容易发生歧义, 会导致出错; 解决方法是: 在派生类中重写基类方法, 覆盖原方法, 再指定基类范围(scope), 确定使用那个基类的
MI/多重继承 & 虚继承
qq_25235869的博客
04-06 366
/* 总结: 多重继承(MI) 必须使用虚继承,不然会出现多个基类; 虚继承中基类的构造函数 必须显示的调用; 考虑某些函数子类的函数与父类的函数冲重复的情况 比如前面的 show 函数,所以必须将重复去掉 分离某些数据(较好的方法用protected继承) */
C++中的代码重用(三)MI（多重继承）
夏洛克福尔摩斯
12-14 716
/*虚基类的声明使得多重继承成为可能*/ /*主要需要解决两件问题*/ /*一、构造函数的建立   二、利用哪个基类的方法*/ //statement.h #ifndef STATEMENT_H_ #define STATEMENT_H_ /*虚基类的声明使得多重继承成为可能*/ /*主要需要解决两件问题*/ /*一、构造函数的建立 二、利用哪个基类的方法*/ #include&lt;io...
C++多重继承二义性原理实例解析
08-19
解决多重继承二义性的一种常见方法是使用虚继承（virtual inheritance）。虚继承使得所有派生自虚基类的对象共享同一份基类的实例，这样就可以消除二义性。下面是一个使用虚继承的例子： ```cpp class A { public: ...
C++多重继承与虚继承分析
01-01
同样的，在多重继承（multiple inheritance）关系中，派生类的对象包含了每个基类的子对象和自定义成员的子对象。下面是一个多重继承关系图： class A{ /* */ }; class B{ /* */ }; class C : public A { /* */ };...
类的继承练习_inheritance_类的继承练习_C++_pineoce_
10-02
在C++编程语言中，类的继承是面向对象编程（OOP）的一个核心概念，它允许我们创建一个新类（子类或派生类），该类不仅拥有已存在的类（父类或基类）的特性，还能添加新的特性和功能。这种机制有助于代码重用，降低...
C/C++ 公有继承、保护继承和私有继承的对比详解
08-31
C++ 提供了三种继承方式：公有继承（public inheritance）、保护继承（protected inheritance）和私有继承（private inheritance），每种方式都有不同的访问权限和行为。 1. **公有继承（Public Inheritance）** -...
Python多重继承之菱形继承的实例详解
01-20
在python中一个类能继承自不止一个父类，这叫做python的多重继承（Multiple Inheritance ）。 语法 class SubclassName(BaseClass1, BaseClass2, BaseClass3, …): pass 菱形继承 在多层继承和多继承同时使用的...
类继承与代码重用
weixin_45492457的博客
01-28 460
类继承与代码重用简单继承 简单继承 使用公有派生，基类的公有成员将成为派生类的公有成员；基类的私有部分也将成为派生类的一部分，但只能通过基类的公有和保护方法访问。 派生类的构造：创建基类对象；派生类的构造函数应该通过成员初始化列表将基类信息传递给基类构造函数；派生类构造函数应该初始化派生类新增的数据成员。 （如果不调用基类构造，程序将使用默认的基类构造）因此除非要使用默认的构造函数，否则应该显式调用正确的基类构造函数。 RatedPlayer::RatedPlayer(unsigned int r, c
C++笔记——公有继承、私有继承、保护继承、多重继承
oucc257的博客
10-20 293
公有继承： 基类的public和protected成员的访问属性在派生类中保持不变，但基类的private成员不可直接访问。 派生类的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。 通过派生类的对象只能访问基类的public成员。 私有继承： void setCatLocation(string location)
C++第十四章_引入_包含(公有继承)和私有继承_is-a关系和has-a关系_私有继承_使用using重新定义获得访问权限_多重继承的问题与改进_虚基类_类模板类模板类模板_栈指针...
08-16 242
目录 1、引入 2、包含(公有继承)和私有继承 3、is-a关系和has-a关系(复习回顾) 4、私有继承 5、使用using重新定义获得访问权限 6、多重继承MI 6.1多重继承的引入 6.2多重继承的问题与改进 6.3虚基类 6.4虚基类与二义性 7、类模板 7.1类模板简单实现 7.2栈指针 1、引入(使用公有继承) /*关闭隐式转换的...
C++类继承——公有继承
asd1147170607的博客
04-22 7286
1 C++中的继承 C++中的类的继承机制提供了较高层次的重用性。许多厂商提供了类库，类库由类声明和实现构成。类继承可以从已有的类中派生出新的类，派生类继承了基类的数据和方法。 我们可以在派生类中添加新的类数据或类方法，此时称为公有继承。如果在派生类中修改了基类类方法的行为，那么称为多态公有继承。 一般情况下，我们修改基类源码就可以实现派生类。C++的继承机制甚至不需要访问基类的源码就可以派生出...
C++ 多重继承
我是小白呀的博客
05-13 7370
C++ 多重继承. 多重继承是什么, 多重继承的优缺点以及注意事项.
C++学习笔记－－多继承
wangrl的博客
10-15 472
这个例子中，Worker是基类，Singer和Waiter继承Worker类，SingingWaiter同时继承Singer类和Waiter类。 If you want to use something other than the default constructor for a virtual base class, you need to invoke the appropriate
从C到C++___类继承(五)多重继承
最新发布
m0_71009069的博客
08-07 361
C++多重继承
[阅读型]深入理解C++多继承(multiple inheritance)与虚继承(virtual inheritance)的底层原理与实现-以g++为例
easy_level1的博客
04-14 1175
目录前言1. virtual 函数需要解决的问题2. 单继承3. 多继承4. 虚继承 前言 做安全的肯定是要深究一下，特别是了解其c++对象的memory layout和一些编译器生成的固定代码。另一方面c++开发者，既然是选择折腾c++，实际上也有了解的必要。本文不是讨论怎么用继承去实现一个良好的设计，而是讨论c++编译器是怎么支持这个特性的。这里不要把编译器想象的多么神通广大，实际上它是通过生成一些固定的代码与数据来实现的。主要参考文献c++的abi1。 极具争议的多继承与虚继承为啥这么恶心？ 因能力有
【第十四章】C++ Primer plus 的编程练习题
xiyuan255的博客
02-08 712
// winec.h -- class Wine definition #ifndef __WINEC_H__ #define __WINEC_H__ #include &lt;string&gt; #include &lt;valarray&gt; #include &lt;utility&gt; class Wine { private: typedef std::valarray&lt;...
C++程序设计课件：第17章 多重继承.ppt
05-29
在C++程序设计的第17章——多重继承中，我们深入探讨了这一关键概念及其在实际编程中的应用。多重继承允许一个派生类从多个基类中继承特性，就像现实生活中的两用沙发既是床也是沙发一样。本章内容分为几个核心部分...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值