C++（继承与派生，虚基类，作用域标识符）

类的继承与派生：

继承关系与派生类：

     类的继承，是新的类从以后类那里继承已有的特性，从已有类产生新类的过程就是类的派生，新类产生后，就具备了已有类的特征，原有的类叫做基类，产生的新类叫做派生类。

语法形式：

class派生类名:继承方式―基类名1,继承方式―基类名2,…,继承方式―基类名n(
    派生类成员声明;
};

   一个派生类，可以同时有多个基类，这种情况成为多继承，同理，只有一个基类成为单继承

class Derived: public Base1, private Base2
{
public:
    Derived();
    ~Derived();
};

      在类族中,直接参与派生出某类的基类称为直接基类，基类的基类甚至更高层的基类称为间接基类。比如由“交通工具”类派生出“汽车”类，“汽车”类又派生出“卡车”类,则“汽车”类是“卡车”类的直接基类，“交通工具”类是“汽车”类的直接基类,而“交通工具”类可以称为“卡车”类的间接基类。

     此外，在派生类的定义中，我们除了要制定基类之外，还要制定继承方式，继承方式规定了派生类如何访问基类的成员。继承方式关键字有：public（公有），private（私有），protected（保护）（在访问控制中讨论），如果不显式的、给出继承方式关键字，默认为private。

派生类形成过程：

3个步骤：吸收基类成员-->改造基类成员-->添加派生类成员

1.吸收基类成员

      派生类会把基类中的成员全部吸收（构造，析构，静态成员除外）

2.改造基类成员

      如果派生类声明了一个与基类成员同名的新成员，则会隐藏基类成员（函数要求同名同参，同名不同参属于重载）

3.添加新的成员

     其实就是在第二部基础上加入其他的派生类成员

     由此我们可以得到一个派生类对象占内存大小=基类成员变量大小+派生类成员变量大小，且顺序是基类成员在前，派生类成员变量在后（后续内存兼容性规则介绍）

访问控制：

public（公有继承）：

    基类的公有成员和保护成员属性不变，但是私有成员不可访问，public也是最常用的继承方式，也就是啥属性都没变

private（私有继承）：

   当使用private继承后，基类的所有成员（private，public，protected）全部变为私有属性，也就是说此时如果想在类外调用基类成员，只能通过该类的函数接口来访问基类，否则无法访问，这种方式的作用为在写好这个类之后，不允许别人继续来继续继承这个类（无法访问）

protect（保护继承）：

    保护继承中，基类的公有成员与保护成员都以保护成员的形式出现在派生类中，一旦被设置为保护后，该成员只能在类内访问，类外不可访问，这也是保护继承和公有继承的区别

总结：

           以下是由三种不同继承方式产生派生类后，此时基类访问权限（也就是类内不同关键字（private，public，protected）修饰的成员）的变化

继承方式\访问级别	public权限	protected权限	private权限
public继承	public	protected	private
private继承	private	private	private
protected继承	protected	protected	private

类型兼容规则：

 类型兼容规则是指在需要基类对象的任何地方,都可以使用公有派生类的对象来替代。

 在替代之后,派生类对象就可以作为基类的对象使用,但只能使用从基类继承的成员：

        1.派生类的对象可以隐含转换为基类对象。

        2.派生类的对象可以初始化基类的引用。

        3.派生类的指针可以隐含转换为基类的指针。

派生类的构造与析构函数

构造函数：

        由于派生类的成员对象是由所有基类的成员对象与派生类新增的成员对象共同组成。因此构造派生类的对象时,就要对基类的成员对象和新增的派生类成员对象进行初始化。

        如果对基类初始化时,需要调用基类的带有形参表的构造函数时,派生类就必须声明构造函数,提供一个将参数传递给基类对象。

# include <iostream>
using namespace std;
class Base1 
{
    //基类Base1,构造函数有参数
public:
    Base1(int i) {cout<< "Constructing Basel "<<i<<endl; }
};
class Base2 {
    //基类Base2,构造函数有参数
public:
    Base2(int j) { cout<< "Constructing Base2 "<<j<<endl; }
};
class Base3 {
    //基类Base3,构造函数无参数
public:
    Base3 ( ){cout<< "Constructing Base3 * "<<endl; }
} ;
class Derived: public Base2,public Base1,public Base3 
{//派生新类Derived,注意基类名的顺序
    public;
    //派生类的公有成员
    Derived(int a，int b,int c,int d) : Base1(a),menber2(d),menber1(c)，Base2 (b){ }
    //注意基类名的个数与顺序,注意成员对象名的个数与顺序private:
    //派生类的私有成员对象
    Basel member1;
    Base2 member2;Base3 member3;
};
int main () {
    Derived obj (1,2，3,4);
    return 0;
}

    运行结果：    

Constructing Base2 2
Constructing Base1 1
Constructing Base3 *
Constructing Base1 3
Constructing Base2 4
Constructing Base3 *

        Derived类构造函数的执行情况：它应该是先调用基类的构造函数,然后调用内嵌对象的构造函数。基类构造函数的调用顺序是按照派生类定义的顺序,因此应该是先Base2,再Base1,最后Base3;而内嵌对象的构造函数调用顺序应该是按照成员在类中声明的顺序,应该是先 Base1,再Base2,最后Base3。程序运行的结果也完全证实了这种分析。

复制构造函数：

        在没有编写复制构造函数时，编译系统会在必要时自动生成一个隐含的复制构造函数﹐这个隐含的复制构造函数会自动调用基类的复制构造函数﹐然后对派生类新增的成员对象一一执行。

假设 Derived类是Base类的派生类，v是一个Derived类的对象

Derived: : Derived (const Derived &v) : Base (v) {…}

        这里使用Derived类对象的引用v作为参数，由于类型兼容规则的存在:可以用派生类的对象去初始化基类的引用。因此当函数的形参是基类的引用时,实参可以是派生类的对象。

析构函数

        在派生过程中,基类的析构函数也不能继承下来，如果需要析构的话﹐就要在派生类中声明新的析构函数。

        与构造函数相似，派生类析构函数会自动调用基类的构造函数，但是它的执行次序和构造函数正好完全相反，首先执行析构函数的函数体,然后对派生类新增的类类型的成员对象进行清理,最后对所有从基类继承来的成员进行清理。

# include <iostream>
using namespace std;
class Base1 
{
    //基类Base1,构造函数有参数
public:
    Base1(int i) {cout<< "Constructing Basel "<<i<<endl; }
    ~Base1 (){cout<<"Destructing Base1"<<endl ; }
};
class Base2 {
    //基类Base2,构造函数有参数
public:
    Base2(int j) { cout<< "Constructing Base2 "<<j<<endl; }
    ~Base2 (){cout<<"Destructing Base2"<<endl ; }
};
class Base3 {
    //基类Base3,构造函数无参数
public:
    Base3 ( ){cout<< "Constructing Base3 * "<<endl; }
    ~Base3 (){cout<<"Destructing Base3"<<endl ; }
} ;
class Derived: public Base2,public Base1,public Base3 
{//派生新类Derived,注意基类名的顺序
    public;
    //派生类的公有成员
    Derived(int a，int b,int c,int d) : Base1(a),menber2(d),menber1(c)，Base2 (b){ }
    //注意基类名的个数与顺序,注意成员对象名的个数与顺序private:
    //派生类的私有成员对象
    Basel member1;
    Base2 member2;Base3 member3;
};
int main () {
    Derived obj (1,2，3,4);
    return 0;
}

运行结果：

Constructing Base2 2
constructing Base1 1
constructing Base3 *
Constructing Basel 3
Constructing Base2 4
Constructing Base3 *
Destructing Base3
Destructing Base2
Destructing Base1
Destructing Base3
Destructing Base1
Destructing Base2

派生类成员的标识与访问

        (1）不可访问的成员：派生类及继续派生的新类均无法访问
        (2）私有成员：派生类内部可以访问,但是建立派生类对象的模块中无法访问,继续派生,就变成了新的派生类中的不可访问成员。
        (3）保护成员：派生类内部成员可以访问，建立派生类对象的模块无法访问,进一步派生,在新的派生类中可能成为私有成员或者保护成员。
        (4）公有成员。派生类、建立派生类的模块都可以访问,继续派生,可能是新派生类中的私有﹑保护或者公有成员。

作用域分辨符

        一般使用形式：类名::成员名（参数表）

        如果派生类中声明了与基类成员函数同名的新函数,即使函数的参数表不同,从基类继承的同名函数的所有重载形式也都会被隐藏（类似于局部变量隐藏全局变量）。

        如果某派生类的多个基类拥有同名的成员,同时,派生类又新增这样的同名成员,在这种情况下,派生类成员将隐藏所有基类的同名成员，此时只能使用：基类名::成员，这种方式来访问

虚基类：

        多继承中，当某类的部分或全部直接基类是从另一个共同基类派生而来时,在这些直接基类中从上一级共同基类继承来的成员就拥有相同的名称。

        在派生类的对象中,这些同名数据成员在内存中同时拥有多个副本,同一个函数名会有多个映射。

        此时可以使用上一章节介绍的作用域分辨符来唯一标识并分别访问它们，也可以将共同基类设置为虚基类，这时从不同的路径继承过来的同名数据成员在内存中就只有一个副本,同一个函数名也只有一个映射。这样就解决了同名成员的唯一标识问题。因此虚基类解决了多重映射问题

语法形式：class  派生类名  :  virtual  继承方式  基类名

虚基类及派生类构造函数

        直接或间接继承虚基类的所有派生类都必须列出对虚基类的初始化

#include <iostream>
using namespace std;
class Base0{
public:
    //外部接口
    Baseo (int var) : var0 (var) {}
    int var0;
    void fun0 ()  {cout<<"Member of Baseo"<<endl; }
};

class Basel : virtual public Base0 {
    //Base0为虚基类,派生Base1类
public:
//新增外部接口
    Basel (int var) : Base0 (var) {}
    int var1;
};

class Base2 : virtual public Base0 {
//Base0为虚基类,派生 Base2类
public:
    //新增外部接口
    Base2(int var) : Base0 (var){ 
    int var2;
};

class Derived: public Base1, public Base2 {
//派生类Derived定义
public:
    //新增外部接口
    Derived (int var) : Base0 (var), Base1 (var),Base2(var) [ }
    int var;
    void fun () {cout<<""Member of Derived"<<endl ; }
};

int main () 
{
    //程序主函数
    Derived d(1);
    //定义Derived类对象d
    d.var= 2;
    d.fun ();return 0;
}