C++的public、protected、private和友元

已于 2024-04-24 21:32:33 修改
阅读量416 收藏 7
点赞数 4
分类专栏： C++语言 文章标签： c++ 开发语言
于 2024-04-21 17:26:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45721740/article/details/138014945
版权
本文详细解释了C++中public、protected和private访问修饰符的作用，以及类的成员函数、静态成员函数和友元的访问权限。友元允许函数或类访问类的受保护和私有成员，但访问并非双向的。
摘要由CSDN通过智能技术生成

一、public、protected和private

    C++类中有三个关键词：public、private和protected，主要是限定对类内数据的访问权限：

  • public:可以被该类中的函数,子类的函数,其友元函数访问,也可以在该类外访问。
  • protected:可以被该类中的函数,子类的函数,其友元函数访问。
  • private:只能由该类中的函数,其友元函数访问。

具体如下：

class A {
public:
	A(int a, int b) : data1(a), data2(b),
		data3(a), data4(b), data5(a), data6(b) {}

	~A() {}

	int data1;
	int data2;

protected:
	int data3;
	int data4;

private:
	int data5;
	int data6;
};


int main() {
	A a(1, 2);
	cout << "outof class a, data access: " << endl \
		<< "data1: " << a.data1 << endl \
		<< "data2: " << a.data2 << endl;

	return 0;
}

结果如下：

outof class a, data access:
data1: 1
data2: 2

    如果把数据换成data3，data4，data5，data6会报错，所以在类外只能够访问public成员。

对于类的成员函数

class A {
public:
	A(int a, int b) : data1(a), data2(b),
		data3(a), data4(b), data5(a), data6(b) {}

	~A() {}

    void print_public(){
        cout << "public function member" << endl;
    }

	int data1;
	int data2;

protected:
	int data3;
	int data4;
    
    void print_protected(){
        cout << "protected function member" << endl;
    }


private:
	int data5;
	int data6;

    void print_private(){
        cout << "private function member" << endl;
    }
};


int main() {
	A a(1, 2);
    a.print();
    

	return 0;
}

    类外可以访问public成员函数，所以在类外只能够访问public成员。

那么成员函数访问有权限吗？没有，成员函数可以访问类的任意数据。

那么静态成员函数呢？

class A {
public:
	A(int a, int b) : data1(a), data2(b),
		data3(a), data4(b), data5(a), data6(b) {}

	~A() {}

	static void print1(A a) {
		cout << "outof class a, data access: " << endl \
			<< "data1: " << a.data1 << endl \
			<< "data2: " << a.data2 << endl;

		cout << "outof class a, data access: " << endl \
			<< "data3: " << a.data3 << endl \
			<< "data4: " << a.data4 << endl;

		cout << "outof class a, data access: " << endl \
			<< "data5: " << a.data5 << endl \
			<< "data6: " << a.data6 << endl;
	}

	int data1;
	int data2;

protected:
	int data3;
	int data4;

	static void print2(A a) {
		cout << "outof class a, data access: " << endl \
			<< "data1: " << a.data1 << endl \
			<< "data2: " << a.data2 << endl;

		cout << "outof class a, data access: " << endl \
			<< "data3: " << a.data3 << endl \
			<< "data4: " << a.data4 << endl;

		cout << "outof class a, data access: " << endl \
			<< "data5: " << a.data5 << endl \
			<< "data6: " << a.data6 << endl;
	}

private:
	int data5;
	int data6;

	static void print3(A a) {
		cout << "outof class a, data access: " << endl \
			<< "data1: " << a.data1 << endl \
			<< "data2: " << a.data2 << endl;

		cout << "outof class a, data access: " << endl \
			<< "data3: " << a.data3 << endl \
			<< "data4: " << a.data4 << endl;

		cout << "outof class a, data access: " << endl \
			<< "data5: " << a.data5 << endl \
			<< "data6: " << a.data6 << endl;
	}
};

int main() {
	A a(1, 2);
	A::print1(a);
//	A::print2(a);    错误，不能访问print2
//	A::print1(a);    错误，不能访问print3

	return 0;
}

    虽然static不属于任何一个类，但是对于protected和private类外依然不能访问。还有static函数不属于类成员所以，需要传递参数，没有隐式传递this指针。

二、友元

2.1友元函数

声明友元函数可以访问类的protected成员和private成员，但是同样友元函数不属于类。因为和静态函数一样，不会默认传入this指针。

class A {
public:
	A(int a, int b) : data1(a), data2(b),
		data3(a), data4(b), data5(a), data6(b) {}

	~A() {}
    
    friend void print_frined(A a);

	int data1;
	int data2;

protected:
	int data3;
	int data4;


private:
	int data5;
	int data6;

};

void print_frined(A a){
    cout << "outof class a, data access: " << endl \
		<< "data1: " << a.data1 << endl \
		<< "data2: " << a.data2 << endl;

	cout << "outof class a, data access: " << endl \
		<< "data3: " << a.data3 << endl \
		<< "data4: " << a.data4 << endl;

	cout << "outof class a, data access: " << endl \
		<< "data5: " << a.data5 << endl \
		<< "data6: " << a.data6 << endl;
}

int main() {
	A a(1, 2);
	print_friend(a);

	return 0;
}

输出结果

outof class a, data access:
data1: 1
data2: 2
outof class a, data access:
data3: 1
data4: 2
outof class a, data access:
data5: 1
data6: 2

2.2 友元类成员函数

在此之前记录一下c++前置声明的问题(太扯淡了，这么离奇的问题竟然现在才知道，我不愧是个大菜鸡)

    和友元函数不一样的是，友元类成员函数，这个函数是另一个类的成员函数，但是访问权限都一样，如下：

class A;
class B{
public:
    void visit(A* a);
};

class A {
public:
	A(int a, int b) : data1(a), data2(b),
		data3(a), data4(b), data5(a), data6(b) {}

	~A() {}
    
    friend void B::visit(A* a);

	int data1;
	int data2;

protected:
	int data3;
	int data4;


private:
	int data5;
	int data6;

};

void B::visit(A* a){
    cout << "outof class a, data access: " << endl \
		<< "data1: " << a->data1 << endl \
		<< "data2: " << a->data2 << endl;

	cout << "outof class a, data access: " << endl \
		<< "data3: " << a->data3 << endl \
		<< "data4: " << a->data4 << endl;

	cout << "outof class a, data access: " << endl \
		<< "data5: " << a->data5 << endl \
		<< "data6: " << a->data6 << endl;
}

int main() {
	A a(1, 2);
    B b;
	b.visit(&a);

	return 0;
}

    注意：B类之前要前置声明A，B的visit函数参数只能使用指针或者引用，B::visit函数的实现必须在A类定义完之后。

  输出结果如下：

outof class a, data access:
data1: 1
data2: 2
outof class a, data access:
data3: 1
data4: 2
outof class a, data access:
data5: 1
data6: 2

B的成员函数可以访问A的所有成员。

2.3 友元类

简单来说就这样

#include <iostream>
using namespace std;

class A {
public:
	A(int a, int b) : data1(a), data2(b),
		data3(a), data4(b), data5(a), data6(b) {}

	~A() {}

	int data1;
	int data2;

	friend class B;

protected:
	int data3;
	int data4;

private:
	int data5;
	int data6;
};

class B {
public:
	int data0 = 0;
	void visit(A* a);

private:
	int data1 = 1;
};

void B::visit(A* a) {
	cout << "outof class A, data access: " << endl \
		<< "data1: " << a->data1 << endl \
		<< "data2: " << a->data2 << endl;

	cout << "outof class A, data access: " << endl \
		<< "data3: " << a->data3 << endl \
		<< "data4: " << a->data4 << endl;

	cout << "outof class A, data access: " << endl \
		<< "data5: " << a->data5 << endl \
		<< "data6: " << a->data6 << endl;
}


int main() {
	A a(1, 2);
	B b;
	b.visit(&a);

	return 0;
}

运行结果如下：

outof class A, data access:
data1: 1
data2: 2
outof class A, data access:
data3: 1
data4: 2
outof class A, data access:
data5: 1
data6: 2

然而，c++里友元不是双向的，这就是说，在A中声明：B是A的友元，B中的所有方法可以访问A的所有成员，但是A不能访问B的所有成员。

#include <iostream>
using namespace std;

class B;
class A {
public:
	A(int a, int b) : data1(a), data2(b),
		data3(a), data4(b), data5(a), data6(b) {}

	~A() {}

	void visit(B* b);  // A新加的函数

	int data1;
	int data2;

	friend class B;

protected:
	int data3;
	int data4;

private:
	int data5;
	int data6;

};

class B {
public:
	int data0 = 0;
	void visit(A* a);

private:
	int data1 = 1;
};

// 新加的东西
void A::visit(B* b) {
	cout << b->data0 << endl;
	//cout << b->data1 << endl;  // 报错
}

void B::visit(A* a) {
	cout << "outof class A, data access: " << endl \
		<< "data1: " << a->data1 << endl \
		<< "data2: " << a->data2 << endl;

	cout << "outof class A, data access: " << endl \
		<< "data3: " << a->data3 << endl \
		<< "data4: " << a->data4 << endl;

	cout << "outof class A, data access: " << endl \
		<< "data5: " << a->data5 << endl \
		<< "data6: " << a->data6 << endl;
}



int main() {
	A a(1, 2);
	B b;
	b.visit(&a);

	return 0;
}

注意：前置声明和成员函数实现的位置。如果A企图访问B的私有成员数据data1，编译器会报错。

Believer——篝火者
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解C++中public、protected及private用法
09-04
在C++中，面向对象编程的核心之一是封装，这通过访问修饰符public、protected和private得以实现。这些修饰符定义了类的成员在不同上下文中的可访问性，从而控制了代码的结构和安全性。 1. **public**： - 公共成员...
概述C++中的 public protected private friend关键字的用法
09-01
`public`、`protected`、`private`和`friend`是C++中定义访问权限的关键字，它们在类的设计中扮演着重要角色。 1. `public`关键字： 当一个成员被声明为`public`时，它可以在类的任何地方以及类的外部被自由地访问...
C++继承之private继承
最新发布
flysnow010的博客
04-10 685
通过继承机制，可以利用已有的对象类型来定义新对象类型。所定义的新对象类型不仅仅拥有新定义的成员，而且还同时拥有旧的成员。我们称已存在的用来派生新类的类为基类，又称为父类。由已存在的类派生出的新类称为派生类，又称为子类。 private继承 派生类中父类public成员变成private成员。
C++使用技巧（三）：C++基类 & 派生类
源代码杀手的博客
10-25 2334
当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。 基类 & 派生类 一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下： class derived-class: access-specifier base-class 其中，访问修饰符 access-specifier 是 public、prote
C++public、protected和private的区别
qq_33865609的博客
06-02 7110
C++public继承、protected继承和private继承的区别 学习C++这三个关键字是比较基础且常见的，下面先简单介绍下这三个关键字在类内的作用： public:公有的，说明声明在public后面的成员所有人都是可以使用的。 protected:受保护的，类内和子类可直接访问，也就是说，基类中有protected成员，子类继承于基类，那么也可以访问基类的protected成员，要是基类是private成员，则对于子类也是隐藏的，不可访问 private:私有的，只有类内的成员函数才可以访问。
C++学习笔记【十八】—— 类成员函数public
xiaodouhao123456的博客
08-14 8632
类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。 类成员函数有两种定义方法： 将函数定义在类的内部 将函数定义在类的外部，单独使用范围解析运算符 :: 来定义 将函数定义在类的内部 在类定义中定义的成员函数是把函数声明为内联的，即便没有使用 inline 标识符。 例程如下： class Box { public: double length; // 长度 double breadth; // 宽度 doubl
C++中的private, public, protected
scott198512的博客
02-17 1万+
Private, Public, and Protected in C++
C++ friend友元函数和友元类.pdf
02-27
C++中的友元（friend）机制是类封装原则的一个例外，允许特定的非成员函数或成员函数访问类的私有（private）和受保护（protected）成员，这在某些特定情况下非常有用，尤其是在需要打破封装性以实现特定功能时。...
c++学习（八）
yuer的博客
05-18 901
访问对象中成员的3种方法： 1.通过对象名和成员运算符（.）访问对象中的成员 2. 通过指向对象的指针访问对象中的成员 例如： Time t1,*p; p=&t1; t1.set_time(); (*p).show_time(); p->show_time(); 3. 通过对象的引用变量访问对象中的成员 引用变量共占同一段存储单元，实际上它们是同一个对象，只是用不同的名
C++使用技巧（五）：C类public，protected和 private的用法
源代码杀手的博客
11-12 1万+
一、用法说明 1.类的一个特征就是封装，public和private作用就是实现这一目的。所以： 用户代码（类外）可以访问public成员而不能访问private成员；private成员只能由类成员（类内）和友元访问。 2.类的另一个特征就是继承，protected的作用就是实现这一目的。所以： protected成员可以被派生类对象访问，不能被用户代码（类外）访问。 二、理解与实践 先从类定义里理解public, 定义一个类，本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类的名称意
公共函数集锦
08-26
mfc 中一些公共函数和扩展类的集锦，更方便的编程应用，主要是自用
C++里public,protected,private的意义和用处
ylf_fengge的博客
10-28 3865
C++里public,protected,private在类成员以及派生类里的使用
C++（笔记）浅谈protected
浅然的专栏
04-06 1万+
一个类使用protected关键字来声明是希望与派生类分享但是不想被其他公共访问使用的成员。所以protected可以看做public和private的中间产物 解析protected 1.类似于私有成员，受保护的成员对于类的用户（类的用户即类的对象）来说是不可访问的，也就是说可以通过类的成员函数访问而不能通过类的对象来访问 2.类似于公有成员，受保护的成员对于派生类的成员和友元来说是可访
C++ protected的用法
尘墨
10-04 1987
#include using namespace std; class A { protected: int m; }; class B: public A { public: void show() { m=10; cout<<"m is :"<<m<<endl; } }; void main() {
C++ protected（受保护的）详解
qq_35886593的博客
03-28 1641
保护成员的可访问范围比私有成员大，比公有成员小。能访问私有成员的地方都能访问保护成员。 保护成员扩大的访问范围表现在：基类的保护成员可以在派生类的成员函数中被访问。 引入保护成员的理由是：基类的成员本来就是派生类的成员，因此对于那些出于隐藏的目的不宜设为公有，但又确实需要在派生类的成员函数中经常访问的基类成员，将它们设置为保护成员，既能起到隐藏的目的，又避免了派生类成员函数要访问它们时只能间接访问...
C++ protected成员访问权限
热门推荐
Legend(谭海燕)的专栏
03-05 1万+
C++ protected成员访问权限
C++中public:的意思
Sakaiml的博客
03-03 1万+
在public: 下的成员，是类的公有成员，别的类或者主函数可以申明个对象直接访问，而private: 下的是私有成员，只有类的内部能访问，类的外部无法访问的． class A { public: int a; private: int b; }; main() { A aa; aa.a=1; //aa.b=2会出错，说无法访问私有成员 } ...
C++类中public，private和protected的作用详解
ThisIsClark
05-24 1万+
首先摘抄一下谭浩强的《C++程序设计》中关于public，private和protected这三个成员访问限定符的概念性解释：如果在类的定义中既不指定private，也不指定public，则系统就默认为是私有的。被声明为私有的（private）成员，只能被本类中的成员函数引用，类外不能调用（友元类除外）。被声明为公用的（public）成员，既可以被本类中的成员函数所引用，也可以被类的作用域内的其他...
c++类中public和private，protected有什么区别
03-28
在C++中，public、private和protected是类成员访问修饰符，它们的作用是控制类成员的访问权限。 public成员可以被类的任何成员函数、友元函数、派生类和外部代码访问，而private成员只能被类的成员函数和友元函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值