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

最新推荐文章于 2025-04-23 21:50:56 发布
最新推荐文章于 2025-04-23 21:50:56 发布
阅读量2w 收藏 182
点赞数 51
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ycf74514/article/details/49053041
版权
本文详细介绍了C++中public、protected和private访问控制的特点及应用，包括不同访问级别的成员如何被类实例和成员函数访问，以及在继承过程中的权限变化。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一：成员的访问权限

1: public访问权限

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

   <实际上，类的成员函数，可以访问本类内的任何成员变量和成员函数>

    

#include<iostream>
#include<string>

using namespace std;

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

int main()
{
	AccessTest at;
	at.pub_mem;     //OK, 类变量可以访问public成员
	at.pub_func();  //OK, 访问public成员函数是没有问题的
	
  return 0;
}



2：protected访问权限

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


#include<string>
#include<iostream>

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.prot_fun();      //OK,友元类可以访问protected成员函数
          int x=t.prot_mem;  //OK,友元类可以访问protected成员变量
       }
};

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

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


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;
}

到现在，是否感觉私有访问属性，和保护属性没有什么区别？区别主要体现在继承上面。下面将会讲到。


总结：public在任何地方都能访问，protected只能在派生类中访问， private只能在友元中访问。



二：继承的访问权限控制

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继承


C++的访问控制：private、protected、public
Sunrise的专栏
12-14 1840
C++访问控制修饰符
【c++ 回顾】protect 权限
Gin.TaMa的博客
07-13 1762
类似于private权限， protect的权限对于类的使用着来说是不可见的 类似与pubic权限，protect的权限对于基类的派生类和友元是可见的 无法通过派生类访问基类对象的protect的成员 第三条就保证了无法通过派生类来绕过protect权限 例如 #include <iostream> class Base { protected: int x; }; c...
C++ 类访问控制public/private/protected探讨
weixin_34320724的博客
06-11 177
摘要：本文是从饮水思源BBS C/C++版上一篇帖子引发的思考。当时看到帖子，突然觉得平时见惯了的，在这里似乎变得陌生了，究竟访问控制符怎样起作用，怎样使用，该怎样理解，本文试图给出讨论。原帖如下  1 #include &lt;IOSTREAM&gt; 2 using namespace std; 3  4 class A{ 5 public: 6     A(int i_,int j_) 7...
C++入门篇——引用详解
最新发布
Chen_xu3207的博客
04-23 930
C++中引入的引用，顾名思义就是引用一个对象的名字，传递给另一对象名，也可理解为取别名。引⽤不是新定义⼀个变量，⽽是给已存在变量取了⼀个别名，编译器不会为引⽤变量开辟内存空间， 它和它引⽤的变量共⽤同⼀块内存空间。抽象点就像⽔壶传中李逵，宋江叫"铁⽜"，江湖上⼈称"⿊旋⻛"；林冲，外号豹⼦头。都是同一对象，只是名称有所区别。这里的类型包括了所有之前学过的数据类型，像整型、指针类型、结构体类型等。但引用在定义时也需注意以下问题：1.引用的别名不能与引用对象相同。
C/C++编程：protected的访问权限
OceanStar的博客
11-19 7952
在没有继承的情况下，protected跟private相同。在派生类的时候才出现分化 基类对象不能访问基类的protected成员，派生类中可以访问基类的protected成员。也就是说private成员是不能被继承的，只有public，protected的成员才可以被继承 只有在派生类中才可以通过派生类对象访问基类的protected成员 #include <iostream> using namespace std; class base { public: bas..
c++中的三种访问限定符：public、private、protected
change_xzt的博客
08-02 354
保护成员可以被类的成员函数、友元函数和派生类（子类）的成员函数访问，不能被类的外部访问。C++中有三种主要的访问限定符，用于控制类成员（变量和函数）的访问权限。私有成员只能被类的成员函数和友元函数访问，不能被类的外部访问。公有成员可以被任何地方访问，包括类的外部。
【C++】类中public、protected和private访问修饰符详解和示例
不定时分享，互相学习，共同进步
08-14 2365
在C++中，类是一种用户定义的类型，它允许我们将数据和操作这些数据的函数封装在一起。为了确保这种封装的有效性和数据的安全性，C++提供了三种访问修饰符：public、protected和private。这些修饰符定义了类成员的访问权限，即哪些成员可以被类的外部、类的内部或派生类访问。本文将详细探讨这三种访问修饰符的作用、原理、区别，并通过示例进行说明。
C++中的三种继承public,protected,private详细解析
01-20
三种访问权限 public:可以被任意实体访问 protected:只允许子类及本类的成员函数访问 private:只允许本类的成员函数访问 三种继承方式 public 继承 protect 继承 private 继承 组合结果 基类中 继承方式 子类中 ...
C++的三种继承方式:public,protected,private
Hsuesh的博客
03-12 2795
C++访问权限控制符 : public 公有成员 基类、派生类、友元、外部都可以访问 protected 保护成员 基类、派生类、友元可以访问 private 私有成员 基类、友元可以访问 同样的C++继承方式有public,protected,private三种： 今天就来给大家简单介绍一下C++的三种继承方式。 1、public 方式继承 基类成员对派生类的可见性对派生类来说，基类的公有成员和保护成员可见，基类的公有成员和保护成员...
c++ private、protect、public、virtual详细说明***
随意的风的专栏
08-22 6791
今天遇到有些同事居然对这些关键字的权限等还不是特别了解，容易弄混淆，今天总结下。 private： 私有控制符。这类成员只能被本类中的成员函数和类的友元函数访问。 protected： 受保护控制符。这类成员可以被本类中的成员函数和类的友元函数访问，也可以被派生类的成员函数和派生类的友元函数访问。 public： 共有控制符。这类成员可以被本类中的成员函数和类的友元函数访问，也可...
C++类中protected访问权限问题
一缕阳光的博客
05-06 2502
在c++中，protected修饰的成员属性和成员函数的访问权限： (1)、本类中的成员函数(public/private/protected修饰的函数) (2)、友元函数和友元类 (3)、派生类中的成员函数可以访问对应基类中的protected成员属性和成员函数。 #include <iostream> #include <string> class Base { public: Base() : m_data(0) {} protected: int
友元不受public/private影响
slw1618的博客
10-14 582
友元是一种定义在类外部的普通函数或类，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。 所以，友元声明只能出现在类定义中。因为友元不是授权类的成员，所以它不受其所在类的声明区域public private 和protected 的影响。 ...
C++的public、protected、private和友元
qq_45721740的博客
04-21 737
结果如下： 如果把数据换成data3，data4，data5，data6会报错，所以在类外只能够访问public成员。对于类的成员函数 类外可以访问public成员函数，所以在类外只能够访问public成员。那么成员函数访问有权限吗？没有，成员函数可以访问类的任意数据。那么静态成员函数呢？ 虽然static不属于任何一个类，但是对于protected和
c++征途 --- 类和对象 --- 友元
qq_51947882的博客
08-05 252
2.方便使用的声明部分 --- 函数的声明部分就是将函数实现的花括号部分内容去掉，然后在创建函数部分的后面加上表示代码结束的；通过将类外的函数或类变为我们要访问的对象的友元（good friend）的方式，使得它们能够去访问这个对象中具有私有权限的成员属性了。让成员函数作为类的友元也需要将成员函数的声明写在对应类的括号里的最上方，然后再用 friend 关键字修饰这个函数声明，在一个类A的括号内的最顶端加上类B的声明，并用friend修饰这个函数声明，我们就可以使得类B成为类A的友元。......
private和public的区别
m0_57236802的博客
09-21 4298
public是最宽松的访问级别，适用于需要从任何地方访问的成员。private是最严格的访问级别，适用于只应在类内部使用的成员。使用合适的访问修饰符是封装和面向对象编程的一个重要方面。选择合适的访问修饰符可以增加代码的可维护性和安全性。
C++ 1.5.2 友元函数、友元类
weixin_45733227的博客
05-20 634
1.友元函数 定义：友元是普通函数或其他类的成员函数，则称为友元函数。 普通函数声明为友元函数的形式： friend <类型标识符><友元函数名>(参数表) 其它类的成员函数声明为友元函数的形式： friend <类型标识符><类名>::<友元函数名>(参数表) 说明： （1）友元函数的声明可以放在类声明中的任何位置。 （2）友元函数的定义一般放在类的外部，最好与类的其他成员定义放在一起，普通函数为友元也可以放在类内。 （3）友元函数不是本类的成员
C++修饰符Private和Public的区别
sagima_sdu的博客
04-23 975
使用这些访问修饰符的主要目的是封装，即隐藏类的实现细节并公开一个操作接口，这有助于保护类的数据不被意外修改，同时使得类更易于使用和维护。是两种访问修饰符，用于控制类成员（包括属性和方法）的访问权限。方法是公开的，任何外部代码都可以访问。方法是私有的，它们只能在类。的内部被访问和使用。
protect C++
02-24
### 如何保护C++代码或应用程序 #### 使用编译器优化和混淆技术 为了防止反向工程，可以利用现代编译器提供的各种优化选项来使最终二进制文件更难以被逆向分析。此外，还可以采用专门的工具和服务来进行源码级别的混淆处理，使得即使有人获得了程序的副本也很难理解其工作原理。 #### 动态链接库(DLL)注入防护措施 对于Windows平台上的应用而言，通过`CreateRemoteThread`函数强制其他进程加载特定DLL的做法是一种常见的攻击手段[^2]。为了避免这种情况发生，开发者可以在启动时验证系统的完整性，并监控异常线程活动；也可以考虑实施基于白名单的安全策略，只允许信任的服务访问自己的资源。 #### 加密敏感数据与算法实现细节 如果项目中有重要的商业逻辑或者专有算法，则应该对其进行加密存储，在运行期间再解密执行。这样即便恶意第三方获取到了可执行文件也无法轻易得知核心业务流程是如何运作的。 #### 发布预编译版本而非源码形式的产品 尽可能提供已经过编译的目标机器指令集而不是原始的人类可读语法结构给终端客户安装部署。这一步骤本身就能有效阻止大部分不具备专业知识背景者的窥探企图。 ```cpp // Example of protecting sensitive information within compiled binaries. #include <iostream> #include <string> class SecureData { private: std::string secret; public: explicit SecureData(const char* s):secret(s){}; void showSecret(){ // Decrypt before showing actual content here... std::cout << "The decrypted message is:" << secret << "\n"; } }; int main() { const char *encryptedMessage="ThisIsAnEncryptedString"; SecureData sd(encryptedMessage); sd.showSecret(); } ``` #### 应用软件许可证条款保障权益 最后但同样重要的是，确保遵循合适的开源协议或许可证发布作品。例如GNU通用公共授权许可（GPL），它明确规定了只要求使用者在修改并分发该自由/开放源码软件时也要保持同样的权利给予后续接收者[^3]。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值