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

来源：互联网发布：国内erp软件排名编辑：程序博客网时间：2024/05/17 06:47

首先对于非派生的情况：

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

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

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

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

然后对于派生的情况：

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

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

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

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

二、私有继承方式：

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

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

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

三、保护继承方式：

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

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

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

[cpp] view plaincopy
#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;  
}  