c++继承汇总（单继承、多继承、虚继承、菱形继承）

一、C++中的对象模型

1、 概念

语言中直接支持面向对象程序设计的部分；

对于各种支持的底层实现机制。（没看懂……）

2、 类中的成员分类

a) 成员函数

　　i. static function

　　ii. non static function

　　iii. virtual function

b)  数据成员

　　i. static member data

　　ii. non static member data

3、 C++对象模型

a) 类对象内存布局中的包括

　　i. non static member data

　　ii. vptr（虚函数表指针）

　　iii. vbptr（虚基类表指针）

b) 不包括

　　i. static member data（存储在静态存储区）

　　ii. 成员函数（存储在代码区）

c) virtual table

简称vtbl。存放着指针，这些指针指向该类每一个虚函数。虚表中的函数地址将按声明时的顺序排列。vtbl在类声明后就形成了，vptr是编译器生成的。

d) vptr的位置一般放在一个类对象的最前端。

e) 虚基类表

vbptr指向的表，用于存放虚继承中，虚基类存储相对于虚基类表指针的偏移量。

二、继承类型

1、普通继承（不包含虚函数）

a、单继承

class Base
{
public:
    Base (int a = 1):base(a){}
    void fun0(){cout << base << endl;}
    int base;
};
class Derive:public Base
{
public:
    Derive (int a = 2):derive(a){}
    void fun1(){cout << base1 << endl;}
    int derive;
};

b、多继承

class Base1
{
public:
    Base1 (int a = 2):base1(a){}
    void fun1(){cout << base1 << endl;}
    int base1;
};
class Base2
{
public:
    Base2 (int a = 3):base2(a){}
    void fun2(){cout << base2 << endl;}
    int base2;
};
class Derive: public Base1, public Base2
{
public:
    Derive (int value = 4):derive (value){}
    void fun3(){cout << derive << endl;}
    int derive;
};

c、菱形继承

按 Ctrl+C 复制代码

按 Ctrl+C 复制代码

注：菱形继承存在二义性问题，编译都不通过，只能通过指定特定基类的方式进行访问基类变量。

Derive d;

d.base =3; // 不正确

d.Base1::base = 3; // 正确

2、普通继承（包含虚函数）

　　a、单继承（包含虚函数）

class Base
{
public:
    Base (int a = 1):base(a){}
    virtual void fun0(){cout << base << endl;}
    int base;
};
class Derive:public Base
{
public:
    Derive (int a = 2):derive(a){}
    virtual void fun0(){};
    virtual void fun1(){cout << derive << endl;}
    int derive;
};

注：派生类中新增的虚函数追加到虚函数表后面。

b、多继承（包含虚函数）

class Base1
{
public:
    Base1 (int a = 2):base1(a){}
    virtual void fun1(){cout << base1 << endl;}
    int base1;
};
class Base2
{
public:
    Base2 (int a = 3):base2(a){}
    virtual void fun2(){cout << base2 << endl;}
    int base2;
};
class Derive: public Base1, public Base2
{
public:
    Derive (int value = 4):derive (value){}
    virtual void fun3(){cout << derive << endl;}
    int derive;
};

注：派生类中新增的虚函数，追加到第一个基类的虚函数表的后面。

c、菱形继承（包含虚函数）

class Base
{
public:
    Base (int a = 1):base(a){}
    virtual void fun0(){cout << base << endl;}
    int base;
};
class Base1:public Base
{
public:
    Base1 (int a = 2):base1(a){}
    virtual void fun1(){cout << base1 << endl;}
    int base1;
};
class Base2:public Base
{
public:
    Base2 (int a = 3):base2(a){}
    virtual void fun2(){cout << base2 << endl;}
    int base2;
};
class Derive: public Base1, public Base2
{
public:
    Derive (int value = 4):derive (value){}
    virtual void fun3(){cout << derive << endl;}
    int derive;
};

注：分析时，由上到下依次分析。存在二义性问题和内存冗余问题。

 3、虚继承（不包含虚函数）

新增虚基类指针，指向虚基类表，虚基类表中首项存储虚基类指针的偏移量，接下来依次存储虚基类的偏移量（偏移量是相对于虚基类表指针的存储地址）。

　　 a、单虚继承（不包含虚函数）

class Base
{
public:
    Base (int a = 1):base(a){}
    void fun0(){cout << base << endl;}
    int base;
};
class Base1:virtual public Base
{
public:
    Base1 (int a = 2):base1(a){}
    void fun1(){cout << base1 << endl;}
    int base1;
};

　　 b、多虚继承（不包含虚函数）

class Base1
{
public:
    Base1 (int a = 2):base1(a){}
    void fun1(){cout << base1 << endl;}
    int base1;
};
class Base2
{
public:
    Base2 (int a = 3):base2(a){}
    void fun2(){cout << base2 << endl;}
    int base2;
};
class Derive:virtual public Base1, virtual public Base2
{
public:
    Derive (int value = 4):derive (value){}
    void fun3(){cout << derive << endl;}
    int derive;
};

　　c、菱形虚继承（不包含虚函数）

　　 第一种形式：

class Base
{
public:
    Base (int a = 1):base(a){}
    void fun0(){cout << base << endl;}
    int base;
};
class Base1:virtual Base
{
public:
    Base1 (int a = 2):base1(a){}
    void fun1(){cout << base1 << endl;}
    int base1;
};
class Base2:virtual Base
{
public:
    Base2 (int a = 3):base2(a){}
    void fun2(){cout << base2 << endl;}
    int base2;
};
class Derive:virtual public Base1, virtual public Base2
{
public:
    Derive (int value = 4):derive (value){}
    void fun3(){cout << derive << endl;}
    int derive;
};

注：分析派生类的内存分布时，也是由上到下分析。虚继承将基类置于内存末尾，但是置于末尾的顺序也有一定的次序。首先Base先放到末尾，然后Base1放到末尾，最后Base2放到末尾。

第二种形式：

class Base
{
public:
    Base (int a = 1):base(a){}
    void fun0(){cout << base << endl;}
    int base;
};
class Base1:virtual public Base
{
public:
    Base1 (int a = 2):base1(a){}
    void fun1(){cout << base1 << endl;}
    int base1;
};

class Base2:virtual public Base
{
public:
    Base2 (int a = 3):base2(a){}
    void fun2(){cout << base2 << endl;}
    int base2;
};
class Derive: public Base1, public Base2
{
public:
    Derive (int value = 4):derive (value){}
    void fun3(){cout << derive << endl;}
    int derive;
};

注：分析的原则，从上到下，依次分析。

4、 虚继承（包含虚函数）

a、单虚继承（包含虚函数）

class Base
{
public:
    Base (int a = 1):base(a){}
    virtual void fun0(){cout << base << endl;}
    int base;
};
class Base1:virtual Base
{
public:
    Base1 (int a = 2):base1(a){}
    virtual void fun1(){cout << base1 << endl;}
    int base1;
};

　　与普通的包含虚函数的单继承相比，派生类拥有自己的虚函数表以及虚函数表指针，而不是与基类共用一个虚函数表。注意虚函数表指针和虚基类表指针的存储顺序。

　　b、多虚继承（包含虚函数）

class Base1
{
public:
    Base1 (int a = 2):base1(a){}
    virtual void fun1(){cout << base1 << endl;}
    int base1;
};

class Base2
{
public:
    Base2 (int a = 3):base2(a){}
    virtual void fun2(){cout << base2 << endl;}
    int base2;
};
class Derive:virtual public Base1, virtual public Base2
{
public:
    Derive (int value = 4):derive (value){}
    virtual void fun3(){cout << derive << endl;}
    int derive;
};

c、菱形虚继承（包含虚函数）

第一种形式：

class Base
{
public:
    Base (int a = 1):base(a){}
    virtual void fun0(){cout << base << endl;}
    int base;
};
class Base1:virtual public Base
{
public:
    Base1 (int a = 2):base1(a){}
    virtual void fun1(){cout << base1 << endl;}
    int base1;
};

class Base2:virtual public Base
{
public:
    Base2 (int a = 3):base2(a){}
    virtual void fun2(){cout << base2 << endl;}
    int base2;
};
class Derive:  public Base1, public Base2
{
public:
    Derive (int value = 4):derive (value){}
    virtual void fun3(){cout << derive << endl;}
    int derive;
};

第二种形式：

class Base
{
public:
    Base (int a = 1):base(a){}
    virtual void fun0(){cout << base << endl;}
    int base;
};
class Base1:virtual public Base
{
public:
    Base1 (int a = 2):base1(a){}
    virtual void fun1(){cout << base1 << endl;}
    int base1;
};

class Base2:virtual public Base
{
public:
    Base2 (int a = 3):base2(a){}
    virtual void fun2(){cout << base2 << endl;}
    int base2;
};
class Derive: virtual public Base1,virtual public Base2
{
public:
    Derive (int value = 4):derive (value){}
    virtual void fun3(){cout << derive << endl;}
    int derive;
};

自行脑补C++类对象的内存结构……

注：上述虚函数中，如果派生类重写了基类的虚函数，则对应虚函数表中的虚函数应该修改成重新后的虚函数，即Base::fun()->Derive::fun()。

原文地址：https://www.cnblogs.com/weekbo/p/8855475.html

时间： 2024-06-15 21:15:56

c++继承汇总（单继承、多继承、虚继承、菱形继承）的相关文章

C++继承详解之三——菱形继承+虚继承内存对象模型详解vbptr（1）

在我个人学习继承的过程中,在网上查阅了许多资料,这些资料中有关菱形继承的知识都是加了虚函数的,也就是涉及了多态的问题,而我在那个时候并没有学习到多态这一块,所以看很多资料都是云里雾里的,那么这篇文章我想以我自己学习过程中的经验,由简到较难的先分析以下菱形继承,让初学者先对这个问题有一点概念,在后面会由浅入深的继续剖析. 本篇文章不会涉及到多态也就是虚函数的菱形继承,在后面的文章更新中,我会慢慢把这些内容都加进去. 菱形继承(也叫钻石继承)是下面的这种情况: 对应代码如下: #include <i

面向对象概论之继承简述，组合简述，菱形继承简述

一.继承 1.简述: 用来表述的是类与类之间的关系,比如A继承了B,那么A会有B已有的方法和属性. 那么A称为子类,B为父类.(父类又叫:基类) 使用继承可以不再用重复写代码的情况下,从而重复使用代码. 提高了编程效率. 2.正确使用继承思想:       1.先抽象然后再继承       2.继承已经存在的类,可拓展或是修改原始功能 3.在继承里的属性查找顺序: 对象自己的----->所在的类中----->父类----->父类的父类------->Object 4.继承语法表达:

C++里的继承和多态（下）——单继承、多继承、菱形继承（含虚拟函数的继承）

1.带有虚函数的类 class Base { public:                  virtual void FunTest1()                 {                                 cout << "Base::FunTest1()" << endl;                 }                  virtual void FunTest2()                 

C++中的类继承之单继承&amp;多继承&amp;菱形继承

 C++中的类继承之单继承&多继承&菱形继承 单继承是一般的单一继承,一个子类只 有一个直接父类时称这个继承关系为单继承.这种关系比较简单是一对一的关系: 多继承是指 一个子类有两个或以上直接父类时称这个继承关系为多继承.这种继承方式使一个子类可以继承多个父类的特性.多继承可以看作是单继承的扩展.派生类具有多个基类,派生类与每个基类之间的关系仍可看作是一个单继承.多继承下派生类的构造函数与单继承下派生类构造函数相似,它必须同时负责该派生类所有基类构造函数的调用.同时,派生类的参数个数必须包

【整理】C++虚函数及其继承、虚继承类大小

参考文章: http://blog.chinaunix.net/uid-25132162-id-1564955.html http://blog.csdn.net/haoel/article/details/1948051/ 一.虚函数与继承 1.空类,空类单继承,空类多继承的sizeof #include <iostream> using namespace std; class Base1 { }; class Base2 { }; class Derived1:public Base1

面向对象：继承、抽象类、抽象方法、虚方法

1.继承什么是继承?目的:代码重用public class 子类:父类{ }父类 基类 被继承的类子类 派生类 需要继承的类 父类构造函数的继承创建子类对象时,先调用父类构造函数,再调用子类构造函数默认调用父类无参构造函数如果子类有无参构造函数,要求父类也有无参构造函数如果调用父类的有参构造函数,显式用base调用 public 子类(参数列表)base(实参)实参:要调用的父类的有参构造函数的参数列表{} base:父类对象(父类实例) 2.抽象abstract 抽象方法:访问修饰符 abst

含有虚函数菱形的虚拟继承(没有对虚函数进行重写)

在VS2013编程,调试 问题 :  菱形继承会引来,二义性 1.源代码 </pre><pre name="code" class="cpp">#include <iostream> using namespace std; class Base { public: virtual void FunTest() { cout << "Base::FunTest () " << endl;

处理菱形继承问题&&实现一个虚函数的覆盖及调用&&实现以下几个类的成员函数

#include <iostream> #include <string> using namespace std; 1.实现以下几个类的成员函数 2.实现一个虚函数的覆盖及调用 3.处理菱形继承问题. 植物 class Botany { public: //(const string& name) // const char* name Botany(const char* name = "") :_name(name) //构造函数 { //cout

虚基类 继承中的构造函数

/* *Copyright (c)2014,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称:d.cpp *作 者:张旺华 *完成日期:2015年6月1日 *版 本 号:v1.0 */ #include <iostream> using namespace std; class Base { public: Base(char i) { cout<<"Base constructor. --"<<i<<