C++中public，protected，private的区别

最新推荐文章于 2026-04-29 07:31:56 发布

转载最新推荐文章于 2026-04-29 07:31:56 发布 · 9.9k 阅读

80 ·

本内容遵循CC 4.0 BY-SA版权协议

原文链接：https://blog.csdn.net/weixin_43907175/article/details/121209818

标签

#c++

linux 专栏收录该内容

532 篇文章

订阅专栏

本文详细介绍了编程语言中类的访问修饰符public、private、protected和default的区别和作用，以及它们在继承中的行为。public成员对所有代码开放，private成员仅限类自身访问，protected成员允许子类和同包内的访问，而default（包访问）则限于同包内。此外，文章还讨论了C++中的继承特性，如public继承、protected继承和private继承对成员访问权限的影响。

该文章已生成可运行项目，

public、private、protected、default的区别

https://blog.csdn.net/lvyuan30276/article/details/72722435

在说明这四个关键字之前，我想就class之间的关系做一个简单的定义，对于继承自己的class，base class可以认为他们都是自己的子女，而对于和自己一个目录下的classes（即同一个包），认为都是自己的朋友friendly。

1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用

2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。

3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。

4、default：java的默认访问权限，当没有使用上面提到的任何访问限定词时，就使用它，这种权限通常被称为包访问权限，在这种权限下，类可以访问在同一个包中的其他类的成员，也即可以访问我们前面说的朋友，在包之外，这些成员如同指定了private。

本文来自www.itxxz.com

整理一下：

public:类本身和任何包的任何类都访问

private 只有类本身可以访问，其他类想访问可以通过该类的成员方法访问如getter/setter

protected:保护的，这个和缺省的比较容易混淆，记住最主要区别是：protected可以在不同包的子类被访问，而friendly不可以。

protected可以在类本身、同包的子类，不同包的子类，同包的非子类被访问

缺省的：可以在类本身，同包的子类，同包的非子类被访问。

Public，protected，private解析

Public成员可以被同一个类或同一个包或不同包下的类都可以访问。

Protected成员可以被同一个类或同一个包下的类可以访问，不能被不同包下的类访问。

Private成员可以被于同一个类访问，不能被同一个包或不同包下的类访问。

特别说明一点protected在不同包子类下为yes的情况：

包外子类有权访问父类成员是什么意思？它指子类继承该成员。然而，这不意味着包外子类能够使用父类实例的引用访问该成员。

换句话说，保护＝继承。保护不是指子类能够处理受保护的父类成员，就好像它是公有的那样。因此，如果包外子类获得父类引用，该子类不能在父类引用上使用点运算符来.访问受保护的成员。子类只能通过继承看到受保护的成员。

public,private,protected,default的区别

https://blog.csdn.net/G823909/article/details/128054025

C++中public，protected，private的区别

https://blog.csdn.net/weixin_43907175/article/details/121209818

C++中public，protected，private个人总结为两种概念，一个宗旨。

两种概念：

概念一：静态的

在C++中一个类的成员的访问级别可分为public，protected，和private。public的访问级别最低，谁都可以访问。

一个类的public成员变量、成员函数，可以通过类的成员函数、类的实例变量进行访问

protected访问级别中等，一个类的protected成员变量、成员函数，无法通过类的实例变量进行访问。但是可以通过类的友元函数、友元类进行访问。

private访问级别最高，一个类的private成员变量、成员函数，无法通过类的实例变量进行访问。但是可以通过类的友元函数、友元类进行访问。

到这里我们发现似乎protectd和private没有什么太大的区别，但是主要区别在概念二中。

概念二：动态的

关于动态的，也就是动作的意义。其中包含父子继承的关系。也就是自类是如何继承父类的，是public继承，protected继承，还是private继承。

（1）public继承

派生类通过public继承，基类的各种权限不变。

派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

派生类的实例变量，可以访问基类的public成员，但是无法访问protected、private成员，仿佛基类的成员之间加到了派生类一般。

可以将public继承看成派生类将基类的public,protected成员囊括到派生类，但是不包括private成员。

（2）proteced继承

派生类通过protected继承，基类的public成员在派生类中的权限变成了protected 。protected和private不变。

派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

派生类的实例变量，无法访问基类的任何成员，因为基类的public成员在派生类中变成了protected。

可以将protected继承看成派生类将基类的public,protected成员囊括到派生类，全部作为派生类的protected成员，但是不包括private成员。

private成员是基类内部的隐私，除了友元，所有人员都不得窥探。派生类的友元，都不能访问

（3）private继承

派生类通过private继承，基类的所有成员在派生类中的权限变成了private。

派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

派生类的实例变量，无法访问基类的任何成员，因为基类的所有成员在派生类中变成了private。

可以将private继承看成派生类将基类的public,protected成员囊括到派生类，全部作为派生类的private成员，但是不包括private成员。

private成员是基类内部的隐私，除了友元，所有人员都不得窥探。派生类的友元，都不能访问

具体实例请参考博客protected,public,private区别实例

https://blog.csdn.net/ycf74514/article/details/49053041

一个宗旨

一个宗旨，就是，最终我们在解决实际开发问题的时候都要遵照类对象中所有成员的具体访问级别，进行访问，越级访问一定是不可以的。

————————————————

原文链接：https://blog.csdn.net/weixin_43907175/article/details/121209818

=========

C++中关于public、protect、private的访问权限控制（实例）

https://blog.csdn.net/ycf74514/article/details/49053041

3：private访问权限

一个类的private成员变量、成员函数，无法通过类的实例变量进行访问。但是可以通过类的友元函数、友元类进行访问。

#include<iostream>
#include<string>

using namespace std;

class AccessTest
{
    friend void Atest();
    friend class CAtest;
public:
    int pub_mem;
    void pub_fun(){}
protected:
    int prot_mem;
    void prot_fun(){}
private:
    int priv_memb;
    void priv_fun(){}
    
};

class CAtest
{
public:
    void x()
    {
        AccessTest t;
        t.priv_fun();       //OK,友元类可以访问private成员函数
        int x=t.priv_memb;  //OK,友元类可以访问private成员变量
    }
};

void Atest()
{
    AccessTest t;
    t.priv_fun();       //OK,友元函数可以访问private成员函数
    int x=t.priv_memb;  //OK,友元函数可以访问private成员变量
}

int main()
{
    AccessTest at;
    at.priv_memb;       //ERROR,类实例变量无法访问private成员变量
    at.priv_fun();      //ERROR,类实例变量无法访问private成员函数
    Atest();
    return 0;
}

二：继承的访问权限控制

1：public继承

派生类通过public继承，基类的各种权限不变。

派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

派生类的实例变量，可以访问基类的public成员，但是无法访问protected、private成员，仿佛基类的成员之间加到了派生类一般。

可以将public继承看成派生类将基类的public,protected成员囊括到派生类，但是不包括private成员。

#include<iostream>
#include<string>

using namespace std;

class AccessTest
{
public:
    int pub_mem;
    void pub_fun(){}
protected:
    int prot_mem;
    void prot_fun(){}
private:
    int priv_memb;
    void priv_fun(){}
    
};

class DAccessTest:public AccessTest
{
public:
    void test()
    {
        int x=pub_mem;     //OK
        pub_fun();         //OK
        
        int y=prot_mem;    //OK
        prot_fun();        //OK
        
        int z=priv_memb;   //ERROR
        priv_fun();        //ERROR
    }
    
};



int main()
{
    DAccessTest dt;
    int x=dt.pub_mem;    //OK
    int y=dt.prot_mem;   //ERROR
    int z=dt.priv_memb;  //ERROR
    return 0;
}

2：protected继承

派生类通过protected继承，基类的public成员在派生类中的权限变成了protected 。protected和private不变。

派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

派生类的实例变量，无法访问基类的任何成员，因为基类的public成员在派生类中变成了protected。

可以将protected继承看成派生类将基类的public,protected成员囊括到派生类，全部作为派生类的protected成员，但是不包括private成员。

private成员是基类内部的隐私，除了友元，所有人员都不得窥探。派生类的友元，都不能访问

#include<iostream>
#include<string>

using namespace std;

class AccessTest
{
    friend void Atest();
    friend class CAtest;
public:
    int pub_mem;
    void pub_fun(){}
protected:
    int prot_mem;
    void prot_fun(){}
private:
    int priv_memb;
    void priv_fun(){}
    
};

class DAccessTest:protected AccessTest
{
public:
    void test()
    {
        int x=pub_mem;     //OK
        pub_fun();         //OK
        
        int y=prot_mem;    //OK
        prot_fun();        //OK
        
        int z=priv_memb;   //ERROR
        priv_fun();        //ERROR
    }
    
};

int main()
{
    DAccessTest dt;
    int x=dt.pub_mem;    //ERROR，基类的成员现在是派生类的保护成员
    int y=dt.prot_mem;   //ERROR，基类的成员现在是派生类的保护成员
    int z=dt.priv_memb;  //ERROR
    return 0;
}

3：private继承

派生类通过private继承，基类的所有成员在派生类中的权限变成了private。

派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

派生类的实例变量，无法访问基类的任何成员，因为基类的所有成员在派生类中变成了private。

可以将private继承看成派生类将基类的public,protected成员囊括到派生类，全部作为派生类的private成员，但是不包括private成员。

private成员是基类内部的隐私，除了友元，所有人员都不得窥探。派生类的友元，都不能访问

#include<iostream>
#include<string>

using namespace std;

class AccessTest
{
    friend void Atest();
    friend class CAtest;
public:
    int pub_mem;
    void pub_fun(){}
protected:
    int prot_mem;
    void prot_fun(){}
private:
    int priv_memb;
    void priv_fun(){}
    
};

class DAccessTest:private AccessTest
{
public:
    void test()
    {
        int x=pub_mem;     //OK
        pub_fun();         //OK
        
        int y=prot_mem;    //OK
        prot_fun();        //OK
        
        int z=priv_memb;   //ERROR
        priv_fun();        //ERROR
    }
    
};

int main()
{
    DAccessTest dt;
    int x=dt.pub_mem;    //ERROR，基类的成员现在是派生类的私有成员
    int y=dt.prot_mem;   //ERROR，基类的成员现在是派生类的私有成员
    int z=dt.priv_memb;  //ERROR, private成员无法访问
    return 0;
}

继承总结：

继承修饰符，就像是一种筛子，将基类的成员筛到派生类。public、protected、private，就是筛子的眼。

通过public继承，所有基类成员（除了private），public、protected都到了派生类里面，public筛眼比较大，不会改变访问权限。

通过protected继承，所有基类成员（除了private），public、protected都到了派生类里面，protected筛眼大小适中，所有过来的成员都变成了protected。

通过private继承，所有基类成员（除了private），public、protected都到了派生类里面，private筛眼最小，所有过来的成员都变成了private。

PS:关于class和struct的区别

1：class不写修饰符，成员默认是private的，而struct 默认是public的

    class Base   //默认private
    {
        int a;
        int b;
    }
     
    Base ba;
    int x=ba.a;//错误
    int y=ba.b;//错误
     
    struct St  //默认public
    {
        int a;
        int b;
    }；
     
    St st;
    int x=st.a; //OK
    int y=st.b;//OK

2:class的继承默认是private的，而struct默认是public的

    class Base{...};
    class Derive:Base{...}  //private继承
     
    struct BStruct{...};
    struct DStruct:BStruct{...};//public继承

————————————————

原文链接：https://blog.csdn.net/ycf74514/article/details/49053041

本文章已经生成可运行项目

C++中public，protected，private的区别

整理一下：

Public，protected，private解析

C++中public，protected，private的区别

C++中关于public、protect、private的访问权限控制 （实例）

3：private访问权限

二：继承的访问权限控制

继承总结：

PS:关于class和struct的区别

C++中关于public、protect、private的访问权限控制（实例）