多重继承详解

一，概念：指的是在继承关系中，继承的父类不止一个。至多可以继承几个父类在c++中没有明确的定义。

class  Grand
{
public:
       int a;
};
class A: public Grand
{
public:
void fun(){}
       
};
class A2
{
public:
void fun(){}
};
class C :public A, public A2 //多重继承
{
public:
};

在这个例子中如果A2和A有相同的函数，那么定义类C对象时，调用该函数要加上作用域运算符，否则，系统不知道调用的是A还是A2中的函数。
即：多重继承的二义性问题。
C obj;
obj A::fun();
当然，如果类C中含有fun()函数，那么类A和A2的fun()函数将被遮蔽，因此，此时调用的将是类c中的fun()函数。

多重继承之间的关系：


二：静态成员在多重继承中的可见问题

class  Grand
{
public:
       static int a;
};
int Grand::a = 10;//类外定义
class A: public Grand
{
public:
       
};
class A2
{
public:
};
class C :public A, public A2
{
public:
};
int main()
{
       C c;
       
       //可以
       C::a = 10;
       A::a = 1;
       C::a = 9;
       c.a = 8;
       A2::a = 3;//不可以
}

三：派生类构造函数与析构函数
主要是调用顺序问题，这里可以自己写代码看看调用顺序。

四：继承的构造函数。

在继承体系中，子类可以继承父类的构造函数，但是，默认构造函数，拷贝构造函数，移动构造函数是不能被继承的。

class B1
{
public:
       B1(int i, int j) { cout << "dad" << endl; }
       B1(){ }
       B1(int i, int j, int k, int n, int m=10){ }
};
class B2 :public B1
{
public:
       using B1::B1;//继承B1中出现的构造函数
};
int main()
{
     B2 b(1,2);
     B2 b1;
     B2(1, 2, 3, 4, 5);
     B2(1, 2, 3, 4);
}

这里：using B1::B1;相当于
B2(int i,int j):B1(i,j){ }
B2(int i, int j,int k,int n) :B1(i,j,k,n) { }
B2(int i, int j, int k, int n,int m) :B1(i, j, k, n,m) { }
B2(){ }

即，在派生类中都会构造出一个与之相同形参列表的构造函数。

五：从多个父类继承构造函数

class D1
{
public:
       D1(int i, int j) { cout << "D1(int i, int j)" << endl; }
};
class D2
{
public:
       D2(int a) { cout << "D2(int a)" << endl; }
       D2() { }
};
class D3:public D1,public D2
{
public:
       using D1::D1;   //D3(int i,int j):D1(i,j) { }
       using D2::D2;   //D3(int a):D2(a) { }
};
int main()
{
       D3 obj(1,2);  
}

如果在多继承的派生类中，它从基类继承来的构造函数中，有相同形参列表的构造函数，那么，派生类必须重写这个版本的构造函数。

class D1
{
public:
       D1(int i) { cout << "D1(int i)" << endl; }
};
class D2
{
public:
       D2(int a) { cout << "D2(int a)" << endl; }
};
class D3:public D1,public D2
{
public:
       using D1::D1;   
       using D2::D2;  
       D3(int i):D1(i),D2(i) { } //重写构造函数
};
int main()
{
       D3 obj(1);    
}

因为， using D1::D1;   //D3(int i):D1(i) { }
      using D2::D2;   //D3(int a):D2(a) { }
这样的话，就相当于有相同形参个数的构造函数了