继承和派生、虚继承和虚基类、虚基类表和虚基类指针
 
继承和派生
继承概述
继承基本概念
派生类中的成员
继承的内容
   
派生类定义
派生类访问控制
对象构造和析构
对象构造和析构的调用顺序
继承中的构造和析构的调用规则
   
调用子类构造前会先调用父类构造
继承中同名成员的处理方法
继承中的静态成员特性
非自动继承的函数
多重继承
  
虚继承和虚基类
菱形继承
虚继承和虚基类
虚继承（Virtual Inheritance）
虚基类（Virtual Base Class）
   
继承后虚基类成员的可见性
  
虚基类表和虚基类指针

 
继承和派生
 
继承概述
 
继承基本概念
 
c++最重要的特征是代码重用，通过继承机制可以利用已有的数据类型来定义新的数据类型，新的类不仅拥有旧类的成员，还拥有新定义的成员。
 
继承可以实现代码的复用，被继承的类称为父类或超类(Superclass)，继承而得到的类称为子类或派生类
 
 
 
一个B类继承于A类，或称从类A派生类B。这样的话，类A成为基类（父类）， 类B成为派生类（子类）。
 
 
派生类中的成员
 
 
 
  派生类中的成员，包含两大部分：
  
 
 
  
一类是从基类继承过来的
 
 
 
 
 
  
 
   
从基类继承过过来的表现其共性
 
  
 
 
 
 
 
  
一类是自己增加的成员
 
 
 
 
 
  
 
   
新增的成员体现了其个性。
 
  
 
 
 
 
继承的内容
 
派生类继承基类，派生类拥有基类中全部成员变量和成员方法（除了构造和析构之外的成员方法）
 
基类的私有成员是会被派生类继承的，但是不能被派生类访问
 从物理上讲是复制过来了，在内存中确实有复制。但是从程序上看是被屏蔽了，不能直接调用。
 
对于基类private类型的成员变量，无论是公有继承还是私有继承，在派生类中定义的成员函数都不能直接访问基类的私有成员，只能通过基类的public或protect成员函数访问基类的私有成员。
 
派生类定义
 

 派生类定义格式：
 
Class 派生类名 : 继承方式 基类名 { //派生类新增的数据成员和成员函数 }
 
继承方式：
 
public ： 公有继承
private ： 私有继承
protected ： 保护继承
 
派生类访问控制
 
派生类继承基类，派生类拥有基类中全部成员变量和成员方法（除了构造和析构之外的成员方法），但是在派生类中，继承的成员并不一定能直接访问，不同的继承方式会导致继承而来的属性拥有不同的访问权限。（根据继承方式缩小访问权限）
 派生类中：虽然继承了所有属性和方法(除了构造和析构)，但是基类的私有成员在派生类中无法访问（无论继承方式是什么），而非私有成员将会根据继承方式缩小访问权限（公有继承由于拥有最高权限所以基类访问权限不变，保护继承会将基类中公有权限缩小至保护权限，私有继承会将基类中公有权限和保护权限缩小至私有权限）
 
 私有继承
 
私有继承后父类公有成员和保护成员都作为子类的私有成员，并且不能被这个子类的对象所访问。
 
如果子类再派生出一个孙子类的话，因为父类的成员在子类中只有公有成员和保护成员可以访问，并且属性降级为private，所以孙子类即使是公有继承子类的，也不能访问private成员。
 
 
 
所以在私有继承时，父类的成员只能由直接派生子类访问，而无法再往下继承。
 
 
对象构造和析构
 
继承时，子类并不会继承父类中的构造函数和析构函数，而是再子类构造中调用父类的构造
 
对象构造和析构的调用顺序
 
 
子类对象在创建时会首先调用父类的构造函数(父类构造先于子类构造)
析构函数调用顺序和构造函数相反，先调用子类中构造，再调用父类中构造
 
继承中的构造和析构的调用规则
 
如果子类没有显示调用父类含参数的构造函数，那么在子类实例化过程中，系统会自动调用父类默认构造（无参构造）
 
在子类构造中调用父类构造，不能再函数体中调用（这样会成为匿名函数），只能在初始化列表中调用父类构造
 1 .在子类体中调用父类构造，变为匿名对象
 2 .在初始化列表中调用父类构造
 
当父类构造函数有参数时（自定义有参构造后系统将不提供默认构造），需要在子类初始化列表(参数列表)中显示调用父类构造函数
 系统会在子类构造中调用父类默认(无参)构造
 父类没有默认构造，则需要进行显示调用
 父类中使用自定义构造后，需要在自定义构造中显示调用（初始化列表）
 
调用子类构造前会先调用父类构造
 
子类对象在创建时会首先调用父类的构造函数(父类构造先于子类构造)，父类构造函数执行完毕后，才会调用子类的构造函数
 
 
 
 
父类的构造函数，用于初始化父类中的成员
 子类的构造函数，用于初始化子类新增或重写成员
 
 
父类构造函数执行完毕后，才会调用子类的构造函数
 
析构函数调用顺序和构造函数相反，先调用子类中构造，再调用父类中构造
 
继承中同名成员的处理方法
 
当子类成员和父类成员同名时，子类依然从父类继承同名成员，当访问时就近调用自身成员
 
 如果子类有成员和父类同名，子类访问其成员默认访问子类的成员(本作用域，就近原则)
 
 
 
  任何时候重新定义基类中的一个重载函数，在新类中所有的其他版本将被自动隐藏.
  
 

  父类和子类中同名函数，子类会将父类中所有同名函数(无论是否为重载版本)，只能通过作用域访问父类函数
 
 
 
在子类通过作用域::进行同名成员区分(在派生类中使用基类的同名成员，显示使用类名限定符)
 
 : 在子类构造函数的函数体中指定作用域也无法调用父类构造，只会生成匿名对象
 
继承中的静态成员特性
 
静态成员函数和非静态成员函数的共同点:
 
他们都可以被继承到派生类中。
如果重新定义一个静态成员函数，所有在基类中的其他重载函数会被隐藏。
如果我们改变基类中一个函数的特征，所有使用该函数名的基类版本都会被隐藏。
 
非自动继承的函数
 
不是所有的函数都能自动从基类继承到派生类中。
 
构造函数和析构函数用来处理对象的创建和析构操作，构造和析构函数只知道对它们的特定层次的对象做什么，也就是说构造函数和析构函数不能被继承，必须为每一个特定的派生类分别创建。
operator=也不能被继承，因为它完成类似构造函数的行为。 
  
 
   
也就是说尽管我们知道如何由=右边的对象如何初始化=左边的对象的所有成员，但是这个并不意味着对其派生类依然有效。
 
  
 
 
多重继承
 
单继承：指每个派生类只直接继承了一个基类的特征
 多继承：指多个基类派生出一个派生类的继承关系,多继承的派生类直接继承了不止一个基类的特征
 
我们可以从一个类继承，我们也可以能同时从多个类继承，这就是多继承。
 
 
多重继承只需要将多个继承的基类使用逗号(,)分隔开即可，分别书写基类继承方式和继承基类名
 
多继承会带来一些二义性的问题， 如果两个基类中有同名的函数或者变量，那么通过派生类对象去访问这个函数或变量时就不能明确到底调用从基类1继承的版本还是从基类2继承的版本
 
 
虚继承和虚基类
 
菱形继承
 
菱形继承是多继承中的一种情况
 
两个派生类继承同一个基类而又有某个类同时继承者两个派生类，这种继承被称为菱形继承（或者钻石型继承）。
 
 菱形继承继承所带来的问题：
 
 
 
调用二义性
 
 羊继承了动物的数据和函数，鸵同样继承了动物的数据和函数，当草泥马调用函数或者数据时，就会产生二义性。
 
解决方法：通过指定调用那个基类的方式来解决
 
 
 
重复继承导致的空间浪费
 
 
草泥马继承自动物的函数和数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以
 
解决方法：采用虚基类
 
 
虚继承和虚基类
 
在多重继承中，如果发生了如：类B继承类A，类C继承类A，类D同时继承了类B和类C，最终在类D中就有了两份类A的成员，这在程序中是不能容忍的，当然解决这个问题的方法就是利用虚继承。
 
 
虚继承（Virtual Inheritance）
 

 为了解决多继承时的命名冲突和冗余数据问题，C++ 提出了虚继承，虚继承使得在派生类中只保留一份间接基类的成员。
 
虚继承的目的是让某个类做出声明，承诺愿意共享它的基类。
 
虚派生只影响从指定了虚基类的派生类中进一步派生出来的类，它不会影响派生类本身
在上图中，当定义 D 类时才出现了对虚派生的需求，但是如果 B 类和 C 类不是从 A 类虚派生得到的，那么 D 类还是会保留 A 类的两份成员。
 
在继承方式前面加上 virtual 关键字就是虚继承
 
C++标准库中的 iostream 类就是一个虚继承的实际应用案例。
 
 
iostream 从 istream 和 ostream 直接继承而来，而 istream 和 ostream 又都继承自一个共同的名为 base_ios 的类，是典型的菱形继承。
 
此时 istream 和 ostream 必须采用虚继承，否则将导致 iostream 类中保留两份 base_ios 类的成员。
 
虚基类（Virtual Base Class）
 
虚继承的目的是让某个类做出声明，承诺愿意共享它的基类。
 
其中，这个被共享的基类就称为虚基类（Virtual Base Class）
 
 
本例中的 A 就是一个虚基类。
在这种机制下，不论虚基类在继承体系中出现了多少次，在虚基类的派生类（如：D）中都只包含一份虚基类的成员。
 
继承后虚基类成员的可见性
 
在虚继承的最终派生类中只保留了一份虚基类的成员，所以该成员可以被直接访问，不会产生二义性，此时访问时可以直接访问而不需要指定作用域。
 
此外，如果虚基类的成员只被一条派生路径覆盖（子类重写父类成员），那么仍然可以直接访问这个被覆盖的成员，但是如果该成员被两条或多条路径覆盖了（多个子类中都重写父类成员），那就不能直接访问了，此时必须指明该成员属于哪个类（此时成员属于继承的父类而不是虚基类，并非虚继承）。
 
派生类中的的重定义（重写虚基类成员）成员比虚基类的成员优先级更高
 
假设 A 定义了一个名为 x 的成员变量，当我们在 D 中直接访问 x 时，会有三种可能性：
 
 
如果 B 和 C 中都没有 x 的定义，那么 x 将被解析为 A 的成员，此时不存在二义性。
如果 B 或 C 其中的一个类定义了 x，也不会有二义性，派生类的 x 比虚基类的 x 优先级更高。
如果 B 和 C 中都定义了 x，那么直接访问 x 将产生二义性问题。
 
虚基类表和虚基类指针
 
普通继承和虚继承的对象内存图是不一样的，其中包含有虚基类表和虚基类指针
 
 
虚继承的派生类结构：
 BigBase 菱形最顶层的类（虚基类），内存布局图没有发生改变。
 
 
Base1和Base2通过虚继承的方式派生自BigBase,这两个对象的布局图中可以看出编译器为我们的对象中增加了一个虚基类指针vbptr (virtual base pointer),vbptr指向了一张表，这张表保存了当前的虚指针相对于虚基类的首地址的偏移量。
 
 
Derived派生于Base1和Base2,继承了两个基类的vbptr指针，并调整了vbptr与虚基类的首地址的偏移量。
 

一.基本概念
 
1.要使这个公共基类在派生类中只产生一个子对象，必须对这个基类声明为虚继承，使这个基类成为虚基类。
 2. 虚基类用于有共同基类的场合
 3. 声明虚基类的一般形式为：
 class 派生类名: virtual 继承方式 基类名
 例：class B1:virtual public B
 5. 注意：
 虚基类并不是在声明基类时声明的，而是在声明派生类时，指定继承
 方式时声明的。因为一个基类可以在派生一个派生类时作为虚基类，而
 在派生另一个派生类时不作为虚基类。
 在第一级继承时就要将共同基类设计为虚基类
 5.作用
 1）主要用来解决多继承时可能发生的对同一基类继承多次而产生的二义
 性问题。
 2）为最远的派生类提供唯一的基类成员，而不重复产生多次拷贝。
 6.
 例.虚继承的测试
 
#include<iostream>
using namespace std ;
class A
{ public :
A ( ) { cout << "class A" << endl ; } 
} ;
class B : public A
{ public : 
B ( ) {cout << "class B" << endl ; } 
} ;
class C : public A
{ public :
C ( ) {cout << "class C" << endl ; }
} ;
class D : public B , public C
{ public : 
D ( ) {cout << "class D" << endl ; } 
} ;
int main ( )
{ D dd ; }
 
二.虚基类及其派生类构造函数
 
1.虚基类的成员是由最（远）派生类的构造函数通过调用虚基类的构造函数进行初始化的。
 建立对象时所指定的类称为最（远）派生类。
 2.在整个继承结构中，直接或间接继承虚基类的所有派生类，都必须在构造函数的成员初始化表中给出对虚基类的构造函数的调用。如果未列出，则表示调用该虚基类的默认构造函数。
 3.在建立对象时，只有最（远）派生类的构造函数调用虚基类的构造函数，该派生类的其他基类对虚基类构造函数的调用被忽略。
 
例.有虚基类时的构造函数举例
 
#include <iostream>
using namespace std;
class B
{
public:
    B(int n)
    {
        nV=n;
    }
    int nV;
    void fun()
    {
        cout<<"Member of B"<<endl;
    }
};
class B1: virtual public B
{
public:
    B1(int a) : B(a) {}
    int nV1;
};
class B2: virtual public B
{
public:
    B2(int a) : B(a) {}
    int nV2;
};
class D1: public B1, public B2
{
public:
    D1(int a) : B(a), B1(a), B2(a) {}
    int nVd;
    void fund()
    {
        cout<<"Member of D1"<<endl;
    }
};
int main()
{
    D1 d1(1);
    d1.fun();
    return 0;
}
 
三.赋值兼容规则
 
赋值兼容规则指在程序中需要使用基类对象的任何地方，都可以用公有派生类的对象来替代。
 赋值兼容规则中所指的替代包括以下的情况：
 1.派生类的对象可以赋给基类对象(强制类型转换)
 2. 派生类的对象可以初始化基类的引用
 3.派生类的对象的地址可以赋给基类类型的指针
 
其特点
 1.在替代之后，派生类对象就可以作为基类的对象使用，但只能使用从基类继承的成员。
 2.一个派生类对象也是一个基类对象，一个基类对象可派上用场的地方，派生类对象一样可派上用场。反之则不然。
 
注意：
 1.声明为指向基类的指针可以指向它的公有派生类的对象，但不允许指向它的私有派生类的对象。
 例如：
 
class B {…}；
class D：private B {…}；
B b1，*pbl；D d1；
pb1=&b1; //合法，基类B的对象b1和B类的指针
pb1=&d1; //非法，不允许将基类指针指向它的私有派生类对象
 
2.允许将一个声明为指向基类的指针指向其公有派生类对象，但是不能将一个声明为指向派生类对象的指针指向其基类的一个对象。
 3. 声明为指向基类对象的指针，当其指向公有派生类对象时，只能用它来直接访问派生类中从基类继承来的成员，而不能直接访问公有派生类的定义的成员。

 
C++ 虚基类
 
概述
多重继承的问题
虚基类
初始化
例子
  
总结

 
概述
 
虚基类 (virtual base class) 是用关键字 virtual 声明继承的父类.
 
 
多重继承的问题
 
N 类:
 
class N {
public:
    int a;
    void display(){
        cout << "A::a=" << a <<endl;
    }
};
 
A 类:
 
class A : public N {
public:
    int a1;
};
 
B 类:
 
class B : public N {
public:
    int a2;
};
 
C 类:
 
class C: public A, public B{
public:
    int a3;
    void display() {cout << "a3=" << a3 << endl;};
};
 
main:
 
int main() {
    C c1;
    // 合法访问
    c1.A::a = 3;
    c1.A::display();

    return 0;
}
 
输出结果:
 
A::a=3
 
存在的问题:
 
A::a 和 B::a 是 N 类成员的拷贝
A::a 和 B::a 占用不同的空间
 
 
虚基类
 
我们希望继承间接共同基类时只保留一份成员, 所以虚基类就诞生了. 当基类通过多条派生路径被一个派生类继承时, 该派生类只继承该基类一次.
 
语法:
 
class 派生类名: virtual 继承方式 基类名
 
初始化
 
通过构造函数的初始化表对虚拟类进行初始化. 例如:
 
N 类:
 
class N {
public:
    int n;
    N(int n) : n(n) {};
};
 
A 类:
 
class A : virtual public N {
public:
    A(int n) : N(n) {};
};
 
B 类:
 
class B : virtual public N {
public:
    B(int n) : N(n) {};
};
 
C 类:
 
class C: public A, public B{
public:
    C(int n) : N(n), A(n), B(n){};
};
 
例子
 
Person 类:
 
#ifndef PROJECT5_PERSON_H
#define PROJECT5_PERSON_H

#include <iostream>
#include <string>
using namespace std;

class Person {
protected:
    string name;
    char gender;
public:
    Person(string n, char g) : name(n), gender(g) {}
    void display() {
        cout << "name: " << name << endl;
        cout << "gender: " << gender << endl;
    }
};

#endif //PROJECT5_PERSON_H
 
Student 类:
 
#ifndef PROJECT5_STUDENT_H
#define PROJECT5_STUDENT_H

#include <string>
#include "Person.h"
using namespace std;

class Student : virtual public Person {
protected:
    double score;
public:
    Student(string n, char g, double s) : Person(n, g), score(s) {};
};

#endif //PROJECT5_STUDENT_H
 
Teacher 类:
 
#ifndef PROJECT5_TEACHER_H
#define PROJECT5_TEACHER_H

#include <string>
#include "Person.h"
using namespace std;

class Teacher : virtual public Person {
protected:
    string title;
public:
    Teacher(string n, char g, string t) : Person(n, g), title(t) {};
};

#endif //PROJECT5_TEACHER_H
 
Graduate 类:
 
#ifndef PROJECT5_GRADUATE_H
#define PROJECT5_GRADUATE_H

#include "Teacher.h"
#include "Student.h"
#include <string>
using namespace std;

class Graduate : public Teacher, public Student{
private:
    double wage;
public:
    Graduate(string n, char g, double s, string t, double w) : Person(n, g), Student(n, g, s), Teacher(n, g, t), wage(w) {};
    void display() {
        Person::display();
        cout << "score: " << score << endl;
        cout << "title: " << title << endl;
        cout << "wages: " << wage << endl;
    };
};

#endif //PROJECT5_GRADUATE_H
 
main:
 
#include <iostream>
#include "Graduate.h"
using namespace std;

int main() {
    Graduate grad1("小白",'f',89.5,"教授",1234.5);
    grad1.display();

    return 0;
}
 
输出结果:
 
name: 小白
gender: f
score: 89.5
title: 教授
wages: 1234.5
 
总结
 
使用多重继承时要十分小心, 否则会进场出现二义性问题
不提倡在程序中使用多重继承
只有在比较简单和不易出现二义性的情况或实在必要时才使用多重继承
能用单一继承解决的问题就不要使用多重继承
 

 
为什么要用虚基类
 
当在多条继承路径上有一个公共的基类,在这些路径中的某几条汇合处，这个公共的基类就会产生多个实例(或多个副本)，若只想保存这个基类的一个实例，可以将这个公共基类说明为虚基类。

代码示例
 
 
 
  
 1 为什么要用虚基类的原因
 2 #include <iostream>
 3 using namespace std;
 4 class A
 5 {
 6 public:
 7     int a;
 8 public:
 9     A()
10     {
11         cout << "A()" << endl;
12     }
13     ~A()
14     {
15         cout << "~A()" << endl;
16     }
17 };
18 
19 class B1 : public A
20 {
21 
22 };
23 
24 class B2 :public A
25 {
26 
27 };
28 
29 class C :public B1, public B2
30 {
31 
32 };
33 
34 void main()
35 {
36     C c1;
37     //c1.a = 1;
38     //特定基类初始化
39     c1.B1::A::a = 10;
40     c1.B2::A::a = 100;
41     cin.get();
42 }
 
 
 
 
 
 
 
虚继承以及虚基类 
   
 
    
 1 #include <iostream>
 2 using namespace std;
 3 
 4 //虚基类
 5 class A
 6 {
 7 public:
 8     int a;
 9 public:
10     A()
11     {
12         cout << "A()" << endl;
13     }
14     ~A()
15     {
16         cout << "~A()" << endl;
17     }
18 };
19 
20 //虚继承节约内存,避免直接保护
21 class B1 :virtual public A
22 {
23 
24 };
25 
26 class B2 :virtual public A
27 {
28 
29 };
30 
31 class C :public B1, public B2
32 {
33 
34 };
35 
36 void main()
37 {
38     C c1;
39     c1.a = 10;
40     c1.B1::A::a = 3;
41     cout << c1.B1::A::a << endl;
42     cout << c1.B2::A::a << endl;
43     cin.get();
44 }
 
   
 
 
 
 
转载于:https://www.cnblogs.com/xiaochi/p/8603549.html