三种类的访问权限与继承方式 public protected private derive

首先对于 非派生的情况：

    类 访问 自身的公有成员、保护成员、私有成员，都是OK的。

    类对象 访问 自身的公有成员是OK的。

    类对象 访问 自身的保护成员是error的。

    类对象 访问 自身的私有成员是error的。

然后对于 派生的情况：

一、公有继承方式（最常用）：

public基类成员 保持 自己public访问级别，成为派生类的public成员。

protected基类成员 保持 自己的protected访问级别，成为派生类的protected成员。

private基类成员 依然是 基类自己的private成员，派生类是无法访问的。

二、私有继承方式：

public基类成员 成为 派生类的private成员。

protected基类成员 成为 派生类的private成员。

private基类成员 依然是 基类自己的private成员，派生类是无法访问的。

三、保护继承方式：

public基类成员 成为 派生类的protected成员。

protected基类成员 保持 成为 派生类的protected成员。

private基类成员 依然是 基类自己的private成员，派生类是无法访问的。

 #include<iostream>
 using namespace std;

 class base{
     public:
         base():base_pub(1),base_pro(2),base_pri(3) {}
         int base_pub;
     protected:
         int base_pro;
     private:
         int base_pri;
     public:
         int use_mypub() { return base_pub; }
         int use_myro()  { return base_pro; }
         int use_mypri() { return base_pri; }
 };

 class pub_derive : public base {
     public:
         int use_base_pub()
         {
             return base_pub;
         }
         int use_base_pro()
         {
             return base_pro;
         }
         int use_base_pri()
         {
             return 1;//base_pri;        //error
         }
         pub_derive():base() {}
 };

 class pro_derive : protected base {
     public:
         int use_base_pub()
         {
             return base_pub;
         }
         int use_base_pro()
         {
             return base_pro;
         }
         int use_base_pri()
         {
             return 1; //base_pri;   //error
         }
         pro_derive():base() {}
 };


 class pri_derive : private base {
     public:
         int use_base_pub()
         {
             return base_pub;
         }
         int use_base_pro()
         {
             return base_pro;
         }
         int use_base_pri()
         {
             return 1 ;//base_pri;  //error
         }
         pri_derive():base() {}
 };

 int main()
 {
     int a;
     base b;
     pub_derive pubd;
     pri_derive prid;
     pro_derive prod;

     //类自身的访问权限
     b.use_mypub();  //类 访问 自身的公有成员 ok
     b.use_myro();   //类 访问 自身的保护成员 ok
     b.use_mypri();  //类 访问 自身的私有成员 ok
     a = b.base_pub;     //类对象 访问 自身的公有成员 ok
     //a = b.base_pro;   //类对象 访问 自身的保护成员 error
     //a = b.base_pri;   //类对象 访问 自身的私有成员 error

     //公有继承类的访问权限
     pubd.use_base_pub();    //公有继承类 访问 基类的公有成员 ok
     pubd.use_base_pro();    //公有继承类 访问 基类的保护成员 ok
     //pubd.use_base_pri();  //公用继承类 访问 基类的私有成员 error
     a = pubd.base_pub;          //公有继承类对象 访问 基类的公有成员 ok
     //a = pubd.base_pro;        //公有继承类对象 访问 基类的保护成员 error
     //a = pubd.base_pri;        //公有继承类对象 访问 基类的私有成员 error


     //保护继承类的访问权限
     prod.use_base_pub();    //保护继承类 访问 基类的公有成员 ok
     prod.use_base_pro();    //保护继承类 访问 基类的保护成员 ok
     prod.use_base_pri();    //保护继承类 访问 基类的私有成员 error
     //a = prod.base_pub;        //保护继承类对象 访问 基类的公有成员 error
     //a = prod.base_pro;        //保护继承类对象 访问 基类的保护成员 error
     //a = prod.base_pri;        //保护继承类对象 访问 基类的私有成员 error


     //私有继承类的访问权限
     prid.use_base_pub();    //私有继承类 访问 基类的公有成员 ok
     prid.use_base_pro();    //私有继承类 访问 基类的保护成员 ok
     prid.use_base_pri();    //私有继承类 访问 基类的私有成员 error
     //a = prid.base_pub;    // 私有继承类对象 访问 基类的公有成员 error
     //a = prid.base_pro;    // 私有继承类对象 访问 基类的保护成员 error
     //a = prid.base_pri;    // 私有继承类对象 访问 基类的私有成员 error


     cout<<"OK"<<endl;
     return 1;
 }