继承
1）继承是面向对象程序设计实现软件重用的重要方法。程序猿能够在已有基类的基础上定义新的派生类。
2） 单继承的派生类仅仅有一个基类。多继承的派生类有多个基类。

3） 派生类对基类成员的訪问由继承方式和成员性质决定。

4） 创建派生类对象时，先调用基类构造函数初始化派生类中的基类成员。调用析构函数的次序和调用构造函数的次序相反。
5）C++提供虚继承机制，防止类继承关系中成员訪问的二义性。
6） 多继承提供了软件重用的强大功能。也添加了程序的复杂性。

派生类类成员訪问级别
1、须要被外界訪问的成员直接设置为public
2、仅仅能在当前类中訪问的成员设置为private
3、仅仅能在当前类和子类中訪问的成员设置为protected。protected成员的訪问权限介于public和private之间。

//类的继承方式对子类对外訪问属性影响

#include <cstdlib>
#include <iostream>

using namespace std;

class A
{
private:
    int a;
protected:
    int b;
public:
    int c;

    A()
    {
        a = 0;
        b = 0;
        c = 0;
    }

    void set(int a, int b, int c)
    {
        this->a = a;
        this->b = b;
        this->c = c;
    }
};

class B : public A
{
public:
    void print()
    {
        //cout<<"a = "<<a; //err
        cout<<"b = "<<b;
        cout<<"c = "<<endl;
    }
};

class C : protected A
{
public:
    void print()
    {
        //cout<<"a = "<<a; //err
        cout<<"b = "<<b;
        cout<<"c = "<<endl;
    }
};

class D : private A
{
public:
    void print()
    {
        //cout<<"a = "<<a; //err
        cout<<"b = "<<b<<endl; 
        cout<<"c = "<<c<<endl; 
    }
};

int main_01(int argc, char *argv[])
{
    A aa;
    B bb;
    C cc;
    D dd;

    aa.c = 100; //ok
    bb.c = 100; //ok
    //cc.c = 100; //err 类的外部是什么含义
    //dd.c = 100; //err

    aa.set(1, 2, 3);
    bb.set(10, 20, 30);
    //cc.set(40, 50, 60); //ee
    //dd.set(70, 80, 90); //ee

    bb.print();
    cc.print();
    dd.print();

    system("pause");
    return 0;
}

类型兼容性原则
子类对象能够当作父类对象使用
子类对象能够直接赋值给父类对象
子类对象能够直接初始化父类对象
父类指针能够直接指向子类对象
父类引用能够直接引用子类对象

#include <cstdlib>
#include <iostream>

using namespace std;

//子类就是特殊的父类
class Parent03
{
protected:
    const char* name;
public:
    Parent03()
    {
        name = "Parent03";
    }

    void print()
    {
        cout<<"Name: "<<name<<endl;
    }
};

class Child03 : public Parent03
{
protected:
    int i;
public:
    Child03(int i)
    {
        this->name = "Child2";
        this->i = i;
    }
};

int main()
{
    Child03 child03(1000);
    //分别定义父类对象 父类指针 父类引用 child
    Parent03 parent = child03;
    Parent03* pp = &child03;
    Parent03& rp = child03;

    parent.print();
    pp->print();
    rp.print();
    system("pause");
    return 0;
}

继承中构造和析构
在子类对象构造时。须要调用父类构造函数对其继承得来的成员进行初始化
在子类对象析构时。须要调用父类析构函数对其继承得来的成员进行清理

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

class Parent04
{
public:
    Parent04(const char* s)
    {
        cout<<"Parent04()"<<" "<<s<<endl;
    }

    ~Parent04()
    {
        cout<<"~Parent04()"<<endl;
    }
};

class Child04 : public Parent04
{
public:
    Child04() : Parent04("Parameter from Child!")
    {
        cout<<"Child04()"<<endl;
    }

    ~Child04()
    {
        cout<<"~Child04()"<<endl;
    }
};

void run04()
{
    Child04 child;
}

int main_04(int argc, char *argv[])
{
    run04();

    system("pause");
    return 0;
}

1、子类对象在创建时会首先调用父类的构造函数
2、父类构造函数运行结束后，运行子类的构造函数
3、当父类的构造函数有參数时，须要在子类的初始化列表中显示调用
4、析构函数调用的先后顺序与构造函数相反

继承中的同名成员变量
1、当子类成员变量与父类成员变量同名时
2、子类依旧从父类继承同名成员
3、在子类中通过作用域分辨符::进行同名成员区分（在派生类中使用基类的同名成员，显式地使用类名限定符）
4、同名成员存储在内存中的不同位置