c++继承

class Base{
    public:
        static int getNum()
        { 
            return sNum; 
        }
        static int getNum(int param)
        {
            return sNum + param;
        }
    public:
        static int sNum;
};
int Base::sNum = 10;
class Derived : public Base
{
    public:
        static int sNum; //基类静态成员属性将被隐藏
#if 0
        //重定义一个函数，基类中重载的函数被隐藏
        static int getNum(int param1, int param2)
        {
            return sNum + param1 + param2;
        }
#else
        //改变基类函数的某个特征，返回值或者参数个数，将会隐藏基类重载的函数
        static void getNum(int param1, int param2)
        {
            cout << sNum + param1 + param2 << endl;
        }
#endif
};
int Derived::sNum = 20

多继承

多继承概念

一个类继承了多个类

#include 
 
using namespace std;
 
class A
{
    public:
        int a;
};
class B
{
    public:
        int a;
};
 
class C:public A,public B
{
	public:
		int a;
};
void test()
{
	C c;
	c.a = 10;
	c.A::a= 20;
	c.B::a = 30;
}
 
int main()
{
    test();
    return 0;
}

菱形继承和虚继承

#include 
 
using namespace std;
 
class BigBase{
    public:
        BigBase(){ mParam = 0; }
        void func(){ cout << "BigBase::func" << endl; }
    public:
        int mParam;
};
class Base1 : public BigBase{};
class Base2 : public BigBase{};
class Derived : public Base1, public Base2{};
int main(){
    Derived derived;
    //1. 对“func”的访问不明确
    //derived.func();
    //cout << derived.mParam << endl;
    cout << "derived.Base1::mParam:" << derived.Base1::mParam << endl;
    cout << "derived.Base2::mParam:" << derived.Base2::mParam << endl;
    //2. 重复继承
    cout << "Derived size:" << sizeof(Derived) << endl; //8
    return 0;
}

#include 
 
using namespace std;
 
class BigBase{
    public:
        BigBase(){ mParam = 0; }
        void func(){ cout << "BigBase::func" << endl; }
    public:
        int mParam;
};
 
class Base1 : virtual public BigBase{};
class Base2 : virtual public BigBase{};
class Derived : public Base1, public Base2{};
int main(){
    Derived derived;
    //二义性问题解决
    derived.func();
    cout << derived.mParam << endl;
    //输出结果:12
    cout << "Derived size:" << sizeof(Derived) << endl;
    return 0;
}

虚继承实现原理

以上程序 Base1 ， Base2 采用虚继承方式继承 BigBase, 那么 BigBase 被称为虚基类。

通过虚继承解决了菱形继承所带来的二义性问题。

但是虚基类是如何解决二义性的呢？并且 derived 大小为 12 字节，这是怎么回事?

通过内存图，我们发现普通继承和虚继承的对象内存图是不一样的。我们也可以猜测到编译器肯定对我们编写的程序做了一些手脚。

BigBase 菱形最顶层的类，内存布局图没有发生改变。Base1和 Base2 通过虚继承的方式派生自 BigBase, 这两个对象的布局图中可以看出编译器为我们的对象中增加了一 个vbptr (virtual base pointer),vbptr 指向了一张表，这张表保存了当前的虚指针相对于虚基类的首地址的偏移量。Derived 派生于 Base1 和 Base2, 继承了两个基类的 vbptr 指针，并调整了 vbptr 与虚基类的首地址的偏移量。

由此可知编译器帮我们做了一些幕后工作，使得这种菱形问题在继承时候能只继承一份数据，并且也解决了二义 性的问题。现在模型就变成了 Base1 和 Base2 Derived 三个类对象共享了一份 BigBase 数据。

当使用虚继承时，虚基类是被共享的，也就是在继承体系中无论被继承多少次，对象内存模型中均只会出现一个 虚基类的子对象（这和多继承是完全不同的）。即使共享虚基类，但是必须要有一个类来完成基类的初始化（因为所有的对象都必须被初始化，哪怕是默认的），同时还不能够重复进行初始化，那到底谁应该负责完成初始化 呢？C++ 标准中选择在每一次继承子类中都必须书写初始化语句（因为每一次继承子类可能都会用来定义对象），

但是虚基类的初始化是由最后的子类完成，其他的初始化语句都不会调用

class BigBase{
    public:
        BigBase(int x){mParam = x;}
        void func(){cout << "BigBase::func" << endl;}
    public:
        int mParam;
};
class Base1 : virtual public BigBase{
    public:
        Base1() :BigBase(10){} //不调用 BigBase 构造
};
class Base2 : virtual public BigBase{
    public:
        Base2() :BigBase(10){} //不调用 BigBase 构造
};
class Derived : public Base1, public Base2{
    public:
        Derived() :BigBase(10){} //调用 BigBase 构造
};
//每一次继承子类中都必须书写初始化语句
int main(){
    Derived derived;
    return 0;
}

注意：

虚继承只能解决具备公共祖先的多继承所带来的二义性问题，不能解决没有公共祖先的多继承的 .

工程开发中真正意义上的多继承是几乎不被使用，因为多重继承带来的代码复杂性远多于其带来的便利，多重继 承对代码维护性上的影响是灾难性的，在设计方法上，任何多继承都可以用单继承代替。