C++ 继承方式 继承同名成员处理 继承中的同名静态成员处理方式 多继承语法（认多个爹） 菱形继承

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

 //继承方式

//公共继承
class Basel 
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son1 : public Basel
{
public:
    void func()
    {
        m_A = 10; //父类中的公共权限成员 到子类中依然是公共权限
        m_B = 10; //父类中的保护权限成员 到子类中依然是保护权限
        //m_C = 10; //父类中的私有权限成员 子类访问不到

    }
};

void test01()
{
    Son1 s1;
    s1.m_A = 100;
    //s1.m_B = 100; 到Son1中 m_B是保护权限 类外访问不到
}


//保护继承

class Base2
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son2 :protected Base2
{
public:
    void func()
    {
        m_A = 100; //父类中公共成员，到子类中变为保护权限
        m_B = 100; //父类中保护成员，到子类中变为保护权限
        //m_C = 100; 父类中私有成员 子类访问不到
    }
};

void test02()
{
    Son2 s1;
    //s1.m_A = 1000; 在Son2中m_A变为保护权限，因此类外访问不到
    //s1.m_B = 1000; 在Son2中 m_B变为保护权限 不可以访问
}

//私有继承
class Base3
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son3 :private Base3
{
public:
    void func()
    {
        m_A = 100;//父类中公共成员 到子类中变为 私有成员
        m_B = 100;//父类中保护成员 到子类中变为 私有成员
        //m_C = 100; //父类中私有成员 到子类中访问不到

    }
};

void test03()
{
    Son3 s1;
    s1.m_A = 100;//到Son3中变为私有成员 类外成员访问不到
}



int main()
{
    test01();
    
    system("pause");
    return 0;

}

 

同名成员处理

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

//继承中同名成员处理
class Base
{
public:
    Base()
    {
        m_A = 100;
    }
    void func()
    {
        cout << "Base - func()调用 " << endl;
    }


    void func(int a)
    {
        cout << "Base - func(int a)调用 " << endl;
    }

    int m_A;
};

class Son :public Base
{
public:
    Son()
    {
        m_A = 200;
    }

    void func()
    {
        cout << "Son - func()调用 " << endl;
    }

    int m_A;
};

//同名属性处理方式
void test01()
{
    Son s;
    cout << "Son 下 m_A = " << s.m_A << endl;
    //如果通过子类对象 访问到父类中同名成员，需要加作用域
    cout << "Base 下 m_A = " << s.Base::m_A << endl;
}

//同名成员函数处理方式
void test02()
{
    Son s;
    s.func();//直接调用 调用是子类中的同名成员


    //如何调用到父类中同名成员函数？
    s.Base::func();

    //如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
    //如果想访问到父类中被隐藏的同名成员函数，需加作用域
    s.Base::func(100);

}

int main()
{
    //test01();
    test02();
    
    system("pause");
    return 0;

}

 继承中的同名静态成员处理方式

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

//继承中的同名静态成员处理方式

class Base
{
public:
    static  int m_A;

    static void func()
    {
        cout << "Base - static void func()" << endl;
    }

    static void func(int a)
    {
        cout << "Base - static void func()" << endl;
    }
};
int Base::m_A = 100;

class Son :public Base
{
public:
    static  int m_A;

    static void func()
    {
        cout << "Son - static void func()" << endl;
    }
};
int Son::m_A = 200;


//同名静态成员属性
void test01()
{
    //1、通过对象访问
    cout << "通过对象访问" << endl;
    Son s;
    cout << "Son 下 m_A = " << s.m_A << endl;
    cout << "Base 下 m_A = " << s.Base::m_A << endl;

    //2、通过类名访问
    cout << "通过类名访问" << endl;
    cout << "Son 下 m_A = " << Son::m_A << endl;
    //第一个::代表通过类名方式访问  第二个::代表访问父类作用域下
    cout << "Base 下 m_A = " << Son::Base::m_A << endl;

}

//同名静态成员函数
void test02()
{
    //1、通过对象访问
    cout << "通过对象访问" << endl;
    Son s;
    s.func();
    s.Base::func();


    //2、通过类名访问
    cout << "通过类名访问" << endl;
    Son::func();
    Son::Base::func();

    //子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
    //如果想访问父类中被隐藏同名成员，需要加作用域
    Son::Base::func(100);
}


int main()
{
    //test01();
    test02();
    
    system("pause");
    return 0;

}

 多继承语法（认多个爹）

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

//多继承语法（认多个爹）


//父类
class Base1
{
public:
    Base1()
    {
        m_A = 100;
    }
    int m_A;
};


class Base2
{
public:
    Base2()
    {
        m_A = 200;
    }
    int m_A;
};


//子类 需要继承Base1和Base2
//语法：class 子类： 继承方式 父类1， 继承方式 父类2 ...
class Son :public Base1, public Base2
{
public:
    Son()
    {
        m_C = 300;
        m_D = 400;
    }
    int m_C;
    int m_D;
};

void test01()
{
    Son s;
    cout << "sizeof Son = " << sizeof(s) << endl;
    //当父类中出现同名成员，需要加作用域区分
    cout << "Base1::m_A = " << s.Base1::m_A << endl;
    cout << "Base1::m_A = " << s.Base2::m_A << endl;
}

int main()
{
    test01();
    //test02();
    
    system("pause");
    return 0;

}

 菱形继承

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

//菱形继承

//动物类
class Animal 
{
public:
    int m_Age;
};

//利用虚继承 解决菱形继承的问题
//在继承之前加上关键字 virtual 变为虚继承
// Animal 类成为 虚基类

//羊类
class Sheep :virtual public Animal {};

//驼类
class Tuo :virtual public Animal{};

//羊驼类
class SheepTuo : public Sheep, public Tuo {};

void test01()
{
    SheepTuo st;
    st.Sheep::m_Age = 18; 
    st.Tuo::m_Age = 28;
    //当菱形继承，两个父类拥有相同的数据，需要加以作用域区分
    cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
    cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
    cout << "st.m_Age = " << st.m_Age << endl;

    //这份数据我们知道 只有一份就可以，菱形继承导致数据有两份，资源浪费
}

int main()
{
    test01();
    //test02();
    
    system("pause");
    return 0;

}