友元的创建和使用（普通函数做友元，成员函数做友元，类做友元）

最新推荐文章于 2024-06-20 09:00:44 发布
最新推荐文章于 2024-06-20 09:00:44 发布
阅读量3.1k 收藏 37
点赞数 19
分类专栏： C++ 文章标签： C++ 友元 私有属性 访问权限 封装性
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yi_chengyu/article/details/120807304
版权

友元的作用：允许让友元类（友元函数）访问自己的私有属性
友元的创建方式：在类的声明（函数的声明）前面加上友元关键字friend，放在允许被访问私有属性的类的里面（不受访问权限限制，随便放，只不过一般我们放在类的最上面）。

一、全局函数做类的友元函数

class Building
{
	friend void visit1(Building building);//visit1函数在类里面被声明为友元类
	friend void visit2(Building& building);//visit2函数在类里面被声明为友元类
public:
	Building()
	{
		parlor = "客厅";
		bathroom = "卧室";
	}
	void Print_bathroom()
	{
		cout << "bathroom:" << bathroom << endl;
	}
public:
	string parlor;
private:
	string bathroom;
};

void visit1(Building building)//临时对象访问私有属性
{
	cout << "visit1正在访问bathroom:" << building.bathroom << endl;
}

void visit2(Building& building)//原对象在友元函数里访问私有属性
{
	cout << "visit2正在访问bathroom:" << building.bathroom << endl;//error
	building.bathroom = "卧室2";
}

int main()
{
	Building building;

	visit1(building);
	building.Print_bathroom();

	visit2(building);
	building.Print_bathroom();//building私有属性在visit2函数里面已经被修改
	
	return 0;
}

在这里插入图片描述

总结来说，不管是在主函数里创建的对象还是在友元全局函数里创建的临时对象，在友元全局函数里对象都可以为所欲为，可以随意访问私有属性，甚至对象在里面可以修改自己的私有属性。
也就是说，除了友元全局函数没有this指针之外，友元函数和类的成员函数对于类来说没什么区别。所以慎用友元。

二、一个类的成员函数做另一个类的友元函数

作用：让一个类的成员函数可以访问另一个类的私有属性。

class Building
{
public:
	Building()
	{
		parlor = "客厅";
		bathroom = "卧室";
	}
public:
	string parlor;
private:
	string bathroom;
};

class Breather
{
public:
	Breather()
	{
		building = new Building;
	}
	string Get_bathroom()
	{
		return building->bathroom;
	}
	Building* building;
};

上面的代码是不允许的。Get_bathroom()函数会报错，原因是Building的bathroom为私有属性，Buildine类的对象不能访问。那么我们如果允许这函数访问呢？那就告诉Building类，这个Get_bathroom函数为友元函数。
但是一个类的成员函数做另一个类的友元函数这个过程是屡屡碰壁的！
首先我们来看第一种代码：

class Building
{
public:
	friend string Breather::Get_bathroom();//将类Breather的成员函数Get_bathroom()声明为Building的友元函数
	Building()
	{
		parlor = "客厅";
		bathroom = "卧室";
	}
public:
	string parlor;
private:
	string bathroom;
};

class Breather
{
public:
	Breather()
	{
		building = new Building;
	}
	string Get_bathroom()
	{
		return building->bathroom;
	}
	Building* building;
};

这种代码编译器通不过，看一下运行结果：
在这里插入图片描述
先抛开访问权限问题，第二个问题说Breather不是类或命名空间名称，这个问题很好想，因为我们在类Breather定义和声明前就用它了，编译器不知道这是什么东西，那么我们平常解决办法就是提前声明一下。那么我们在最上面加上class Breather;声明后，再运行出现以下问题：
在这里插入图片描述
这个问题应该是找不到Get_bathroom(),那么我们干脆直接把Breather类放在Building类之前定义。那么就在最前面加上class Breather;声明Breather是一个类。修改后代码如下：

class Building;

class Breather
{
public:
	Breather()
	{
		building = new Building;
	}
	string Get_bathroom()
	{
		return building->bathroom;
	}
	Building* building;
};

class Building
{
public:
	friend string Breather::Get_bathroom();
	Building()
	{
		parlor = "客厅";
		bathroom = "卧室";
	}
public:
	string parlor;
private:
	string bathroom;
};

运行结果：
在这里插入图片描述
人傻了，先不说一直报错的另一个问题（bathroom不可访问，这个问题说明我们友元没有弄成功），就连这两个类的类名都搞定不了了。冷静一下之后，突然想明白了。
首先再来仔细来分析一下，第23行代码用到了类Building的构造函数，我们只是声明了Building是一个类，但是编译器这个时候并不知道这个类里面有什么东西，所以没办法调用Building的构造函数，所以building没办法构造出来，所以23行和27行都报错。那么，我们就把类Breather中用到Building类及Building构造的对象的语句都放在最后面，放到Building类的后面，这样到时候编译器就已经知道Building类里面有什么东西了。修改后的代码：

class Breather;
class Building;

class Breather
{
public:
	Breather();//只留声明，定义放到类Building下面
	string Get_bathroom();//只留声明，定义放到类Building下面
	Building* building;
};

class Building
{
public:
	friend string Breather::Get_bathroom();
	Building()
	{
		parlor = "客厅";
		bathroom = "卧室";
	}
public:
	string parlor;
private:
	string bathroom;
};

/**************Breather类中用到类Building的两个函数定义***************/
Breather::Breather()
{
	building = new Building;
}
string Breather::Get_bathroom()
{
	return building->bathroom;
}
/******************************************************************/
int main()
{
	Breather breather;
	breather.Get_bathroom();

	return 0;
}

运行结果：
在这里插入图片描述
终于成功了！

类的成员函数做另一个类的友元函数，总结来说注意以下几点：
1.成员函数被做友元的类，写在另一个类的上面。
2.另一个类的声明写在成员函数被做友元的类的上面。（为了简单，可把所有类都在最上面声明一下）。
3.所有用到其他类的成员的函数的定义都写在其他类的下面。（在本来的类中肯定要写声明）。

三、一个类做另一个类的友元类

class Building
{
	friend class Breather;//声明Breather为友元类
public:
	Building()
	{
		parlor = "客厅";
		bathroom = "卧室";
	}
public:
	string parlor;
private:
	string bathroom;
};

class Breather 
{
public:
	Breather()
	{
		building = new Building;
	}
	string Get_bathroom()
	{
		return building->bathroom;
	}
	Building* building;
};

void visit1(Breather& breather)
{
	cout << "breaather 正在访问：" << breather.building->parlor << endl;
	//cout << "breaather 正在访问：" << breather.building->bathroom << endl;//error1
}

int main()
{
	Breather breather;

	cout << "正在访问：" << breather.building->parlor << endl;
	//cout << "正在访问：" << breather.building->bathroom << endl;//error
	cout << "正在访问：" << breather.Get_bathroom() << endl;
	visit1(breather);

	return 0;
}

运行结果：
在这里插入图片描述

以上面代码为例，总结来说，就是Building创建的对象在Breather类里面可以为所欲为，可以随意访问和修改自己的私有属性，但是在Breather类外面不可以这样做，哪怕是以Breather类为中介创建的Building的对象。
友元函数作用是在这个友元函数内，Building的对象可以为所欲为；友元类作用是在这个友元类内，Building的对象可以为所欲为。在类外除非调用这两个类的成员函数，否则无法继续访问Building的私有属性。

上面代码发现visit函数里不可以直接访问Building的私有属性，但是如果把visit声明为友元函数，那么在visit里面这些对象也可以为所欲为了。下面代码是把Breather声明为友元类，把visit函数声明为友元函数：

class Building
{
	friend class Breather;//将Breather声明为友元类
	friend void visit1(Breather& breather);//将visit1声明为友元函数
public:
	Building()
	{
		parlor = "客厅";
		bathroom = "卧室";
	}
	string Get()
	{
		return bathroom;
	}
public:
	string parlor;
private:
	string bathroom;
};

class Breather 
{
public:
	Breather()
	{
		building = new Building;
	}
	string Get_bathroom()
	{
		return building->bathroom;
	}
	Building* building;
};

void visit1(Breather& breather)
{
	cout << "breather 正在访问：" << breather.building->parlor << endl;
	cout << "breather 正在访问：" << breather.building->bathroom << endl;
}

int main()
{
	Breather breather;
	visit1(breather);

	return 0;
}

运行结果：
在这里插入图片描述
visit1声明为Building的友元函数，对象在里面可以为所欲为。那么如果在Breather类为Building类的友元类的前提下，在Breather类里面将visit1声明为友元函数，那么在visit1里面可以用breather.building->bathroom吗？如下代码：

class Building
{
	friend class Breather;//将Breather类声明为Building的友元类
public:
	Building()
	{
		parlor = "客厅";
		bathroom = "卧室";
	}
	string Get()
	{
		return bathroom;
	}
public:
	string parlor;
private:
	string bathroom;
};

class Breather 
{
	friend void visit1(Breather& breather);//将visit1声明为友元Breather的函数
public:
	Breather()
	{
		building = new Building;
	}
	string Get_bathroom()
	{
		return building->bathroom;
	}
	Building* building;
};

void visit1(Breather& breather)
{
	cout << "breaather 正在访问：" << breather.building->parlor << endl;
	cout << "breaather 正在访问：" << breather.building->bathroom << endl;//error!!!!!!!!!!!
}

int main()
{
	Breather breather;
	visit1(breather);

	return 0;
}

答案是不可以！
捋一下关系：Breather为Building的友元类，visit1为Breather的友元函数。所以在Breather类里面，Building类的对象可以为所欲为，在visit1函数里面，Breather类的对象可以为所欲为。
友元赋予的权限不具有传递性。
在visit1里面Breather类的对象可以为所欲为，但是不能够用Breather类的对象为中介去调用Building类的对象为所欲为。

孟小胖_H
关注
  • 19
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
C++中友元类的使用
骆驼胡杨的博客
05-11 1444
为什么要使用友元类 把ComputerServer类作为Computer类的友元类， 那么ComputerServer类的所有成员函数，就可以直接访问Computer类的private数据成员。 友元类可以直接访问对应类的所有数据成员 使用友元类，和友元函数时，使用friend关键字进行声明即可，与访问权限无关， 所以，可以写在private/pulic/protected任意权限内。 Computer.h #pragma once #include <string> #include "Co
简要介绍C++编程中的友元函数和友元类
09-03
在C++编程中，友元函数和友元类是两个重要的概念，它们打破了封装的常规规则，允许外部函数或类访问通常被保护的私有和受保护的成员。虽然在实际开发中使用较少，但在某些特定场景下，它们能够提供更加灵活的代码...
友元函数和友元类_友元函数用法_
10-03
4. 友元关系不会随着对象的创建和销毁而改变，而是属于类级别的关系。 在实际开发中，正确使用友元可以提高代码的效率和灵活性，但需权衡可能带来的封装性损失。理解友元的用法和潜在影响是成为一名熟练的C++程序员...
【C++ | 友元(friend)】友元函数、友元类、友元成员函数详解及例子代码
最新发布
wkd_007的博客
06-20 2844
本文介绍了C++的友元函数、友元类、友元成员函数、其他友元关系，以及使用例子介绍了如何声明、定义、使用。
C++之友元：友元函数和友元类详解
01-20
一、友元介绍我们知道，类的成员函数可以访问同类的其他成员函数，包括公有、私有和保护成员。而类的外部函数只能访问类的公有成员。友元是一种允许非类成员函数访问类的非公有成员的一种机制。可以把一个函数指定为...
C++四种类型强制转换——const_cast、static_cast、dynamic_cast、reinterpret_cast
热门推荐
yi_chengyu的博客
12-14 1万+
文章目录一、const_cast1.基本知识2.示例演示二、static_cast1.基本知识2.示例演示三、dynamic_cast1.基本知识2.示例演示四、reinterpret_cast1.基本知识2.示例演示 一、const_cast 1.基本知识 (1)const_cast只针对指针、引用，当然，this指针也是其中之一。 (2)const_cast的大部分使用主要是将常量指针转换为常指针。常量指针指向的空间的内容不允许被修改，但是使用const_cast进行强制转换就可以修改。 (3)co.
父类指针指向子类对象的问题、父类对象和子类对象之间的问题
yi_chengyu的博客
10-22 1万+
一、父类指针指向子类对象 先上代码： class Base { public: void base_fun1() {} virtual void base_fun2() { cout << "this is Base fun2()" << endl; } public: int a_a; protected: int a_b; private: int a_c; }; class Son :public Base { public: void son_fu
C++函数重载
yi_chengyu的博客
10-13 7529
一.基本概念 函数重载即函数名相同，函数形参列表不同（函数特征标不同）的一类函数称为函数重载。注意函数重载的依据只有形参列表不同。函数的返回类型不同不可以作为函数重载的依据。 如果两个函数的参数数目和类型相同，那么这两个函数的函数特征标就相同，不能重载。 如下举例一组重载函数： void fun(int a); void fun(int a,int b); void fun(double a,int b); void fun(double a,double b); void fun(const char*
C++中虚继承产生的虚基类指针和虚基类表，虚函数产生的虚函数指针和虚函数表
yi_chengyu的博客
10-20 6368
本博客主要通过查看类的内容的变化，深入探讨有关虚指针和虚表的问题。 一、虚继承产生的虚基类表指针和虚基类表 如下代码：写一个棱形继承，父类Base，子类Son1和Son2虚继承Base，又来一个类Grandson继承Son1和Son2。 代码： class Base { public: int a; protected: int b; private: int c; }; class Son1 :virtual public Base { public: int a; protected: i
类的构造函数（分类和调用）
yi_chengyu的博客
10-15 6183
一、构造函数的分类及调用 1.构造函数的分类 （1）类的构造函数按照形参分类，可以分为无参构造函数和有参构造函数。 （2）按照类型分类，可以分为普通构造函数和拷贝构造函数。 普通拷贝构造函数可以根据形参的不同进行构造函数重载。但是析构函数不行，析构函数要求不能有形参，所以析构函数不能重载，而且必须没有形参。拷贝构造函数又分为浅拷贝和深拷贝。这两点在下面第四大点单独整理。 2.调用不同的构造函数对应的写法 写个学生类。注意，一下构造函数的成员变量初始化方式为初始化列表。格式为： 构造函数(形参列表):属性1(
运算符重载（加减运算符、前置加加（减减）后置加加（减减）运算符、赋值运算符、输入输出运算符、关系运算符、函数调用）
yi_chengyu的博客
10-18 5857
编译器对于一个类会默认生成以几种函数： 1.默认构造函数（空形参，空函数体） 2.默认拷贝构造函数（浅拷贝，也叫值拷贝、字节拷贝） 3.析构函数（空形参，空函数体。析构函数要求形参列表必须是空的，所以析构函数不能重载） 4.赋值函数（两个对象赋值，也是以浅（值、字节）拷贝的形式） 讲述以上这四种默认生成的函数的优秀博客点击此处。 编译器会对内置类型（比如char,int,short…）进行加减乘除运算符计算，但是我们自定义类型，有些运算编译器不知道怎么做。我们自定义类型需要进行这些运算的时候，需要我们重载运
C++多态
yi_chengyu的博客
10-23 5684
本篇博客主要记载以下内容： （1）多态的基本概念（计算器代码示例） （2）纯虚函数和抽象类（制作饮品示例） （3）虚析构函数和纯虚析构函数（电脑组装示例） 对于虚函数指针和虚函数表（以及虚指针虚表）在另一篇博客中详细记录。 一、多态的基本概念 1.多态的基本概念 多态分为两类：静态多态和动态多态。 静态多态： 函数重载和运算符重载都属于静态多态。 动态多态： 派生类和虚函数实现运行时多态。 静态多态区别：静态多态的函数地址早绑定，编译阶段确定函数地址。动态多态的函数地址晚绑定，运行阶段确定函数地址。 多态动
引用&——左值引用int&、右值引用int&&、常量引用const int&、左值和右值
yi_chengyu的博客
10-12 5190
1.引用的基本使用 引用是对变量起别名。用代码来说明： int main() { int a = 0; int& b = a; b = 10; cout << a << endl; cout << b << endl; return 0; } 这段代码中是对引用的基本使用。 定义变量a = 10；在栈中分配一个4字节空间，空间里的值赋值为10。 int& b = a;相当于给a这个空间取个别名，这个时候b和a就是指同一个空间，相
动态联编和静态联编
yi_chengyu的博客
10-23 4564
一、动态联编和静态联编的基本概念 1.基本概念 将源代码中的函数调用解释为执行特定的函数代码块被称为函数名联编。在C语言中这个步骤更简单，因为C语言的函数名不允许重复，即没有函数重载这一说，每个函数名都对应着一个函数代码块。但是在C++中要复杂，因为C++中允许函数重载，必须得根据函数名和形参列表来对应一个函数代码块。C/C++编译器在编译过程就完成了这种联编。在编译过程中进行联编被称为静态联编 （早期联编）。 但是虚函数的产生使得静态联编变的困难，因为父类的虚函数允许被子类重写。当我们用一个父类指针指向一
C++——异步操作（std::future、std::async、std::packaged_task、std::promise）
yi_chengyu的博客
01-19 3710
文章目录一、std::future与std::async1.基本概念2.代码演示二、std::future与std::packaged_task1.基本知识2.代码演示三、std::future与std::promise1.基本知识2.代码演示 一、std::future与std::async 1.基本概念 （1）std::future的基本知识 std::future期待一个返回，从一个异步调用的角度来说，future更像是执行函数的返回值，C++标准库使用std::future为一次性事件建模，如果.
C++类的继承
yi_chengyu的博客
10-18 3474
继承是很大程度上解决了代码重复的问题。比如狗和猫都属于动物，我们需要在猫和狗的类里面写上动物年龄，动物名字等。但是动物都可以有年龄和起名称，这个时候我们写个动物类，把动物都有的属性写进去，狗和猫继承动物类就好了，就不需要对狗和猫的类里面分别写年龄和名字了。 本篇博客主要记录以下问题： 一、基本语法和继承方式 二、继承中的对象模型 三、继承中对象的构造析构顺序 四、继承同名成员的处理方式（包括普通成员、静态成员） 五、多继承语法 六、棱形继承 一、基本语法和继承方式 1.基本语法 继承的基本格式为： clas
C++——右值引用
yi_chengyu的博客
12-24 2519
文章目录一、基本知识1.作用2.右值的基本概念以及与左值的辨别3.右值引用的特性二、右值引用优化性能三、移动语义(move)和完美转发(forward)1.移动语义move2.完美转发forward 一、基本知识 1.作用 作用：C++11中引用了右值引用和移动语义，可以避免无谓的复制，提高了程序性能。 2.右值的基本概念以及与左值的辨别 ①C++11中的所有的值必将属于左值、将亡值、纯右值三者之一，将亡值和纯右值都属于右值。 ②左值是表达式结束后仍然存在的持久对象，右值是指表达式结束时就不存在的临时对.
C++——互斥量
yi_chengyu的博客
12-24 2343
文章目录一、基本知识二、独占互斥量mutex1.mutex的介绍2.mutex的成员函数3.实例演示三、lock_guard和unique_lock的使用和区别四、递归互斥量recursive_mutex1.基本知识2.演示示例五、带超时的互斥量std::timed_mutex和std::recursive_timed_mutex 一、基本知识 C++11提供如下4种语义的互斥量（mutex） std::mutex，独占的互斥量，不能递归使用。 std::time_mutex，带超时的独占互斥量，不能递.
friend 友元类和友元函数 friend 友元类和友元函数
09-09
友元类是指在一个类中，可以通过友元关键字将另一个类声明为友元类。友元类的所有成员函数都能够访问被声明为友元类的类的私有和保护成员。这意味着友元类能够绕过类的访问限定符，直接访问私有和保护成员变量和函数。 友元函数是指在一个类中，可以通过友元关键字将一个函数声明为友元函数。这个友元函数可以访问该类的私有和保护成员，但不是类的成员函数。与友元类类似，友元函数也能够绕过类的访问限定符，直接访问私有和保护成员。 友元函数和友元类的使用方式都是通过在类中使用friend关键字进行声明。友元函数可以在类的任何地方进行声明，并且一个函数可以是多个类的友元函数。另外，友元函数不能用const修饰。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

孟小胖_H

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值