C++ 多继承
1. 定义格式
class : [] , [] ,...
{
};
2. 重复继承——虚基类
在多继承中，如果直接基类有公共的基类，则会出现重复继承。这样，公共基类中的数据成员在多继承的派生类中皆有多个拷贝。
如：
class A
{
int x;
};
class B: public A{};
class C: public A{};
class D: public B, public C{};
//此时D用有两个x成员B::x 和 C::x
为了解决这样的问题，要使用虚基类。
1）虚基类的构造函数有最新派生出的类的构造函数调用
2）虚基类的构造函数优先非虚基类的构造函数执行
class A
{
int x;
public:
A(int i) {x=i;}
};
class B: virtual public A
{
int y;
public:
B(int i): A(1) {y=i;}
};
class C: virtual public A
{
int z;
public:
C(int i): A(2) {z=i;}
};
class D: public B, public C
{
int m;
public:
D(int i, int j, int k): B(i),C(j),A(3){m=k;}
};
class E: public C
{
int n;
public:
E(int i, int j, int k, int l): D(i,j,k),A(4){n=1;}
}; D d(1,2,3); E e(1,2,3,4);
当创建D对象d时，所调用的构造函数的顺序是：
A(3), B(1), C(2), D(1,2,3);
当创建E对象e时，所调用的构造函数的顺序是：
A(4), B(1), C(2), D(1,2,3), E(1,2,3,4)
————————————————
C++多继承详解
在C++语言中，一个派生类可以从一个基类派生，也可以从多个基类派生。从一个基类派生的继承称为单继承；从多个基类派生的继承称为多继承。
1.继承的三种方式
公有继承(public),私有继承(private),保护继承(protected)
三种继承方式的说明，如下表所示：
2.什么是多继承
一个类有多个基类，那么这种继承关系就叫做多继承。 比如有两个类，服务员类Waiter，歌手类Singer，我们有一个类既是服务员，又是歌手， 那么我们可以定义类的多继承关系如下：
<code>class Waiter
{};
class Singer
{};
class SingerWaiter:public Waiter,public Singer
{};/<code>
3.使用多继承会带来哪些问题
多继承比单继承复杂，也更容易出现问题，因此我们不建议使用多继承。 多继承的两个主要问题是： 1)从两个不同的基类，继承同名方法 如下例所示：
<code>class Waiter
{
public:
void work(){std::cout<};
class Singer
{
public:
void work(){std::cout<};
class SingerWaiter:public Waiter,public Singer
{};
int main()
{
SingerWaiter singerWaiter;
singerWaiter.work();
return 0;
}/<code>
编译器不知道该调用哪个基类的work方法，所以会报singerWaiter.work();不明确错误。
2)从多个基类间接继承同一个类的多个实例 如下例所示：
<code>class Worker
{};
class Waiter:public Worker
{};
class Singer:public Worker
{};
class SingerWaiter:public Waiter,public Singer
{};
int main()
{
SingerWaiter singerWaiter;
Worker *pw = &singerWaiter;
return 0;
}/<code>
会报错Worker *pw = &singerWaiter;基类Worker不明确。 这是因为SingerWaiter对象创建时，会分别调用Waiter类和Singer类的构造函数， Waiter类和Singer类又会分别调用Worker类的构造函数，生成了两份Worker类的实例， 所以pw指针，不知道该指向哪一份Worker实例。
4.如何解决多继承带来的问题
对于问题一，我们在调用时，需要明确指出具体要调用哪个类的方法，如下所示：
<code>int main()
{
SingerWaiter singerWaiter;
singerWaiter.Waiter::work();//调用Waiter类的方法 singerWaiter.Singer::work();//调用Singer类的方法 return 0;
}/<code>
对于问题二，我们引入了虚基类的概念。如下所示：
<code>class Worker
{};
class Waiter:virtual public Worker
{};
class Singer:virtual public Worker
{};
class SingerWaiter:public Waiter,public Singer
{};
int main()
{
SingerWaiter singerWaiter;
Worker *pw = &singerWaiter;
return 0;
}/<code>
我们在子类继承时，声明一个virtual关键字，这时，就表明基类Worker是一个虚基类。 实例化SingerWaiter时产生的Waiter对象和Singer对象，共享一个基类Worker对象。
5.使用虚基类需要注意的问题
我们知道继承关系中，类的构造函数具有传递性，如以下代码所示：
<code>class A
{
private:
int a;
public:
A(int n=0):a(n){}
int get(){return a;}
};
class B:public A
{
private:
int b;
public:
B(int m=0,int n=0):A(n),b(m){}
int get(){return b;}
};
class C:public B
{
private:
int c;
public:
C(int q=0,int m=0,int n=0):B(m,n),c(q){}
int get(){return c;}
void Show()
{
std::cout<<:get> }
};
int main()
{
C c(1,2,3);
c.Show();
return 0;
}/<code>
输出结果为： 3 2 1 调用C的构造函数，则B,A构造函数都将使用传入的参数进行初始化。
我们再看使用虚基类的情况：
<code>class A
{
private:
int a;
public:
A(int n=0):a(n){}
int get(){return a;}
};
class B:virtual public A
{
private:
int b;
public:
B(int m=0,int n=0):A(n),b(m){}
int get(){return b;}
};
class C:public B
{
private:
int c;
public:
C(int q=0,int m=0,int n=0):B(m,n),c(q){}
int get(){return c;}
void Show()
{
std::cout< <:get> }
};
int main()
{
C c(1,2,3);
c.Show();
return 0;
}/<code>
输出结果为： 0 2 1 说明A并没有使用传入的参数进行初始化， 这是因为在虚基类中，我们假想会有多个子类向虚基类传递参数，为了避免这种情况， 在虚基类的情况下，禁止了子类C使用中间类B向虚基类A传递参数，此时调用的是A的默认构造函数。 那么我们该如何使用参数，初始化虚基类呢？ 答案是我们可以在子类C中，直接调用虚基类A的构造函数进行初始化，如以下代码所示：
<code>class A
{
private:
int a;
public:
A(int n=0):a(n){}
int get(){return a;}
};
class B:virtual public A
{
private:
int b;
public:
B(int m=0,int n=0):A(n),b(m){}
int get(){return b;}
};
class C:public B
{
private:
int c;
public:
C(int q=0,int m=0,int n=0):A(m),B(m,n),c(q){}
int get(){return c;}
void Show()
{
std::cout<<:get> }
};
int main()
{
C c(1,2,3);
c.Show();
return 0;
}/<code>
输出结果为： 3 2 1
跳过中间类，直接调用基类的构造函数，这种方式只适合虚基类。 在非虚基类中会报错“不允许使用间接非虚拟基类”。
参考资料：《C++ Primer.Plus》 pp.551-567
一个类可以同时继承多个类，称为多继承。下列关于多个继承和虚基类的表述中，错误的是
A．每个派生类的构造函数都要为虚基类构造函数提供实参 B．多继承时有可能出现对基类成员访问的二义性问题 C．使用虚基类可以解决二义性问题并实现运行时的多态性 D．建立最派生类对象时，虚基类的构造函数会首先被调用
正确答案 C 答案解析： [解析] 本题考核虚基类。C++中，通过虚拟基类所派生的类，在所产生的对象中，只包含了一个和其他类共享的基础对象，也就是说，从同一个基类中以虚拟方式派生的所有类，在它们所产生的对象里，不会有一份基础对象，而只是在内存里保留一份基础对象，而派生类中只保留指向此基础对象的指针，这样就不会同时有两份基类对象的情形发生。用虚基类可以解决二义性问题。但是实现运行时的多态性是虚函数。
通过分享实用的计算机编程语言干货，推动中国编程到2025年基本实现普及化，使编程变得全民皆知，最终实现中国编程之崛起，这里是中国编程2025，感谢大家的支持。
原文链接：https://blog.csdn.net/haitaolang/article/details/70847419
閱讀更多 中國編程2025 的文章
