继承：单继承、派生类成员的访问属性、多继承、菱形继承、虚继承，菱形虚拟继承

最新推荐文章于 2023-02-10 20:18:25 发布
最新推荐文章于 2023-02-10 20:18:25 发布
阅读量1k 收藏 1
点赞数 3
分类专栏： cpp 文章标签： 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaseraod/article/details/69704143
版权

1，派生类的声明方式

class Student
{
public:
    void display()
    {
        cout << "num:" << num << endl;
        cout << "name:" << name << endl;
        cout << "sex:" << sex << endl;
    }
private:
    int num;
    char name[10];
    char sex;
};

class Student1 : public Student//声明派生类
{
public:
    void display_1()
    {
        cout << "age:" << endl;
        cout << "address:" << addr << endl;
    }
private:
    int age;
    char addr[10];
};

2，派生类成员的访问属性
（1）public(公用继承）

class student
{
public:
    void getvalue()
    {
        cin >> num >> name >> sex;
    }
    void display()
    {
        cout << "num:" << num << endl;
        cout << "name::" << name << endl;
        cout << "sex:" << sex << endl;
    }
private:
    int num;
    char name[10];
    char sex[5];
};

class student1:public student
{
public:
    void getvalue_1()
    {
        getvalue();
        cin >> age>>addr;
    }
    void display_1()
    {
        display();//调用基类公有成员函数来访问基类私有成员变量
        cout << "num:" << num << endl;//报错，基类私有成员不可访问
        cout << "age:" << age << endl;
        cout << "addr:" << addr << endl;
    }
    int age;
    char addr[10];
};

int main()
{
    Student1 stud;
    stud.getvalue_1();
    stud.display_1();
    system("pause\n");
    return 0;
}

下面用一张表来说明公用基类的成员在派生类中的访问属性
这里写图片描述

（2）private(私有继承）
将上面的程序改为私有继承

class student
{
public:
    void getvalue()
    {
        cin >> num >> name >> sex;
    }
    void display()
    {
        cout << "num:" << num << endl;
        cout << "name::" << name << endl;
        cout << "sex:" << sex << endl;
    }
private:
    int num;
    char name[10];
    char sex[5];
};

class Student1 :private student
{
public:
    void getvalue_1()
    {
        getvalue();
        cin >> age >> addr;
    }
    void display_1()
    {
        display();
        //cout << "num:" << num << endl;
        cout << "age:" << age << endl;
        cout << "addr:" << addr << endl;
    }
private:
    int age;
    char addr[10];
};

int main()
{
    Student1 stud;
    //stud.getvalue();//报错，私有基类的公用成员函数在外界不可访问
    stud.display_1();
    //stud.age = 18;//错误，外界无法访问派生类的私有成员
    system("pause\n");
    return 0;

}

结论：（1）不能通过派生类对象引用从私有基类继承过来的任何成员
（2）派生类的成员函数不能访问私有基类的私有成员，但可以访问私有类的公用成员函数
这里写图片描述

（3）protected（保护继承）

class student
{
private:
    void display();

protected:
    int num;
    char name[10];
    char sex[5];
};

class Student1 :protected student
{
public:
    void getvalue_1()
    {
        cin >> num >> name >> sex;
        cin >> age >> addr;
    }
    void display_1()
    {
        cout << "num:" << num << endl;
        cout << "name:" << num << endl;
        cout << "sex:" << num << endl;
        cout << "age:" << age << endl;
        cout << "addr:" << addr << endl;
    }
private:
    int age;
    char addr[10];
};

int main()
{
    Student1 stud;
    stud.display_1();
    //stud.display();//报错，保护基类的公用成员在外界不可访问
    stud.display_1();
    //stud.age = 18;//报错，基类的保护成员对派生类的外界来说是不可访问的
    system("pause\n");
    return 0;

}

保护基类的公有成员和保护成员在派生类中都成了保护成员，其私有成员仍为基类私有，也就是把基类原有的公有成员也保护起来，不让类外任意访问。
3，多级派生时的访问属性

class A
{
public:
    int i;
protected:
    void f1(){}
    int j;
private:
    int k;
};

class B :public A
{
public:
    void f2(){}
protected:
    void f3(){}
private:
    int m;
};

class C :protected B
{
public:
    void f4();
private:
    int n;
};

int main()
{
    C c;
    B b;
    b.i = 10;//可访问
    //c.f2();//不可访问
}

各成员在不同类中的访问属性

无论哪一种继承方式，在派生类中是不能访问基类的私有成员的，私有成员只能被本类的成员函数访问。
4，派生类的构造函数和析构函数
先定义一个简单的派生类的构造函数

class Student
{
public:
    Student(int n, string nam, char s)//定义基类构造函数
        :num(n), name(nam), sex(s)
    {
        cout << "Student()" << endl;
    }
    ~Student()
    {
        cout << "~Student()" << endl;
    }
protected:
    int num;
    string name;
    char sex;
};

class Student1 :public Student
{
public:
    Student1(int n, string nam, char s, int a, string add)//定义派生类构造函数
        :Student(n, nam, s), age(a), addr(add)//在初始化列表初始化
    {
        cout << "Student1(）"<<endl;
    }
    void show()
    {
        cout << "num:" << num << endl;
        cout << "name:" << name << endl;
        cout << "sex:" << sex << endl;
        cout << "age:" << age << endl;
        cout << "add:" << addr << endl;
    }
    ~Student1()
    {
        cout << "~Student1()" << endl;
    }
private:
    int age;
    string addr;
};

int main()
{
    Student1 stud1(1000, "wangli", 'n', 19, "shanxikejidaxue");
    Student1 stud2(1001, "liuyulin", 'n', 18, "xibeihzengfadaxue");
    stud1.show();
    cout << endl;
    stud2.show();
    //system("pause\n");
    return 0;
}

分别在两个构造函数和两个析构函数处大断点，对程序进行调试，打印的结果如图
这里写图片描述
从结果上看，程序是先调用了基类的构造函数，再调用派生类的构造函数，程序结束后，先析构派生类，再析构基类。
事实上，从程序的调试过程可以看出，程序是先调用派生类的构造函数，此时，执行调用基类构造函数完成对基类的初始化，然后再继续执行派生类构造函数的函数体。此处可上机实践进行验证。

若派生类中有子对象，则在派生类构造函数中对子对象进行初始化。因此，执行派生类构造函数的次序是
（1）调用基类构造函数，对基类数据成员初始化
（2）调用子对象构造函数，对子对象数据成员初始化
（3）再执行派生类构造函数本身，对派生类数据成员初始化

派生类是不能继承基类的析构函数的，也需要通过派生类的析构函数去调用基类的析构函数。
5，多重继承引起的二义性问题及同名覆盖

class A
{
public:
    int a;
    void display();
};
class B
{
public:
    int a;
    void display();
};
class C :public A, public B
{
public:
    int b;
    //void show();
};

int main()
{
    C c;
    c.a = 10;//报错
    c.display();//报错
}

编译系统无法判别要访问的是哪个基类的成员，编译出错，这就是多重继承存在的二义性问题。
如果将C类改为如下形式

class C :public A, public B
{
public:
    int a;
    void display();
};

int main()
{
    C c;
    c.a = 10;//编译通过
    c.display();//编译通过
}

此时编译通过，那么程序执行时访问的到底是哪一个类中的成员？
此时，访问的是C类的成员，规则：基类的同名成员在派生类中被屏蔽，成为“不可见”的，或者说，派生类新增加的同名成员覆盖了基类中的同名成员。
注意：不同的成员函数，只有在函数名和参数个数相同，类型匹配的情况下才发生同名覆盖
6，菱形继承及虚基类
菱形继承时多重继承中的一种继承方式，也存在二义性问题
这里写图片描述
这样的继承方式成为菱形继承

class A
{
public:
    int data;
    void fun(){}
};

class B :public A
{
public:
    int data;
    void fun(){}
    int _b;
};

class C :public A
{
public:
    int data;
    void fun(){}
    int _c;
};

class D :public B, public C
{
public:
    int _d;
    void fun_d(){}
};

这里写图片描述
从上图看出，不同类中相同的成员在D中产生了多份拷贝，不仅占用内存，而且对访问这些成员增加困难。
下面我们介绍虚基类
虚基类可使得在继承间接共同基类时只保留一份成员
将上面的代码改为

class A
{};
class B:virtual public A
{};
class C:virtual public A
{};

这里写图片描述

之前学习继承多态的时候学的是似懂非懂的，所以这篇博客内容也只是一些概念性的东西，并未深入探索，再回过头学习时，以前模棱两可的东西突然就明白了一些，所以决定将这篇博客更新。

菱形继承中含有虚函数：

class A
{
public:
    virtual void Fun1()
    {
        cout << "A::Fun1" << endl;
    }
    virtual void Fun2()
    {
        cout << "A::Fun2" << endl;
    }
    int _a;
};

class B :public A
{
public:
    virtual void Fun1()
    {
        cout << "B::Fun1" << endl;
    }
    virtual void Fun3()
    {
        cout << "B::Fun3" << endl;
    }
    int _b;
};

class C :public A
{
public:
    virtual void Fun1()
    {
        cout << "C::Fun1()" << endl;
    }
    virtual void Fun4()
    {
        cout << "C::Fun4" << endl;
    }
    int _c;
};

class D :public B, public C
{
public:
    virtual void Fun1()
    {
        cout << "D::Fun1" << endl;
    }
    virtual void Fun5()
    {
        cout << "D::Fun5" << endl;
    }
    int _d;
};

//打印虚表
typedef void(*V_FUNC) ();

void PrintVTable(int* vtable)
{
    printf("vtable 0x%p\n", vtable);
    int** ppVtable = (int**)vtable;
    for (size_t i = 0; ppVtable[i] != 0; ++i)
    {
        printf("vatable[%u]:0x%p->", i, ppVtable[i]);
        V_FUNC f = (V_FUNC)ppVtable[i];
        f();
    }
    cout << "——————————————————————————————" << endl;
}

void Test1()
{
    D d;
    d.B::_a = 1;
    d._b = 2;
    d.C::_a = 3;
    d._c = 4;
    d._d = 5;

    PrintVTable(*((int**)&d));//第一个虚表B的
    PrintVTable(*((int**)((char*)&d + sizeof(B))));//C的虚表
}

int main()
{
    Test1();
    system("pause");
    return 0;
}

我们通过内存窗口来查看D的虚表：
这里写图片描述

可以证明，多继承时，子进程中新增的虚函数是写入了第一个继承的父类的虚表中。

菱形虚拟继承中含有虚函数：

class A
{
public:
    virtual void Fun1()//去掉Func1崩溃，因为BC是同级的。虚继承不明确
    {
        cout << "A::Fun1" << endl;
    }
    virtual void Fun2()
    {
        cout << "A::Fun2" << endl;
    }
    int _a;
};

class B :virtual public A
{
public:
    virtual void Fun1()
    {
        cout << "B::Fun1" << endl;
    }
    virtual void Fun3()
    {
        cout << "B::Fun3" << endl;
    }
    int _b;
};

class C :virtual public A
{
public:
    virtual void Fun1()
    {
        cout << "C::Fun1()" << endl;
    }
    virtual void Fun4()
    {
        cout << "C::Fun4" << endl;
    }
    int _c;
};

class D :public B, public C
{
public:
    virtual void Fun1()
    {
        cout << "D::Fun1" << endl;
    }
    virtual void Fun5()
    {
        cout << "D::Fun5" << endl;
    }
    int _d;
};

typedef void(*V_FUNC) ();

void PrintVTable(int* vtable)
{
    printf("vtable 0x%p\n", vtable);
    int** ppVtable = (int**)vtable;
    for (size_t i = 0; ppVtable[i] != 0; ++i)
    {
        printf("vatable[%u]:0x%p->", i, ppVtable[i]);
        V_FUNC f = (V_FUNC)ppVtable[i];
        f();
    }
    cout << "——————————————————————————————" << endl;
}

void Test1()
{
    D d;
    d.B::_a = 1;
    d._b = 2;
    d.C::_a = 3;
    d._c = 4;
    d._d = 5;


//(*(int**)&d)解引用二级指针，在32位和64位下均能正确使用

    PrintVTable(*((int**)&d));//第一个虚表B的
    PrintVTable(*((int**)((char*)&d + sizeof(B)-sizeof(A))));//C的虚表
    PrintVTable(*((int**)((char*)&d + sizeof(D)-sizeof(A))));//A的虚表
    //B的虚表里其实是含有A的
    cout << sizeof(A) << endl;
    cout << sizeof(B) << endl; 
    cout << sizeof(C) << endl;
    cout << sizeof(D) << endl;

    B b;
    b._a = 10;
    b._b = 11;
}

int main()
{
    Test1();
    system("pause");
    return 0;
}

这里写图片描述

通过上图可以看出，菱形虚拟继承中，为了避免二义性，公共父类A有单独的虚表，且图中有两张表，一个是虚基表，里面保存的是虚继承中子类的偏移量，而虚表中保存的是虚函数。
公共数据a在D对象的最底层，且B类和C类中均包含A类，所以的它们的大小为虚表指针+虚基表指针+各自数据大小+A类中公共数据大小。

ChaseRaod
关注
专栏目录
C++ 继承 | 对象切割、菱形继承、虚继承、对象组合
Jormungand_V的博客
08-24 907
文章目录继承继承的概念继承方式基类与派生类的赋值转换派生类的默认成员函数友元与静态成员多继承菱形继承虚继承 继承 继承的概念 继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。 当创建一个类时，我们可以继承一个已有类的成员和方法，并且在原有的基础上进行提升，这个被继承的类叫做基类，而这个继承后新建的类叫做派生类。 class [派生类名] : [继承类型] [基类名] 实现： class Human { public: Human(string name = "张三", int ag
继承（单继承、多继承、菱形继承、虚继承）
gunqu_d的博客
11-15 641
一、单继承 单继承是一种 一个子类只有一个直接父类 的继承关系。 eg： 二、多继承 多继承是一种 一个子类有两个或两个以上直接父类 的继承关系。 eg： 三、菱形继承 菱形继承由两个（或以上）单继承，一个多继承构成，结构如下: eg: 显然，上例中Assistant类多继承了Student和Teacher两个类，而Student和Teache
C++不同继承方式下派生类成员的访问属性
zuisanlang的专栏
03-19 1334
对C++不同继承方式下派生类成员的访问属性问题做了总结，并且用图形化的方式呈现出来，如下： 一、public继承 二、protected继承 三、private继承 四、protected继承和private继承的比较 4.1protected继承方式对孙类的影响 子类从父类是protected继承方式，孙类从子类是public或protected继承方式的情形：...
C++基础（八）继承与派生——派生类成员的访问属性
浮生流年的博客
01-24 421
派生类成员的访问属性 public : 公有继承 基类 public 成员：在派生类中还是 public 属性，在派生类的内部和外部都可以访问 基类 protected 成员：在派生类中还是 protected 属性，在派生类的内部可以访问， 外部不可以访问 基类 private 成员：在派生类中还是 private 属性，在派生类的内部和外部都不可以访
派生类成员的访问属性
qq_45288949的博客
05-13 381
一、公有继承 共有继承访问属性 在基类的访问属性 继承方式 在派生类的访问属性 public public public protected protected private 不可直接访问 公有继承的应用： 1.通过派生类的对象访问基类的成员变量。 #include<iostream> using namespace std; class Clock { public: void SetClock() { cin&g
C++ 派生类访问属性
我是小白呀的博客
05-13 3974
C++ 派生类访问属性. 公用的 (public), 受保护的 (protected), 私有的 (private), 不可访问的.
C++ 派生类成员的访问属性
weixin_30596343的博客
04-19 561
派生类成员的访问属性： C++继承方式总共分为以下几种：public、private、protected三种（它们直接影响到派生类的成员、及其对象对基类成员访问的规则）。（1）public（公有继承）：继承时保持基类中各成员属性不变，并且基类中private成员被隐藏。派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；派生类的对象只能访问基...
C++（第十一篇）：继承（基类与派生类、菱形继承和菱形虚拟继承问题）
杨同学的博客
12-11 1143
面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类去继承一个已有的类即可。这个已有的类称为基类（父类），新建的类称为派生类（子类）。很多人说 C++ 语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出菱形继承。否则在复杂度及性能上都有问题。
C++菱形继承对象内存布局实战讲解和分析
净无邪博客
02-27 2828
本文主要讲解C++对象模型中的菱形继承的对象模型，分别讨论基类对象变量和函数的继承问题。 何为菱形继承： 菱形继承是指一个基类（Base）派生出两个派生类（Derived1，Derived2），然后这两个派生类（Derived1，Derived2）派生出一个最终的派生类，如1.1的下图所示。 一、菱形继承之非虚继承 1.1类Base、派生类Derived1、派生类Derived2、最终派生类DDerived的UML结构图 1.2类Base、派生类Derived1、派生类Derived2、最终派生类DDer
C++ 多重继承和虚拟继承对象模型、效率分析
09-04
虚拟继承确保在派生层次结构中，基类只有一个实例，即使多个派生类都继承自它。这样可以避免菱形问题，并减少内存中的冗余。实现虚拟继承时，对象模型通常分为不变局部（即与派生无关的部分）和共享局部（即虚拟基类...
继承后基类、派生类的访问属性
午后斜阳
09-05 4851
一、单继承与多继承（1）一个派生类只从一个基类派生，这称为单继承(single inheritance)；（2）一个派生类有两个或多个基类的称为多重继承(multiple inheritance)；（注意：区分多重继承和多级派生的概念）二、声明派生类的方式（1）声明派生类的一般形式为： class 派生类名:［继承方式］ 基类名 { 派生类新增加的成员
5.2派生类成员访问属性
rkm444076698的博客
12-07 393
还记得派生类成员访问属性吗？ 就是由继承方式和派生类成员访问限制符决定的那个 而且在此我们还新引入了protected这个新的成员访问限制符 从类的用户角度来看，保护类成员等价于私有成员，有一点与私有成员不同 那就是保护成员可以被派生类的成员函数引用 如果把友元比喻成朋友，可以允许好朋友进入自己的卧室 而保护成员相当于保险箱，任何外人均不得窥视，只有子女（及其派生类）才能打开 所以prot...
继承与派生：派生类对基类成员的访问控制之公有继承
chunlanse2014的专栏
03-16 1237
派生类从基类继承时有三个步骤，第一个步骤是吸收基类成员，吸收了基类中除构造函数和析构函数之外的所有数据成员和函数成员，第二个步骤就是修改基类成员，包括修改对基类成员的访问属性和覆盖基类成员，第三个步骤是添加新成员。第二个步骤中修改对基类成员的访问属性可以通过派生类的继承方式控制。       类的成员有public（公有）、protected（保护）和private（私有）三种访问属性。类的
C++多级派生访问属性
最新发布
LC的专栏
02-10 218
定义派生类student_new，从基类student私有派生而来，那么，基类student中的所有数据在student_new中都是私有。那么，在派生类student_v1中就定义print_v1()函数，调用派生类的print_new()函数，输出从派生类继承过来的数据。所以，派生类student_new中访问基类student的print()函数，可以访问基类student中的私有数据。那么，如果又有一个新的类student_v1 从 student_new类派生，会是怎么样的情况？
多级派生时的访问权限
u012223598的专栏
08-15 496
下面通过一个简单的例子来介绍一下
继承、多继承、菱形虚拟继承
centor的博客
07-23 541
继承  继承是由父类和子类（或称之为基类与派生类）两种角色构成，子承父业，就是说派生类会继承基类的所有的成员，并拥有自己特有的成员。 用一段代码来解释说明继承关系#include <iostream> using namespace std;class Base //基类 { public: Base() { cout<<"Base()"<<endl; }
C++之菱形继承与虚继承（无虚函数）
Koma_CC的博客
05-03 355
定义：设有一个父类A类，B类和C类分别继承它，然后再有一个D类继承B类和C类。这样就叫做菱形继承也叫钻石继承(Diamond inheritance)上代码块：#define _CRT_SECURE_NO_WARNINGS 1 #include&lt;stdio.h&gt; #include&lt;iostream&gt; using namespace std; class A { public...
继承基类成员访问方式的变化
weixin_45512163的博客
10-28 361
1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是 被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。 2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能 访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。 3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类 的访问方式 == Min(成员在基类.
不同派生方式下基类成员在派生类中的可访问范围属性
ltimaginea的博客
10-23 1260
不同派生方式下基类成员在派生类中的可访问范围属性 派生方式 派生方式 派生方式 基类成员 公有派生 私有派生 保护派生 私有成员 不可访问 不可访问 不可访问 保护成员 保护 私有 保护 公有成员 公有 私有 保护 ...
继承与派生——多继承
L_Andy的专栏
03-09 1153
只有一个基类的派生方法称为单继承。实际上，可以为一个派生类指定多个基类，这样的继承结构被称为多重继承或多继承。 多继承声明        在C++中，声明具有两个以上基类的派生类与声明单继承派生类的形式相似，只需将要继承的多个基类使用逗号“，”分隔即可。其声明的一般形式如下： class 派生类名 : 继承方式1 基类名1，继承方式2 基类名2，……，继承方式n 基类名n { // 派生
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值