C++ 继承与接口知识点小结（一）

ゝ一纸荒年。 2022-08-02 14:49 128阅读 0赞

【摘要】  
**要求[理解覆盖、重载、隐藏][Link 1]的概念与相互之间的区别；熟记类继承中对象、函数的访问控制；掌握虚函数、虚函数表、虚函数指针的联系；理解区分虚函数和虚继承在虚方法、虚指针在****空间分配上的重点与难点；熟练使用多重继承，要求能区分基类的同名函数和基类的空间布局。**

【正文】

**类继承中的覆盖**

#include<iostream>
 using namespace std;
 
 class A
 {
 protected:
 int m_data;
 public:
 A(int data = 0)
 {
 m_data = data;
 }
 int GetData()
 {
 return doGetData();
 }
 virtual int doGetData()
 {
 return m_data;
 }
 };
 
 class B : public A
 {
 protected:
 int m_data;
 public:
 B(int data = 1)
 {
 m_data = data;
 }
 int doGetData()
 {
 return m_data;
 }
 };
 
 class C : public B
 {
 protected:
 int m_data;
 public:
 C(int data = 2)
 {
 m_data = data;
 }
 };
 
 int main ()
 {
 C c(10);
 
 cout << c.GetData() <<endl; 
 //C中未定义，故调用B中的，但是B中也未定义，故调用A中的GetData()，因为A中的doGetData()是虚函数，所以调用B类中的doGetData()，而B类的doGetData()返回B::m_data， 故输出 1。
 cout << c.A::GetData() <<endl;
 //因为A中的doGetData()是虚函数，所以调用B类中的doGetData()，而B类的doGetData()返回B::m_data，故输出 1。
 cout << c.B::GetData() <<endl;
 //肯定是B类的返回值 1 了。
 cout << c.C::GetData() <<endl;
 //C类中未重定义GetData()，故调用从B继承来的GetData()，但是B类也未定义，所以调用A中的GetData(),因为A中的doGetData()是虚函数，所以调用B类的doGetData(),股输出为1
 
 cout << c.doGetData() <<endl;
 //B类的返回值 1 了。
 cout << c.A::doGetData() <<endl;
 //因为直接调用了A的doGetData() ，所以输出0。
 cout << c.B::doGetData() <<endl;
 //调用了B的doGetData()，所以输出 1。
 cout << c.C::doGetData() <<endl;
 //调用了B的doGetData()，所以输出 1。
 return 0;
 }

> 这里需要注意的是，第二个和第六个输出，此处单独列出并解析

cout << c.A::GetData() <<endl;
 cout << c.A::doGetData() <<endl;

> 这里两个虽然都是调用A类中的函数，但是，一个是成员函数调用虚函数一个是直接调用虚函数；
> 
> 第一个函数是成员函数调用虚函数，本类中无该虚函数的定义声明，故找到最近的基类系虚函数；
> 
> 第二个函数直接调用虚函数，直接去调用类中查找，故找到调用类结果即可。

*  这里要注意存在一个就近调用，如果父类存在相关接口则优先调用父类接口，如果父类也不存在相关接口则调用祖父辈接口。
 *  关于覆盖的概念：指针的数据类型是实函数的类型，指针指向的对象的数据类型，是虚函数的数据类型。
 *  详见：[C++ 覆盖 重载 隐藏 浅析][Link 1]
 *  详址：http://blog.csdn.net/u013630349/article/details/46706299

**类继承中的访问控制**

<table> 
 <tbody> 
 <tr> 
 <td> &nbsp; </td> 
 <td> 公有继承(public) </td> 
 <td> 保护继承(protected) </td> 
 <td> 私有继承(private) </td> 
 </tr> 
 <tr> 
 <td> 派生类对基类的访问控制 </td> 
 <td> 公有及保护成员可见 </td> 
 <td> 公有及保护成员可见 </td> 
 <td> 公有及保护成员可见 </td> 
 </tr> 
 <tr> 
 <td> 派生类对象对基类的访问控制 </td> 
 <td> 公有成员 </td> 
 <td> 所有成员不可见 </td> 
 <td> 所有成员不可见 </td> 
 </tr> 
 <tr> 
 <td> 派生类中基类成员的访问控制属性 </td> 
 <td> 基类公有与保护成员访问控制属性不变 </td> 
 <td> 基类公有与保护成员作为派生类的保护成员 </td> 
 <td> 基类公有与保护成员作为派生类的私有成员 </td> 
 </tr> 
 <tr> 
 <td> 备注 </td> 
 <td> &nbsp; </td> 
 <td colspan="2"> 基类成员作为派生类的(保护\私有)成员不被子类访问 </td> 
 </tr> 
 </tbody> 
</table>

**private: 本类函数和友元函数可以访问。  
protected: 本类函数、友元函数和子类函数可以访问。  
public: 本类函数、友元函数、子类函数和本类的对象可以访问。  
和公有继承、保护继承和私有继承没有关系，保护继承和私有继承影响的是子类的继承关系。**

**例：****类B从类A派生，****私有继承，只能说基类A的public和protected成员到了子类B后，都变为private，B再往下继承时，其子类C是不能访问A的public和protected成员的，但是对于B来说，A的protected和public是可以访问的。**

**虚函数继承和虚继承**

> **虚方法（虚函数）**
> 
> 每个含有虚方法（虚函数）对象里有虚表指针，指向虚表。虚表里存放了虚函数的地址，虚函数表是顺序存放虚函数地址的，不需要用到链表。所以，**类中的每一个对象都有一个指向顺序表的指针来存虚方法地址（顺序表和链表都是线性表），那就是虚表。**
> 
> 虚函数的实现要求对象携带额外的信息，这些信息用于在运行时确定后该对象应该调用哪一个虚函数，典型的情况下，这个信息具有一种被称为 vptr 虚函数指针的指针形式，vptr 指向一个被称为 vtbl 的虚函数表，函数指针数组，每一个虚函数都关联到 vtbl 。
> 
> 当一个对象调用了虚函数，实际的被调用函数通过下面步骤确定：
> 
> 1）找到对象的 vptr 指向的 vtbl ；
> 
> 2）在 vtbl 中寻找合适的函数指针。

> **虚函数的缺点**
> 
> 虚函数最主要的缺点是执行效率较低，看一看虚拟函数引发的多态性的实现过程，你就能体会到其中的原因，另外就是由于要携带额外的信息（VPTR），所以导致类多占的内存空间也会比较大，对象也是一样的。

> **虚函数、虚函数表、虚函数指针的联系**
> 
> 每一个具有虚函数的类都有一个虚函数表VTABLE，里面按在类中声明的虚函数的顺序存放着虚函数的地址，这个虚函数表VTABLE是这个类的所有对象所共有的，也就是说无论用户声明了多少个类对象，但是，这个VTABLE虚函数表（数据结构的唯一性）只有一个（可以理解成一个类只有一种表，每个对象都复制一个表，存在一个该对象初始化的内存空间之上）。
> 
> 详见：[C++ 关于类与对象在虚函数表上唯一性问题 浅析][C_ _]
> 
> 详址：http://blog.csdn.net/u013630349/article/details/47068767
> 
> 在每个具有虚函数的类的对象里面都有一个VPTR虚函数指针，这个指针指向VTABLE的首地址，每个类的对象都有这么一种指针。
> 
> 每个对象的虚函数表是一样的，指的是虚函数表的数据结构，但是，每个对象各有一个虚函数表，指的是每个对象的虚函数表的内存地址不同。  
>

> **虚函数的继承**
> 
> 1）空类、单一继承的空类、多重继承的空类所占空间大小为：1（字节，下同）；
> 
> 2）一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间的；
> 
> 3）类对象的大小 = 各非静态数据成员（包括父类的非静态数据成员但都不包括所有的成员函数）的总和+ vfptr指针(多继承下可能不止一个) + vbptr指针(多继承下可能不止一个) + 编译器额外增加的字节；
> 
> 4）当类中声明了虚函数（不管是1个还是多个），那么在实例化对象时，编译器会自动在对象里安插一个指针vPtr指向虚函数表VTable。

#include<iostream>
 #include<memory.h>
 #include<assert.h>
 
 using namespace std;
 class A
 {
 char k[3]; //所占的大小为3
 public:
 virtual void aa(){}; //虚指针大小为4
 };
 class B : public A
 {
 char j[3];
 public:
 virtual void bb(){};
 };
 class C : public virtual A
 {
 char i[3];
 public:
 virtual void cc(){};
 };
 int main(int argc, char *argv[])
 {
 cout << "sizeof(A): " << sizeof(A) << endl; //大小为4(char)+4(虚表)=8
 cout << "sizeof(B): " << sizeof(B) << endl; //大小为8(A副本)+4(char)+4(虚表)=16
 cout << "sizeof(C): " << sizeof(C) << endl; //大小为8(A副本)+4(char)+4(虚表)+4(虚继承+虚函数构成指针多一个)=20
 return 0;
 }

> **什么是虚继承？它和一般的继承有什么不同？有什么用**
> 
> 虚拟继承是多重继承中特有的概念。虚拟基类是为了解决多重继承而出现的，可以节省内存空间
> 
> 请看下图：

> ![20140828223544883][]

> 在图 1中，类D接触自类B和类C，而类B和类C都继承自类A，因此出现了图 2所示的情况。
> 
> 在图 2中，类D中会出现两次A。为了节省内存空间，可以将B、C对A的继承定义为虚拟继承，而A成了虚拟基类。最后形成了图 3。
> 
> **区分虚函数和虚继承**
> 
> 虚拟继承是多重继承中特有的概念,是为解决多重继承的。用虚继承可以节省内存空间
> 
> 虚函数是面向对象多态性的主要方式，通过继承基类中的虚函数在子类中重载实现不同操做。继承的虚函数在子类中不需要加virtual，默认就是虚函数。可以被它的子类覆盖。
> 
> **如果不是虚继承的类（普通继承），即便有虚函数也不会因此增加存储空间，如果是虚继承的类，没有虚函数就添加一个虚指针空间，有虚函数不论多少个，就添加两个虚指针空间！！！**
> 
> **详见：**[C++ 深入理解 虚继承、多重继承和直接继承][C_ _ 1]
> 
> **详址：http://blog.csdn.net/u013630349/article/details/47057929**

#### 多重继承 ####

> 多重继承优缺点
> 
> 优点：
> 
> 简单、清晰、更加有利于复用，对象可以调用多个基类中的接口
> 
> **缺点：**
> 
> 1）**二义性**，例如类A派生了B和C，而B和C共同派生了D,麻烦就出现了，这种中间大两头小的继承树有个形象的名字：叫做砖石型继承树（DOD）；
> 
> 2）**使得父类指针指向子类对象变得很麻烦**，得用C++的dynamic\_cast来执行强制转换，这个东西也很麻烦，因为它是运行期间而非编译期间进行转换的，它要求编译器允许RTTI；
> 
> 3）**多重继承还会使子类的vtable变得不同寻常**，因为子类的vtable中绝对不可能包含完整的有序的两个父类的vtable，因此每个父类对象都添加了一个指针。
> 
> 多重继承优缺点简版
> 
> 优点：多种功能，加快任务实现。
> 
> 缺点：多重性格，易得精神分裂。
> 
> **多重继承的声明：**
> 
> 声明一个类Jetplane，它是从Rocket和Airplane继承而来的
> 
> class JetPlane:public Rocket, public Airplane
> 
> **在多继承的时候，如果一个类继承同时继承自class A和class B,而class A和B中有一个函数叫foo()，如何明确地在子类中指出覆盖的是哪个父类的foo()**
> 
> #include<iostream>
> #include<memory.h>
> #include<assert.h>
> 
> using namespace std;
> class A
> {
> public:
> void foo(){};
> };
> class B
> {
> public:
> 	void foo(){};
> };
> class D：public A, public B
> {
> };
> int main()
> {
> D d;
> d.A::foo();
> return 0;
> }
> 
> 基类和派生类的地址和布局的问题
> 
> #include <iostream>
> using namespace std;
> 
> class A
> {
> int m_a;
> };
> 
> class B
> {
> int m_b;
> };
> 
> class C: public A , public B
> {
> int m_c;
> };
> 
> int main(int argc, char* argv[])
> {
> C *pc=new C;
> B *pb=dynamic_cast<B*>(pc);
> A *pa=dynamic_cast<A*>(pc);
> 
> if (pc==pb)
> {
> cout<<"equal"<<endl;
> }
> else
> {
> cout<<"unequal"<<endl;
> }
> 
> if ((int)pc==(int)pb)
> {
> cout<<"equal"<<endl;
> }
> else
> {
> cout<<"unequal"<<endl;
> }
> delete pc;
> return 0;
> }
> 
> **实验结果：第一个相同是因为父类指针指向子类对象的时候，采用多重继承之后用dynamic\_cast，导致相等输出equal，第二指针pc和pb值是不同的，所以，转换为int型也是不同的。输出unequal。？？？（尚未理解！）**

[Link 1]: http://blog.csdn.net/u013630349/article/details/46706299
[C_ _]: http://blog.csdn.net/u013630349/article/details/47068767
[20140828223544883]: /images/20220731/2b30489d285e4154bdddd2eb5272f433.png
[C_ _ 1]: http://blog.csdn.net/u013630349/article/details/47057929