继承的方式

#include<iostream>
//#include<memory>
using namespace std;

class Parent
{
public://访问控制权限
    int pub;//在类的内部和外部都能访问
protected:
    int pro;//在类的内部可以访问，在类的外部不能访问
private:
    int pri;//在类的内部可以访问，在类的外部不能访问，
            //在单个类中和protected一样
};

//规则1：只要是父类中的private成员，不管是什么方式，儿子都访问不了
//规则2：如果是公有（public）继承，儿子中的访问控制权限保持不变
//规则3：如果是保护（protected）继承，儿子中的父亲中除了private成员，其余都是protected
//规则4：如果是私有（private）继承，儿子中的父亲中除了private成员，其余在儿子中都是protected
//公有继承
class Child :public Parent//继承方式：公有继承
{
public:
    void func()
    {
        cout << pub << endl;//pub父类的public成员变量，
           //在public继承后，在子类【内部外部】都可以访问

        cout << pro << endl;//pro父类的public成员变量，
          //在public继承后，在子类【内部】可以访问，【外部】不可访问
         //该类的儿子可以访问

        //cout << pri << endl;//pri父类的public成员变量，
                //在public继承后，在子类【内部外 部】都不可以访问
    }
};
//保护继承
class Child2 :protected Parent
{
public: 
    void func2()
    {
        pub;//此时pub通过protected继承，能够在类的内部访问,
           //类的外部不能访问，类的儿子可以访问，pub就是protected成员
        pro;//pro 与 pub是一样的性质
        //pri;//在子类【内部外 部】都不可以访问
    }
};

class Child3 :private Parent
{
public: 
    void func3()
    {
        pub;//pub在类的内部可以访问，在类的外部不可以访问
           //pub在该类的儿子中访问不了，说明pub在Child3中是私有成员
        pro;//pro 与 pub性质一样，也是私有成员
        //pri;//不可见
    }
};

//三看原则：
//1.看调用的成员是在类的外部还是类的内部
//2.看儿子的继承方式
//3.当前变量在儿子中的变量在父类中的de访问控制权限

//一般都是使用公有继承
int main()
{
    Child c1;
    c1.func();
    c1.pub;
    //c1.pro;
    return 0;
}

继承方式的练习

#include<iostream>
using namespace std;

class A
{
public:
    int c;
    A()
    {
        a = 0;
        b = 0;
        c = 0;
    }
    void set()
    {
        this->a = a;
        this->b = b;
        this->c = c;
    }

protected:
    int b;
private:
    int a; 

};

class B :public A
{
public:
    void print()
    {
         //cout << "a = " << a;//a是父类私有成员，不可访问
         cout << "b = " << b;//b此时是该类的保护成员，可以在类的内部访问
         cout << " c = " << c << endl;//此时c是该类的公有成员，类的内部可以访问
    }
};

class C :protected A
{
public:
    void print()
    {
        //cout << "a = " << a;//a是父类私有成员，不可访问
        cout << "b = " << b;//b此时是该类的保护成员，可以在类的内部访问
        cout << " c = " << c << endl;//此时c是该类的保护成员，类的内部可以访问
    }
};


class D :private A
{
public:
    void print()
    {
        // cout << "a = " << a;//a是父类私有成员，不可访问
         cout << "b = " << b;//b此时是该类的私有成员，可以在类的内部访问
          cout << " c = " << c << endl;//c此时是该类的私有成员，可以在类的内部访问
    }
};
int main()
{
     A aa;
     B bb;
     C cc;
     D dd;

     aa.c =100;//c在A类中是公有，类的外部可以访问。
     bb.c = 100;//c在B类中是公有，类的外部可以访问。
    // cc.c = 100;//c在C类中是保护，类的外部不可以访问。
    // dd.c = 100;//c在D类中是私有，类的外部不可以访问。
     aa.set();//set方法在A类中是公有方法，类的外部可以访问
     bb.set();//set方法在B类中是公有方法，类的外部可以访问
    //cc.set();//set方法在C类中是保护方法，类的外部不可以访问
    // dd.set();//set方法在A类中是私有方法，类的外部不可以访问

     bb.print();//print是定义在B类的public成员函数，在类的外部可以访问
     cc.print();//print是定义在C类的public成员函数，在类的外部可以访问
     dd.print();//print是定义在D类的public成员函数，在类的外部可以访问
    return 0;
}

总结：

规则1：只要是父类中的private成员，不管是什么方式，儿子都访问不了
规则2：如果是公有（public）继承，儿子中的访问控制权限保持不变
规则3：如果是保护（protected）继承，儿子中的父亲中除了private成员，其余都是protected
规则4：如果是私有（private）继承，儿子中的父亲中除了private成员，其余在儿子中都是private成员