c++多态下的继承

什么是多态？

给定一个函数接口，实现多种不同的功能。

c++的多态分为两种

静态多态：在函数的编译器就决定了调用哪种调用。（静态绑定）

动态多态：在函数运行期间决定调用哪种方法。

实现多态的两个条件：

1基类中必须要有虚函数，派生类中必须要重写虚函数。

2用基类的指针或者引用去调用虚函数。

#include<iostream>
using namespace std;

class A                   //基类
{
public:
void foo()
{
printf("1\n");
}
virtual void fun()    //虚函数
{
printf("2\n");
}
};
class B : public A        //派生类
{
public:
void foo()
{
printf("3\n");
}
void fun()            //重写虚函数
{
printf("4\n");
}
};
int main(void)
{
A a;
B b;
A *p = &a;
p->foo();
p->fun();
p = &b;             //用基类的 引用去指向派生类
p->foo();           //不构成多态   调用基类的成员函数
p->fun();           //满足 重写 和 基类引用调用两个条件   实现多态  调用自己重写的虚函数
return 0;
}

虚函数的重写条件：

1基类中必须声明成虚函数

2在子类中重写的时候函数的原型不能变（返回值类型 函数名 参数列表）

纯虚函数：

用成员前加virtual关键字并在后面加上 =0.

class Base
{
public:
virtual void fun() =0;
};

纯虚函数注意事项：

1含有纯虚函数的类是抽象类不能实力化出对象。

2纯虚函数在派生类中重写以后才能实例化出对象。

虚函数表：

class Base1
{
public:
virtual void fun();
};
class Base2
{
public:
void fun();
};

void funtest()
{
cout<<sizeof(Base1)<<endl;
cout<<sizeof(Base2)<<endl;
}
int main()
{
funtest();

system("pause");
return 0;
}

为什么Base1的大小为4而Base2的大小为1？

为什么是1之前的博客说过，为了解决空类的占位问题。那Base1中也没有定义变量成员 ，为什么是4呢？因为Base1存在虚函数，所以对应的存在虚函数列表，而Base1中存在一个指针，指向了这张表，而一个指针的大小就是4，所以这个类的大小就是4。

class B
{
public:
virtual void fun1();
virtual void fun12();

private:
int _b;

};

B的模型



监视窗口的内容



可以看出对象b中包含一个_vfptr（虚表指针），和一个_b(变量)，符合该对象大小为8。虚表指针又指向一个 指针数组 其中包含两个指针[0]和[1]，而这两个指针就是fun1和fun2.

多态继承

多态的单继承

#include<iostream>
using namespace std;
class B
{
public:
virtual void fun1()
{
cout<<"B::fun1"<<endl;
}
virtual void fun2()
{
cout<<"B::fun2"<<endl;
}

int _b;

};
class D:  public B
{
public:
virtual void fun1()
{
//重写fun1
cout<<"D::fun1"<<endl;
}
virtual void fun3()
{
//新增fun3
cout<<"D::fun3"<<endl;
}
int _d;

};
typedef void (*VF)();
void PrintVF(B& b)
{
VF* VFptr =  (VF*)(*(int*)(&b));
while (*VFptr)
{
(*VFptr)();
++VFptr;
}
}
int main()
{
B b;
D d;
cout<<sizeof(d)<<endl;
PrintVF(d);
system("pause");
return 0;
}

程序运行结果：

多继承：

多继承模型和可以看成单继承的多次累加，不同的是 多继承的情况下当前类的虚函数时添加在第一个继承类的虚表后面。

虚拟单继承：

#include<iostream>
using namespace std;
class B
{
public:
virtual void fun1()
{
cout<<"B::fun1"<<endl;
}
virtual void fun2()
{
cout<<"B::fun2"<<endl;
}

int _b;

};
class D: public  virtual B   //改为虚拟继承
{
public:
virtual void fun1()
{
//重写fun1
cout<<"D::fun1"<<endl;
}
virtual void fun3()
{
//新增fun3
cout<<"D::fun3"<<endl;
}
int _d;

};
typedef void (*VF)();
void PrintVF(B& b)
{
VF* VFptr =  (VF*)(*(int*)(&b));
while (*VFptr)
{
(*VFptr)();
++VFptr;
}
}
int main()
{
B b;
D d;
cout<<sizeof(d)<<endl;
PrintVF(d);
system("pause");
return 0;
}

看一下监视窗口



对象模型：



程序运行结果：

菱形继承：

#include<iostream>
using namespace std;
class B
{
public:
virtual void fun1()
{
cout<<"B::fun1"<<endl;
}
virtual void fun2()
{
cout<<"B::fun2"<<endl;
}

int _b;

};

class C1:public virtual B
{
public:
virtual void fun3()
{
cout<<"C1::fun3"<<endl;
}
int _c1;
};

class C2:public virtual B
{
public:
virtual void fun4()
{
cout<<"C1::fun4"<<endl;
}
int _c2;

};
class D: public C1,public C2
{
public:
virtual void fun5()
{
cout<<"D::fun1"<<endl;
}

int _d;

};

int main()
{
D d;
cout<<sizeof(d)<<endl;
system("pause");
return 0;
}

对象d的大小为C1（12）+C2（12）+4 = 28

菱形虚拟继承：

#include<iostream>
using namespace std;
class B
{
public:
virtual void fun1()
{
cout<<"B::fun1"<<endl;
}
virtual void fun2()
{
cout<<"B::fun2"<<endl;
}

int _b;

};

class C1:public virtual  B  //虚拟继承
{
public:
virtual void fun3()
{
cout<<"C1::fun3"<<endl;
}
int _c1;
};

class C2:public virtual B  //虚拟继承
{
public:
virtual void fun4()
{
cout<<"C1::fun4"<<endl;
}
int _c2;

};
class D: public C1,public C2
{
public:
virtual void fun5()
{
cout<<"D::fun1"<<endl;
}

int _d;

};

int main()
{
D d;
cout<<sizeof(d)<<endl;
system("pause");
return 0;
}

对象d的大小应为 C1（12）+C2（12）+_d(4)+B(8) = 36