继承和派生

基类和派生类

class Student                             //基类
{
    //...
};

class CollegeStudent : public Student    //大学生是学生的派生类
{
    //...   
};

派生类对于基类继承提供了代码的重用性。派生类的增加部分提供了对原有代码扩充和改进的能力。

继承的特点：

• 一个派生类可以有一个或多个基类，只有一个基类时叫单继承（每个类可以有多个派生类，但最多有一个基类），有多个基类时叫多继承。
• 继承关系可以是多级的，即类Y继承类X，类Z继承类Y同时存在。
• 不允许继承循环，即不允许类A继承类B，类B继承类C，类C继承类A同时存在。
• 基类中能够被继承的部分只能是公有成员和保护成员，私有成员不能被继承。

根据继承关键字不同，其继承的方式也不同：

• public：        表示公有基类               基类的公有成员    =>    派生类的公有成员  ||  基类的保护成员    =>    派生类的保护成员
• private：      表示私有基类                基类的公有成员和保护成员    =>    派生类的私有成员
• protected：  表示保护基类                基类的公有成员和保护成员    =>    派生类的保护成员

当基类和派生类中的函数重名时，为了能够在派生类中仍然能调用基类中的函数，可以用 :: 运算符进行调用。

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

class B : public A
{
public:
    void fun();
    void g()
    {
        fun();        //类B中的fun()
        A::fun();     //类A中的fun()
    }
};

派生类的构造函数和析构函数

派生类不能继承基类的构造函数和析构函数，但可以在创建派生类对象时，调用基类的构造函数来初始化基类的数据成员。构造函数的调用时先基类后派生类。同样，析构函数的调用顺序与构造函数相反。

派生类构造函数的一般格式为：

派生类名 (派生类参数) : 基类构造函数 (参数表) ，子对象名 (参数表)
{
    派生类数据成员初始化;
}

派生类构造函数的调用顺序：（先基类后派生类）

• 基类的构造函数是按继承声明的顺序进行调用的。
• 调用子对象构造函数时，是按着在类中声明的顺序进行调用的。
• 派生类构造函数体内的语句也是按着声明时的顺序执行的。

派生类在创建对象时，系统将自动调用其构造函数，以及其基类的构造函数。如果派生类的基类无构造函数或构造函数无参数，则派生类可以定义或不定义构造函数。如果派生类的基类有构造函数，并且构造函数有参数，则派生类必须定义构造函数，并且要通过定义的构造函数将参数传递给基类的构造函数。

class A
{
    int num;
    float grade;
public:
    A(int n,float v) : num(n),grade(v)           //带参数构造函数
    {    cout<<"the A initialized"<<endl;    }
};
class B : public A                 //在调用B的对象时，从基类开始初始化，因此先调用基类构造函数
{
    int num;
    float grade;
public:
    B(void) : A(10000,0)                         //无参数构造函数，要为基类的构造函数设置参数
    {    cout<<"the B initialized"<<endl;    }
    B(int n, float x, double dx) : A(n, x)       //带参数构造函数，要为基类的构造函数设置参数
    {    cout<<"the B initialized"<<endl;    }
};

继承的二义性

class A
{
public:
    void f();
};

class B
{
public:
    void g();
    void f();
};
class C ：public A,public B
{
public:
    void h();
    f();
};

在这里调用函数 f() 就产生了二义性，因为不能明确调用的是类A中的 f() 还是类B中的，我们可以通过在类C中重新定义一个新的 f()，即 void f(); 的方式消除二义性。函数的实现如下：

void C::f()
{
    A::f();
}

虚基类（virtual）

如果一个派生类从多个基类派生，而这些基类又有一个共同的基类，则在对该基类中声明的名字进行访问时，可能产生二义性。因此我们使用虚基类来使公共基类在派生类中只产生一个子对象，此时不管从哪条路径去访问公共基类的子对象时，都是访问的一个子对象，这样就不会产生二义性。

class B
{
public:
    int b;
};

class B1 ： virtual public B
{
public:
    int b1;
};

class B2 ： virtual public B
{
public:
    int b2;
};

class C ： public B1,public B2
{
private:
    int c;
};

void main()
{
    C cc;
    cc.b;
}