深入理解C++中public、protected及private用法

Armypopy Armypopy 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 5.8k累计阅读 5.8k平均单平台 已同步平台 CSDN 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
原创 最新推荐文章于 2024-05-29 10:35:18 发布 5.8k 阅读 AI 写同款· GEO 优化 ›
AI权益加码！Claude Code、Cursor等20+工具免费用！ 购周边限时加赠Coding Plan Lite，畅享主流AI工具！学习进阶更高效！ 阅读详情

初学C++的朋友经常在类中看到public，protected，private以及它们在继承中表示的一些访问范围，很容易搞糊涂。今天本文就来十分分析一下C++中public、protected及private用法。相信对于大家深入掌握C++程序设计会有很大的帮助。

这里我们首先要明白下面几点。

1.类的一个特征就是封装，public和private作用就是实现这一目的。所以：

用户代码（类外）可以访问public成员而不能访问private成员；private成员只能由类成员（类内）和友元访问。

2.类的另一个特征就是继承，protected的作用就是实现这一目的。所以：

protected成员可以被派生类对象访问，不能被用户代码（类外）访问。

现来看看如下示例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include<iostream>
#include<assert.h>
using  namespace  std;
class  A{
public :
   int  a;
   A(){
     a1 = 1;
     a2 = 2;
     a3 = 3;
     a = 4;
   }
   void  fun(){
     cout << a << endl;     //正确
     cout << a1 << endl;    //正确
     cout << a2 << endl;    //正确，类内访问
     cout << a3 << endl;    //正确，类内访问
   }
public :
   int  a1;
protected :
   int  a2;
private :
   int  a3;
};
int  main(){
   A itema;
   itema.a = 10;     //正确
   itema.a1 = 20;     //正确
   itema.a2 = 30;     //错误，类外不能访问protected成员
   itema.a3 = 40;     //错误，类外不能访问private成员
   system ( "pause" );
   return  0;
}

继承中的特点：

先记住：不管是否继承，上面的规则永远适用！

有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。

1.public继承：基类public成员，protected成员，private成员的访问属性在派生类中分别变成：public, protected, private

2.protected继承：基类public成员，protected成员，private成员的访问属性在派生类中分别变成：protected, protected, private

3.private继承：基类public成员，protected成员，private成员的访问属性在派生类中分别变成：private, private, private

但无论哪种继承方式，上面两点都没有改变：

1.private成员只能被本类成员（类内）和友元访问，不能被派生类访问；

2.protected成员可以被派生类访问。

再来看看以下代码：

1.public继承

代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include<iostream>
#include<assert.h>
using  namespace  std;
 
class  A{
public :
   int  a;
   A(){
     a1 = 1;
     a2 = 2;
     a3 = 3;
     a = 4;
   }
   void  fun(){
     cout << a << endl;     //正确
     cout << a1 << endl;    //正确
     cout << a2 << endl;    //正确
     cout << a3 << endl;    //正确
   }
public :
   int  a1;
protected :
   int  a2;
private :
   int  a3;
};
class  B :  public  A{
public :
   int  a;
   B( int  i){
     A();
     a = i;
   }
   void  fun(){
     cout << a << endl;        //正确，public成员
     cout << a1 << endl;        //正确，基类的public成员，在派生类中仍是public成员。
     cout << a2 << endl;        //正确，基类的protected成员，在派生类中仍是protected可以被派生类访问。
     cout << a3 << endl;        //错误，基类的private成员不能被派生类访问。
   }
};
int  main(){
   B b(10);
   cout << b.a << endl;
   cout << b.a1 << endl;    //正确
   cout << b.a2 << endl;    //错误，类外不能访问protected成员
   cout << b.a3 << endl;    //错误，类外不能访问private成员
   system ( "pause" );
   return  0;
}

2.protected继承：

代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include<iostream>
#include<assert.h>
using  namespace  std;
class  A{
public :
   int  a;
   A(){
     a1 = 1;
     a2 = 2;
     a3 = 3;
     a = 4;
   }
   void  fun(){
     cout << a << endl;     //正确
     cout << a1 << endl;    //正确
     cout << a2 << endl;    //正确
     cout << a3 << endl;    //正确
   }
public :
   int  a1;
protected :
   int  a2;
private :
   int  a3;
};
class  B :  protected  A{
public :
   int  a;
   B( int  i){
     A();
     a = i;
   }
   void  fun(){
     cout << a << endl;        //正确，public成员。
     cout << a1 << endl;        //正确，基类的public成员，在派生类中变成了protected，可以被派生类访问。
     cout << a2 << endl;        //正确，基类的protected成员，在派生类中还是protected，可以被派生类访问。
     cout << a3 << endl;        //错误，基类的private成员不能被派生类访问。
   }
};
int  main(){
   B b(10);
   cout << b.a << endl;        //正确。public成员
   cout << b.a1 << endl;       //错误，protected成员不能在类外访问。
   cout << b.a2 << endl;       //错误，protected成员不能在类外访问。
   cout << b.a3 << endl;       //错误，private成员不能在类外访问。
   system ( "pause" );
   return  0;
}

3.private继承：

代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include<iostream>
#include<assert.h>
using  namespace  std;
class  A{
public :
   int  a;
   A(){
     a1 = 1;
     a2 = 2;
     a3 = 3;
     a = 4;
   }
   void  fun(){
     cout << a << endl;     //正确
     cout << a1 << endl;    //正确
     cout << a2 << endl;    //正确
     cout << a3 << endl;    //正确
   }
public :
   int  a1;
protected :
   int  a2;
private :
   int  a3;
};
class  B :  private  A{
public :
   int  a;
   B( int  i){
     A();
     a = i;
   }
   void  fun(){
     cout << a << endl;        //正确，public成员。
     cout << a1 << endl;        //正确，基类public成员,在派生类中变成了private,可以被派生类访问。
     cout << a2 << endl;        //正确，基类的protected成员，在派生类中变成了private,可以被派生类访问。
     cout << a3 << endl;        //错误，基类的private成员不能被派生类访问。
   }
};
int  main(){
   B b(10);
   cout << b.a << endl;        //正确。public成员
   cout << b.a1 << endl;       //错误，private成员不能在类外访问。
   cout << b.a2 << endl;       //错误, private成员不能在类外访问。
   cout << b.a3 << endl;       //错误，private成员不能在类外访问。
   system ( "pause" );
   return  0;
}

通过以上的代码都备有较为详尽的注释，读者应该能够理解。仔细看代码中派生类B中定义了和基类同名的成员a，此时基类的a仍然存在，可以验证。

?
1
2
3
4
5
6
7
int  main(){
   cout <<  sizeof (A) << endl;
   cout <<  sizeof (B) << endl;
 
   system ( "pause" );
   return  0;
}

输出：

16

20

所以派生类包含了基类所有成员以及新增的成员，同名的成员被隐藏起来，调用的时候只会调用派生类中的成员。

如果要调用基类的同名成员，可以用以下方法：

?
1
2
3
4
5
6
7
8
9
int  main(){
 
   B b(10);
   cout << b.a << endl;
   cout << b.A::a << endl;
 
   system ( "pause" );
   return  0;
}

输出：

10

4

记得这里是在类外访问，而a在基类中是public，所以继承方式应该为public，使得a在派生类中仍然为public，在类外可以访问。

感兴趣的读者可以调试运行一下本文实例，加深印象的同时还会有新的收获。

本内容遵循 CC 4.0 BY-SA 版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
关于c++的protected关键字 阅读详情

相关推荐

C++之类的三种继承修饰符（public、private、protected）总结

介绍public、private、protected在类继承中的权限限制

1960

C++中的private, public, protected

Private, Public, and Protected in C++

scott198512的博客 1万+

C++中protected的访问控制作用

在C++中，protected关键字的作用是将类的数据成员和成员函数区分为三种访问类型，分别是public、protected和private三种访问类型。使用protected关键字时，父类的成员函数和数据成员可以被其子类继承并使用，可以实现多态功能，还能增加程序的可扩展性。在实际编程中，我们应该合理使用protected关键字，以提高程序的安全性和可维护性。

很酷的站长的博客 2834

C++类详解（public、private、protected）

二、C++类的声明   类使用class关键字声明，声明方法如下： class 类名： { public://公有成员 int num; private:私有成员 int age; protected:保护成员 int sex; }； 三、类的属性public、private和protected 类的public成员可以被任意实体访问，你可以认为它就是c语言中的struct结构体，可以直接用a.x这种形式访问； 类的private成员不能直接

weixin_39270987的博客 2万+

abstract类中不可以有private的成员_深入理解C++中public、protected及private用法

这篇文章主要介绍了C++中public、protected及private用法,对于C++面向对象程序设计来说是非常重要的概念,需要的朋友可以参考下初学C++的朋友经常在类中看到public，protected，private以及它们在继承中表示的一些访问范围，很容易搞糊涂。今天本文就来十分分析一下C++中public、protected及private用法。相信对于大家深入掌握C++程序设计会有...

weixin_39827506的博客 273

c语言private用法,深入理解C++中public、protected及private用法

初学C++的朋友经常在类中看到public，protected，private以及它们在继承中表示的一些访问范围，很容易搞糊涂。今天本文就来十分分析一下C++中public、protected及private用法。相信对于大家深入掌握C++程序设计会有很大的帮助。这里我们首先要明白下面几点。1.类的一个特征就是封装，public和private作用就是实现这一目的。所以：用户代码(类外)可以访问p...

weixin_39582724的博客 4732

c语言中public 用法,深入理解C++中public、protected及private用法

初学C++的朋友经常在类中看到public，protected，private以及它们在继承中表示的一些访问范围，很容易搞糊涂。今天本文就来十分分析一下C++中public、protected及private用法。相信对于大家深入掌握C++程序设计会有很大的帮助。这里我们首先要明白下面几点。1.类的一个特征就是封装，public和private作用就是实现这一目的。所以：用户代码(类外)可以访问p...

weixin_34840783的博客 9756

深入理解c++中public，protected，及private用法。

深入理解c++中public，protected，及private用法。

pq2385601的专栏 837
下一篇： 文件压缩
点赞 7
评论 0
书签 书签 18
Armypopy
Armypopy
博客等级 码龄10年 1粉丝 3原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值