覆盖、保护成员、派生类的构造函数、public继承的赋值兼容规则、直接基类与间接基类

覆盖、保护成员、派生类的构造函数

覆盖

派生类可以定义一个和基类成员同名的成员，这就叫覆盖。在派生类中访问这类成员时，缺省的情况是访问派生类中定义的成员。要在派生类中访问由基类定义的同名成员时，要使用作用域符号::。

//基类和派生类有同名成员的情况：
class base
{
    int j;
public:
    int i;
    void func();
};

class derived:public base
{
public:
    int i;
    void access();
    void func();
};

void derived::access()
{
    j = 5;    //错误：j是私有成员
    i = 5;    //引用的是派生类的i
    base::i = 5;  //引用的是基类的i
    func();   //派生类的
    base:func();  //基类的
}
derived obj;
obj.i = 1;
obj.base::i = 1;
//一般来说基类与派生类不定义同名成员变量。
//obj占用的存储空间：base::j、base::i、i。

类的保护成员

另一种存取权限说明符：protected
基类的practice成员，可以被下列函数访问：
1、基类的成员函数
2、基类的友元函数
基类的public成员，可以被下列函数访问：
1、基类的成员函数
2、基类的友元函数
3、派生类的成员函数
4、派生类的友元函数
5、其他函数
基类的protected成员，可以被下列函数访问：
1、基类的成员函数
2、基类的友元函数
3、派生类的成员函数可以访问当前对象的基类的保护成员

class Father
{
private:
    int nPrivate;  //私有成员
public:
    int nPublic;   //公有成员
protected:
    int nProtected; //保护成员
};

class Son :public Father
{
    void AccessFather()
    {
        nPublic = 1;       //正确
        nPrivate = 1;      //错误
        nProtected = 1;    //正确，访问从基类继承的protected成员
        Son f;
        f.nProtected = 1;  //错误，f不是当前对象
    }
};

int main()
{
    Father f;
    Son s;
    f.nPublic = 1;      //正确
    s.nPublic = 1;      //正确
    f.nProtected = 1;   //错误
    f.nPrivate = 1;     //错误
    s.nProtected = 1;   //错误
    s.nPrivate = 1;     //错误

    return 0;
}

派生类的构造函数

class Bug
{
private:
    int nLegs;
    int nColor;
public:
    int nType;
    Bug(int legs, int color);
    void PrintBug() {}
};

class FlyBug :public Bug
{
private:
    int nWings;
public:
    FlyBug(int legs, int color, int wings);
};

Bug::Bug(int legs, int color)
{
    nLegs = legs;
    nColor = color;
}

/*
//错误的FlyBug构造函数
FlyBug::FlyBug(int legs, int color, int wings)
{
    nLegs = legs;   //不能访问
    nColor = color; //不能访问
    nType = 1;      //正确
    nWings = wings;
}
*/

//正确的FlyBug构造函数
FlyBug::FlyBug(int legs, int color, int wings):Bug(legs, color)
{
    nWings = wings;
}
/*
也可以这么写
FlyBug::FlyBug(int legs, int color, int wings):Bug(legs, color), nWings(wings){}
*/

int main()
{
    FlyBug fb(2, 3, 4);
    fb.PrintBug();
    fb.nType = 1;
    fb.nLegs = 2;   //错误：nLegs是private成员

    return 0;
}

在创建派生类的对象时，需要调用基类的构造函数：初始化派生类对象中从基类继承的成员。在执行一个派生类的构造函数之前，总是先执行基类的构造函数。
调用基类构造函数的两种方式：
1、显示方式：在派生类的构造函数中，为基类的构造函数提供参数。
derived::dervied(arg_dervied-list):base(arg_base-list)
2、隐式方式：在派生类的构造函数中，省略基类构造函数时，派生类的构造函数则自动调用基类的默认构造函数。
派生类的析构函数被执行时，执行完派生类的析构函数之后，自动调用基类的析构函数。

#include <iostream>
using namespace std;

class Base
{
public:
    int n;
    Base(int i):n(i)
    {
        cout << "Base " << n << " constructed" << endl;
    }
    ~Base()
    {
        cout << "Base " << n << " destructed" << endl;
    }
};

class Derived:public Base
{
public:
    Derived(int i):Base(i)   //此处必须要用显示方式（加上初始化列表）（因为基类没有无参构造函数）
    {
        cout << "Derived constructed" << endl;
    }
    ~Derived()
    {
        cout << "Derived destructed" << endl;
    }
};

int main()
{
    Derived obj(3);

    return 0;
}
/*
输出：
Base 3 constructed
Derived constructed
Derived destructed
Base 3 destructed
*/

包含成员对象的派生类的构造函数写法

class Bug
{
private:
    int nLegs;
    int nColor;
public:
    int nType;
    Bug(int legs, int color);
    void PrintBug() {}
};

class Skill
{
public:
    Skill(int n) {}
};

class FlyBug:public Bug
{
    int nWings;
    Skill sk1, sk2;
public:
    FlyBug(int legs, int color, int wings);
};

FlyBug::FlyBug(int legs, int color, int wings):Bug(legs, color), sk1(5), sk2(color), nWings(wings) {}

在创建派生类的对象时：
1、先执行基类的构造函数，用以初始化派生类对象中从基类继承的成员。
2、再执行成员对象类的构造函数，用以初始化派生类对象中成员对象。
3、最后执行派生类自己的构造函数。
在派生类对象消亡时：
1、先执行派生类自己的析构函数。
2、再依次执行各成员对象类的析构函数。
3、最后执行基类的析构函数。
析构函数的调用顺序与构造函数的调用顺序相反。

public继承的赋值兼容规则

class base{};
class derived:public base{};
base b;
derived d;

//1)派生类的对象可以赋值给基类对象
b = d;  //反过来不行

//2)派生类对象可以初始化基类引用  
base &br = d;

//3)派生类对象的地址可以赋值给基类指针
base *pb = &d;
//⚠️注意：如果派生方式是private或protected，则上述三条不可行。

直接基类与间接基类

1、类A派生类B，类B派生类C，类C派生类D,…
-类A是类B的直接基类
-类B是类C的直接基类，类A是类C的间接基类
-类C是类D的直接基类，类A、B是类D间接基类
2、声明类时，只需要列出它的直接基类
派生类沿着类的层次自动向上继承它的间接基类
派生类的成员包括：派生类自己定义的成员、直接基类中的所有成员、所有间接基类的全部成员

#include <iostream>
using namespace std;

class Base
{
public:
    int n;
    Base(int i):n(i)
    {
        cout << "Base " << n << " constructed" << endl;
    }
    ~Base()
    {
        cout << "Base " << n << " destructed" << endl;
    }
};

class Derived:public Base
{
public:
    Derived(int i):Base(i)   //此处必须要用显示方式（加上初始化列表）（因为基类没有无参构造函数）
    {
        cout << "Derived constructed" << endl;
    }
    ~Derived()
    {
        cout << "Derived destructed" << endl;
    }
};

class MoreDerived:public Derived
{
public:
    MoreDerived():Derived(4)   //此处必须要用显示方式（加上初始化列表）（因为基类没有无参构造函数）
    {
        cout << "MoreDerived constructed" << endl;
    }
    ~MoreDerived()
    {
        cout << "MoreDerived destructed" << endl;
    }
};

int main()
{
    MoreDerived obj;

    return 0;
}
/*
输出：
Base 4 constructed
Derived constructed
MoreDerived constructed
MoreDerived destructed
Derived destructed
Base 4 destructed
*/