21-【每天亿点点C++,简单又有趣儿】继承 ------ 管你看没看懂，跑就完事了

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

/*继承基础*/
class BasePage
{
    public:
    void header()
    {
        cout << "首页、公开课、登陆、注册" << endl;
    }
    void footer()
    {
        cout << "帮助" << endl;
    }
    void left()
    {
        cout << "左侧列表 Java C++ Python" << endl;
    }

};
class Java:public BasePage
{
public:
    void content()
    {
        cout << "Java 视频" << endl;
    }
};
class CJa:public BasePage
{
public:
    void content()
    {
        cout << "C++ 视频" << endl;
    }
};
class Python:public BasePage
{
public:
    void content()
    {
        cout << "Python 视频" << endl;
    }
};


void test_26()
{
        cout << "   Java 页面   " << endl;
    Java java;
    java.header();
    java.footer();
    java.left();
    java.content();
    cout << "-----------------" << endl;

    cout << "   C++ 页面   " << endl;
    CJa cJa;
    cJa.header();
    cJa.footer();
    cJa.left();
    cJa.content();
    cout << "-----------------" << endl;

    cout << "   Python 页面   " << endl;
    Python py;
    py.header();
    py.footer();
    py.left();
    py.content();
    cout << "-----------------" << endl;
    }








/*继承方式*/
class BaBa
{
public:
    int a;
protected:
    int b;
private:
    int c;
};
class PublicSon:public BaBa
{
public:
    int f;

};






/*继承的对象模型*/
class BaseB
{
public:
    int a;
protected:
    int b;
private:
    int c;
};
class Sonn:public BaseB
{
public:
    int d;
};

void test_27()
{
    //父类中所有非静态成员属性都会被继承，虽然访问不到，因为编译器隐藏了
    cout << "内存占用：" << sizeof(Sonn) <<endl;
    //利用开发人员命令提示工具查看类布局 #　cl /d1 reportSingleClassLayoutSonn "xxxx.cpp"
}






/*继承中的构造和析构的顺序*/

class Fulei
{
public:
    Fulei()
    {
        cout << "Fulei的构造函数" << endl;
    }
    ~Fulei()
    {
        cout << "Fulei的析构函数" << endl;
    }
};

class Er:public Fulei
{
public:
    Er()
    {
        cout << "Er的构造函数" << endl;
    }
    ~Er()
    {
        cout << "Er的析构函数" << endl;
    }
};
void test_28()
{
    Er err; //创建子时先创建父类
    //Fulei的构造函数
    //Er的构造函数
    //Er的析构函数
    //Fulei的析构函数
}






/*父子同名成员*/
// 访问子类重名成员 直接访问即可
// 访问父类重名成员 需要加作用域

class BaseF
{
public:
    BaseF()
    {
        m_A = 100;
    }
    void func()
    {
        cout << "Base func" << endl;
    }
    void func(int a)
    {
        cout << "Base func a="<< a << endl;
    }
    int m_A;
};
class SonF:public BaseF
{
public:
    SonF()
    {
        m_A = 200;
    }
    void func()
    {
        cout << "Son func" << endl;
    }

    int m_A;
};

void test_29()
{
    // 同名成员属性，不同名
    SonF son;
    cout << "son.m_A = " << son.m_A << endl;
    cout << "base下.m_A = " << son.BaseF::m_A << endl; //加作用域

    //同名函数
    son.func();
    son.BaseF::func(); //加所作用于
    //错 son.func(100);// 如果子类中出现和父类中的同名函数的成员函数,编译器全部隐藏，全部需要加作用域
    son.BaseF::func(100);
}



/*继承中的静态成员*/
// 访问子类重名成员 直接访问即可
// 访问父类重名成员 需要加作用域

class BaseG
{
public:

    static int m_A;
    static void func()
    {
        cout << "Base static func" << endl;
    }
    static void func(int a)
    {
        cout << "Base static func a="<< a << endl;
    }
};
int BaseG::m_A = 100;
class SonG:public BaseG
{
public:
    static int m_A;
    static void func()
    {
        cout << "Son static func" << endl;
    }

};
int SonG::m_A = 200;
void test_30()
{
    cout << "通过对象的方式访问" << endl;
    SonG son;
    cout << "son 下 m_A = " << son.m_A << endl;
    cout << "Base 下 m_A = " << son.BaseG::m_A << endl;
    cout << "通过类名的方式访问" << endl;
    cout << "son 下 m_A = " << SonG::m_A << endl;
    cout << "Base 下 m_A = " << SonG::BaseG::m_A << endl; //第一个:: 代表通过类名的方式访问，第二个:: 代表访问父下作用域

    // 通过对象访问
    son.func();
    son.BaseG::func();
    //通过类名访问
    SonG::func();
    SonG::BaseG::func();
    //重载的静态函数
    SonG::BaseG::func(100);//加作用域
}



/*多继承*/
class Base01
{
public:
    Base01()
    {
        a = 100;
    }
    int a;
};
class Base02
{
public:
    Base02()
    {
        a = 234;
        b = 200;
    }
    int b;
    int a;
};
// 语法：子类：继承方式 父1，继承方式 父2，...
class Son00 :public Base01, public Base02
{
public:
    Son00()
    {
        c = 1;
        d = 2;
    }
    int c;
    int d;

};

void test_31()
{
    Son00 s;
    cout << "size Son00 : " << sizeof(s) <<endl;
    cout << "b = " << s.b <<endl;
    cout << "Base01 a = " << s.Base01::a <<endl; // 加作用域
    cout << "Base02 a = " << s.Base02::a <<endl; // 加作用域
}





/*菱形继承*/
//  【动物】
//   /    \
//【羊】【驼】
//   \    /
//  【羊驼】

class Animal
{
public:
    int m_age;
};
class Sheep:virtual public Animal //Animal虚基类
{

};
class Tuo:virtual public Animal //Animal虚基类
{

};
class YTuo:public Tuo,public Sheep
{

};
void test_32()
{
    YTuo yt;
    yt.Sheep::m_age = 18;
    yt.Tuo::m_age = 28;
    cout << "羊驼A  Sheep::m_age = " << yt.Sheep::m_age << endl;
    cout << "羊驼A    Tuo::m_age = " << yt.Tuo::m_age << endl;
    // 只有一份即可，有两份就浪费=》虚继承  语法：继承前加virtual 修饰后就是虚基类
    cout << "羊驼A         m_age = " << yt.m_age << endl;
    // 底层 其实是继承指针，指针都指向一个虚基类的age ,实质上只有一个age
}
int main()
{
    test_26();/*继承基础*/
    test_27();/*继承的对象模型*/
    test_28();/*继承中的构造和析构的顺序*/
    test_29();/*父子同名成员*/
    test_30();/*继承中的静态成员*/
    test_31();/*多继承*/ //(避免使用)
    test_32();/*菱形继承*/
}