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

最新推荐文章于 2023-09-21 19:16:01 发布
最新推荐文章于 2023-09-21 19:16:01 发布
阅读量399 收藏
点赞数

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

一：成员的访问权限

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。

我真的不会Coding
关注
C++的访问控制：private、protected、public
Sunrise的专栏
12-14 1753
C++访问控制修饰符
【c++ 回顾】protect 权限
Gin.TaMa的博客
07-13 1703
类似于private权限， protect的权限对于类的使用着来说是不可见的 类似与pubic权限，protect的权限对于基类的派生类和友元是可见的 无法通过派生类访问基类对象的protect的成员 第三条就保证了无法通过派生类来绕过protect权限 例如 #include <iostream> class Base { protected: int x; }; c...
C++ 类访问控制public/private/protected探讨
weixin_34320724的博客
06-11 149
摘要：本文是从饮水思源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/C++编程：protected的访问权限
OceanStar的博客
11-19 7772
在没有继承的情况下，protected跟private相同。在派生类的时候才出现分化 基类对象不能访问基类的protected成员，派生类中可以访问基类的protected成员。也就是说private成员是不能被继承的，只有public，protected的成员才可以被继承 只有在派生类中才可以通过派生类对象访问基类的protected成员 #include <iostream> using namespace std; class base { public: bas..
C++中类的三种访问权限：private、public与protect
weixin_51268298的博客
01-18 7456
C++中类的三种访问权限：private、public与protect 类与面向对象 C++中可以定义一个类。定义一个类，其实就是把一堆实体的共同特征给提取出来。这种面向对象而不是面向过程的解决问题的思想，大大提升了复杂大型软件的开发效率。比如在游戏开发中，需要生成一批属性相近、行为相似的怪物，那我们可以定义一个怪物类： class Monster { ​ private: //私有类型成员 ​ int attack = 15; //攻击力属性 ​ public: //公有类型成员
C++中的三种继承public,protected,private详细解析
01-20
三种访问权限 public:可以被任意实体访问 protected:只允许子类及本类的成员函数访问 private:只允许本类的成员函数访问 三种继承方式 public 继承 protect 继承 private 继承 组合结果 基类中 继承方式 子类中 ...
C++的三种继承方式:public,protected,private
Hsuesh的博客
03-12 2624
C++访问权限控制符 : public 公有成员 基类、派生类、友元、外部都可以访问 protected 保护成员 基类、派生类、友元可以访问 private 私有成员 基类、友元可以访问 同样的C++继承方式有public,protected,private三种： 今天就来给大家简单介绍一下C++的三种继承方式。 1、public 方式继承 基类成员对派生类的可见性对派生类来说，基类的公有成员和保护成员可见，基类的公有成员和保护成员...
C++中public、protected及private继承
mystyle_的博客
07-30 1311
转载这里 在设计基类时，对于某些成员变量基类设计者A也不知道其他人会怎么使用，假如A一开始将成员变量a定义为private,当其他人过来继承时需要一个a++的操作，那么他就不得不去找A让他改基类的定义，不然在继承类中无法直接操作基类的私有成员。过了一会儿又有人需要一个a--操作，那么A又要改基类定义添加一个a--的public成员函数，当然后面还有各种需求。。所以A很无奈，于是就出现了protect,对于继承者而言，你们随便操作不用再来麻烦我。这样即保证了数据的私有性（不能被对象获取），同时基类设计者..
友元函数和友元类
青青的专栏--C/C++ OOA/D Design Pattern
05-29 952
友元函数和友元类         采用类的机制后实现了数据的隐藏与封装，类的数据成员一般定义为私有成员，成员函数一般定义为公有的，依此提供类与外界间的通信接口。但是，有时需要定义 一些函数，这些函数不是类的一部分，但又需要频繁地访问类的数据成员，这时可以将这些函数定义为该函数的友元函数。除了友元函数外，还有友元类，两者统称 为友元。友元的作用是提高了程序的运行效率（即减少了类型检查和安全性检查等都
c++ private、protect、public、virtual详细说明***
随意的风的专栏
08-22 6566
今天遇到有些同事居然对这些关键字的权限等还不是特别了解，容易弄混淆，今天总结下。 private： 私有控制符。这类成员只能被本类中的成员函数和类的友元函数访问。 protected： 受保护控制符。这类成员可以被本类中的成员函数和类的友元函数访问，也可以被派生类的成员函数和派生类的友元函数访问。 public： 共有控制符。这类成员可以被本类中的成员函数和类的友元函数访问，也可...
友元不受public/private影响
slw1618的博客
10-14 498
友元是一种定义在类外部的普通函数或类，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。 所以，友元声明只能出现在类定义中。因为友元不是授权类的成员，所以它不受其所在类的声明区域public private 和protected 的影响。 ...
c语言中的protect_概述C++中的 public protected private friend关键字的用法
weixin_29189377的博客
12-31 2317
一个C++类中的变量如果如下关键字作为修饰符.1. public: 程序的任何地方都可以访问.2 protected: 只有类本身及其派生类和其友元函数,友元类可以访问.3 private: 只有类本身及其友元函数,友元类可以访问.4 friend: 用于定义友元函数友元类. 在类里声明的一个普通函数,在前面加上friend修饰符,这个函数就可以访问该类的一切成员,包括private成员.下面在看...
c++征途 --- 类和对象 --- 友元
qq_51947882的博客
08-05 196
2.方便使用的声明部分 --- 函数的声明部分就是将函数实现的花括号部分内容去掉，然后在创建函数部分的后面加上表示代码结束的；通过将类外的函数或类变为我们要访问的对象的友元（good friend）的方式，使得它们能够去访问这个对象中具有私有权限的成员属性了。让成员函数作为类的友元也需要将成员函数的声明写在对应类的括号里的最上方，然后再用 friend 关键字修饰这个函数声明，在一个类A的括号内的最顶端加上类B的声明，并用friend修饰这个函数声明，我们就可以使得类B成为类A的友元。......
private和public的区别
最新发布
m0_57236802的博客
09-21 3481
public是最宽松的访问级别，适用于需要从任何地方访问的成员。private是最严格的访问级别，适用于只应在类内部使用的成员。使用合适的访问修饰符是封装和面向对象编程的一个重要方面。选择合适的访问修饰符可以增加代码的可维护性和安全性。
C++ 1.5.2 友元函数、友元类
weixin_45733227的博客
05-20 588
1.友元函数 定义：友元是普通函数或其他类的成员函数，则称为友元函数。 普通函数声明为友元函数的形式： friend <类型标识符><友元函数名>(参数表) 其它类的成员函数声明为友元函数的形式： friend <类型标识符><类名>::<友元函数名>(参数表) 说明： （1）友元函数的声明可以放在类声明中的任何位置。 （2）友元函数的定义一般放在类的外部，最好与类的其他成员定义放在一起，普通函数为友元也可以放在类内。 （3）友元函数不是本类的成员
C++中public，protected，private的区别
ken2232的博客
03-18 7823
C++中关于public、protect、private的访问权限控制（实例）
c++中protected和private区别
m0_46104251的博客
02-23 2741
protected比private可被访问范围更大，比public更小
C++封装详解：public、protected、private访问控制
"深入探讨C++中的访问控制符public、protected和private及其在继承中的应用" 在C++编程语言中，访问修饰符public、protected和private是实现类的封装和继承的关键概念。它们决定了类的成员在不同上下文下的可访问性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值