C语言日记 37 类的友元（友元类见下一篇）

原创 已于 2022-11-24 21:03:35 修改 · 403 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #java #算法

于 2022-11-22 11:49:38 首次发布
本文详细介绍了C++中友元的概念及其应用，包括全局函数、成员函数作为友元的情况，并探讨了不同方式下如何访问类的私有成员。此外，还讲解了如何使用友元进行两点间距离的计算。

（1）：全局函数做友元 

根据36 类和对象-友元-全局函数做友元_哔哩哔哩_bilibili复现出如下代码：

一、（只是）访问（公开）内部成员：

#include <iostream>
using namespace std;
class Building
{
private:
	int ws;//卧室
public:
	int kt;//客厅
	Building();
};
Building::Building()//构造函数赋初值
	{
		int ws = 1;
		int kt = 2;
	}
int visit(Building b)
{

	cout << "客厅=" << b.kt << endl;
	return 0;
}
int main()
{
	Building b1;
	visit(b1);
}

在这里，实际上，我们也可以把构造函数写在类里面，实现同样的效果：

class Building
{
private:
	int ws;//卧室
public:
	int kt;//客厅
	Building()//构造函数赋初值
	{
		int ws = 1;
		int kt = 2;
	}
};

 结果：

​

为什么我写了半天，最后返回的是一个随机值呢？

根本原因，就在于构造函数的格式不对，构造函数在赋初值时，类里面的变量（成员）前不应该（不能）有类型说明

（C语言日记 33 构造函数_宇 -Yu的博客-优快云博客中，就有构造函数定义和声明的使用格式）

如果没有类型说明，那么构造函数相当于还在给类的（公有，私有）成员变量赋初值，

而加上了类型说明，那么相当于构造函数在给函数内自定义的变量赋初值，和类里面的成员没有关系，而类的成员实际上并没有被赋值，输出时返回的自然就是一个随机值；所以，我们应将程序改为：（通过实参形参调用传值）

#include <iostream>
using namespace std;
class Building
{
private:
	int ws;//卧室
public:
	int kt;//客厅
	Building();
};
Building::Building()//构造函数赋初值
{
	 ws = 1;
	 kt = 2;
}
int visit(Building b)
{

	cout << "客厅=" << b.kt << endl;
	return 0;
}
int main()
{
	Building b1;
	visit(b1);
}

结果：

​

修改为36 类和对象-友元-全局函数做友元_哔哩哔哩_bilibili源程序所设计的各个模块的样子：

#include <iostream>
using namespace std;
class Building
{
private:
	int ws;//卧室
public:
	int kt;//客厅
	Building()//构造函数赋初值
	{
		ws = 1;
		kt = 2;
	}
};
//
int visit(Building b)
{
	cout << "客厅=" << b.kt << endl;
	return 0;
}
void test()
{
	Building b1;
	visit(b1);
}
int main()
{
	test();
}

我们可以通过实参形参调用传值，也可以用指针，引用的方式传值：

指针：

int visit(Building* b)
{
	cout << "客厅=" << b->kt << endl;
	return 0;
}
void test()
{
	Building b1;
	visit(&b1);
}

注解：

（1）：这里的“->”，表示：通过指针来访问结构体变量（的具体内容）C语言日记 28 结构体类型_宇 -Yu的博客-优快云博客

（2）：

visit(&b1);

中，&表示取（地）址，不能改为*（如果改为*，则表示访问该指针指向的目标对象的具体内容）

如果一定不想这样写的话，可以改写为：

void test()
{
	Building b;
	Building *b1=&b;
	visit(b1);
}

引用：

int visit(Building &b)
{
	cout << "客厅=" <<b.kt << endl;
	return 0;
}
void test()
{
	Building b;
	visit(b);
}

注解：

（1）：引用访问，就和对象访问自身的内容属性引用，不能用“->”；（“->”只能用于指针）

（2）：

	visit(b);

只能这么写，不能在前面加“*”（加了表求指向目标的值），也不能加“&”（加了表求指向目标的地址）

二、访问内部私有成员（这就要用到友元了）

这时，既然我们想要让全局函数访问内部私有成员，只要在前面的基础上

在visit()函数中写一个输出私有函数的语句：

    cout << "卧室=" << b.ws << endl;

并且在类的成员声明里面加（上）一个友元函数的声明：

    friend void visit(Building b);

值得注意的是：

这里的友元函数的声明加在类（体）的任意处都可以：

友元函数不是成员函数，无论是放在private私有成员说明中：

#include <iostream>
using namespace std;
class Building
{
private:
	int ws;//卧室
	friend void visit(Building b);
public:
	int kt;//客厅
	Building()//构造函数赋初值
	{
		ws = 1;
		kt = 2;
	}
};
//
void visit(Building b)
{
	cout << "客厅=" << b.kt << endl;
	cout << "卧室=" << b.ws << endl;
}
void test()
{
	Building b1;
	visit(b1);
}
int main()
{
	test();
}

还是放在成员说明之外：

#include <iostream>
using namespace std;
class Building
{
	friend void visit(Building b);
private:
	int ws;//卧室
public:
	int kt;//客厅
	Building()//构造函数赋初值
	{
		ws = 1;
		kt = 2;
	}
};
//
void visit(Building b)
{
	cout << "客厅=" << b.kt << endl;
	cout << "卧室=" << b.ws << endl;
}
void test()
{
	Building b1;
	visit(b1);
}
int main()
{
	test();
}

最终结果都可以访问类的内部私有成员：

例8-14 使用普通函数计算两点间的距离。

源程序：

#include <iostream>
#include <cmath>
using namespace std;
class Point	//Point 类定义
{
private://私有数据成员
	int x, y;
public://外部接口
	Point(int x = 0, int y = 0) :x(x), y(y) { }
	int getX() { return x; }
	int getY() { return y; }
	friend float dist(Point& a, Point& b); //友元函数是一个普通函数
};
float dist(Point& a, Point& b)//普通函数的定义
{
	double x = a.x - b.x;
	double y = a.y - b.y;
	return(float)sqrt(x * x + y * y);
}
//
int main()
{
	Point p1(3, 5), p2(11, 6);
	cout << "The distance is:";
	cout << dist(p1, p2) << endl;
	//调用普通友元函数
	return 0;
}

结果：

The distance is:8.06226

（1）：#include <cmath>：相当于#include <math.h> （C语言）<C++的库>，当然这里不写也无所谓，如同：C语言日记 8 C++语句_宇 -Yu的博客-优快云博客：#include <math.h>//可有可无

（2）：其中的： friend float dist(Point &a, Point &b); 只是一个用引用作为函数参数的形式，可以改（写）为：（实参形参传递数据）

friend float dist(Point a, Point b);  

详见书P105（当然，像这样用实参形参传递数据，采用的是值传递的传值的方式）；

也可以改（写）为：（指针传递数据）

#include <iostream>
#include <cmath>
using namespace std;
class Point	//Point 类定义
{
private://私有数据成员
	int x, y;
public://外部接口
	Point(int x = 0, int y = 0) :x(x), y(y) { }
	int getX() { return x; }
	int getY() { return y; }
	friend float dist(Point* a, Point* b); //友元函数是一个普通函数
};
float dist(Point* a, Point* b)//普通函数的定义
{
	double x = a->x - b->x;
	double y = a->y - b->y;
	return(float)sqrt(x * x + y * y);
}
//
int main()
{
	Point p1(3, 5), p2(11, 6);
	cout << "The distance is:";
	cout << dist(&p1, &p2) << endl;
	//调用普通友元函数
	return 0;
}

 当然，改写为指针传递数据的方式的修改过程，比起其他两种情况要更为复杂一些：

改动处：

（1）：形参a和b改为指针

（2）:“->”改为"."

（3）：调用dist函数时，里面的实参p1，p2改为取（地）址“&p1，&p2”

（3）：另外，（如果）我们想要在类中（里面）定义该友元函数（不用分开声明，直接一次性定义完成就行了）最终结果也一样：

#include <iostream>
using namespace std;
class Point	//Point 类定义
{
private://私有数据成员
	int x, y;
public://外部接口
	Point(int x = 0, int y = 0) :x(x), y(y) { }
	int getX() { return x; }
	int getY() { return y; }
	friend float dist(Point a, Point b)//友元函数是一个普通函数
	{
		double x = a.x - b.x;
		double y = a.y - b.y;
		return(float)sqrt(x * x + y * y);
	}
};
//
int main()
{
	Point p1(3, 5), p2(11, 6);
	cout << "The distance is:";
	cout << dist(p1, p2) << endl;
	//调用普通友元函数
	return 0;
}

而在这里我们可以看到，实际上想要访问本类的内部私有成员，根本还用不着什么友元函数，

直接设立一个公有的类函数直接访问调用私有成员就可以：

#include <iostream>
#include <cmath>
using namespace std;
class Point	//Point 类定义
{
private://私有数据成员
	int x, y;
public://外部接口
	Point(int x = 0, int y = 0) :x(x), y(y) { }
	int getX() { return x; }
	int getY() { return y; }
	float dist(Point* a, Point* b)//普通函数的定义
	{
		double x = a->x - b->x;
		double y = a->y - b->y;
		return(float)sqrt(x * x + y * y);
	}
};
//
int main()
{
	Point p1(3, 5), p2(11, 6);
	cout << "The distance is:";
	cout << dist(&p1, &p2) << endl;
	//调用普通友元函数
	return 0;
}

结果：

为什么？？？

调用类中定义的函数必须用对象（才能调用）：（这里用p1，p2都可以）

#include <iostream>
#include <cmath>
using namespace std;
class Point	//Point 类定义
{
private://私有数据成员
	int x, y;
public://外部接口
	Point(int x = 0, int y = 0) :x(x), y(y) { }
	int getX() { return x; }
	int getY() { return y; }
	float dist(Point* a, Point* b)//普通函数的定义
	{
		double x = a->x - b->x;
		double y = a->y - b->y;
		return(float)sqrt(x * x + y * y);
	}
};
//
int main()
{
	Point p1(3, 5), p2(11, 6);
	cout << "The distance is:";
	cout << p1.dist(&p1, &p2) << endl;
	//调用普通友元函数
	return 0;
}

 （2）：成员函数做友元

 例8-15 使用其他类的成员函数实现两点间距离的计算。

源程序：

#include <iostream>
using namespace std;
class Point;//声明 Point 类
class Dist//Dist 类定义
{
public:
	float dist(Point& a, Point& b);
};
class Point//Point 类定义
{
private://私有数据成员
	int x, y;
public://外部接口
	Point(int x = 0, int y = 0) :x(x), y(y) {}
	int getx() { return x; }
	int getY() { return y; }
	friend float Dist::dist(Point& a, Point& b);
	//友元函数是Dist的成员函数
};
float Dist::dist(Point& a, Point& b) //友元函数的定义
{
	double x = a.x - b.x;
	double y = a.y - b.y;
	return (float)sqrt(x * x + y * y);
}
int main()
{
	Point p3(10, 8), p4(4, 12);
	Dist d;
	cout << "The distance is:"; cout << d.dist(p3, p4) << endl;
	//调用成员友元函数
	return 0;
}

The distance is:7.2111

 ​​

（3）：友元类

见下一篇日记

（其实是下一篇日记太短，而这篇日记太长，把这个内容换一个位置，调整一下两篇的篇幅）

C++友元
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-23 469
1. 起源： 类实现了数据的隐藏与封装，类的数据成员一般定义为私有成员，仅能通过类的成员函数才能读写。如果数据成员定义为公共的，则又破坏了封装性。但是某些情况下，需要频繁读写类的数据成员，特别是在对某些成员函数多次调用时，由于参数传递、类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。 2. 概念： 友元是一种定义在类外部的普通函数，但他需要在类体内进行说明，为了和该类的成员函数加以区别...
C++ 中友元函数与友元类详解
08-30
3. 某类的友元函数的作用域并非该类作用域，如果该友元函数是另一类的成员函数，则其作用域为另一类的作用域，否则与一般函数相同。 4. 友元函数破坏了面向对象设计的封装特性。所以应该尽量少用。 使用方法： ...
C++ —— 友元(友元函数、友元类和友元成员函数)
starter_____的博客
10-27 1731
有些情况下，允许特定的非成员函数访问一个类的私有成员，同时仍阻止一般的访问，这是很方便做到的。例如被重载的操作符，如输入或输出操作符，经常需要访问类的私有数据成员。 友元(friend)机制允许一个类将对其非公有成员的访问权授予指定的函数或者类 友元的声明以friend开始，它只能出现在类定义的内部，友元声明可以出现在类中的任何地方 友元不是授予友元关系的那个类的成员，所以它们不受其声明出现部分...
C++之：友元类
weixin_33978044的博客
03-11 193
一、文章来由 上一篇写了友元函数，这一次写一个姊妹篇，继续深入探究一下友元类。 二、定义 友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。 当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。定义友元类的语句格式如下： friend...
c语言friend函数,实用C语言中friend友元函数详细解析
weixin_31443757的博客
05-20 963
C语言中friend友元函数详细解析友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend。我们已知道类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程序中的其他函数是无法访问私有成员的。非成员函数可以访问类中的公有成员，但是如果将数据成员都定义为公有的，这又破坏了隐藏的...
六、C++学习_友元函数（带C语言基础）
baidu_39049318的博客
09-05 282
六、C++学习_友元函数（带C语言基础） 解决运算符重载问题 Integer int5, int4, int3; //自己封装的类 int5 = int3 + int4; //重载+运算符 实现 int3.value + int4.value int5 = int4 + 1024; //编译通过 int5 = 1024 + int4; //编译报错 友元函数 //使用友元方式重载+运算符，实现int类型与Integer类型的相加； friend const Integer operator+(int
C++之友元：友元函数和友元类详解
01-20
一、友元介绍我们知道，类的成员函数可以访问同类的其他成员函数，包括公有、私有和保护成员。而类的外部函数只能访问类的公有成员。友元是一种允许非类成员函数访问类的非公有成员的一种机制。可以把一个函数指定为...
友元函数和友元类_友元函数用法_
10-03
在C++编程语言中，`友元`是一个重要的特性，用于打破封装的限制，使得类与类之间可以互相访问对方的私有或受保护成员。标题"友元函数和友元类"涉及到两个核心概念：友元函数和友元类。 **友元函数** 是一个非成员...
简要介绍C++编程中的友元函数和友元类
09-03
友元类的概念使得两个类之间可以共享私有信息，但同样可能导致数据安全问题，因为友元类可以不受限制地访问另一个类的内部状态。 总的来说，友元函数和友元类是C++中用于增强类间交互的高级特性，它们打破了封装...
c++友元函数与友元类的深入解析
12-31
友元是一种定义在类外部的普通函数，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效
友元（C++）
MoooLi的博客
09-19 784
C++控制对象私有部分的访问。通常，公有类方法提供唯一的访问途径，但是有时候这种限制太严格，以致于不适合特定的编程问题。在这种情况下，C++提供了另外一种形式的访问权限：友元。友元有三种 友元函数 友元类 友元成员函数 通过让函数称为类的友元，可以赋予该函数与类的成员函数相同的访问权限。 介绍如何成为友元前，先介绍为何需要友元。再为类重载二元运算符时（带两个参数的运算符）常常需要友元。将Tim...
C++友元类
Andy的博客
01-30 1995
C++友元类
C++中的友元——编程界的老王
qyvlik的专栏
08-09 1537
c++中友元类可以访问类的所有域，简直是编程世界的老王。
c语言的友元函数的用法,友元函数<<的模板化
weixin_39572794的博客
05-22 216
1、构造函数的一种使用intmain(void){//Testt1=10;//在构造函数中寻找只有一个参数的//手动的调用构造函数;Testt2=Test(1,2);//直接调用构造函数--->匿名对象;//直接调用Test的有参构造函数,初始化t2对象;只会调用一次构造函数(直接把匿名对象转成t2);}2、构造与赋值语句Testg(){//返回为对象,我就给你返...
c语言友元,简单友元实例和访问申明using关键字
weixin_39614657的博客
05-22 120
#include//Y类的不完全定义class Y;//X类的定义class X {public:void disp(Y py,char *name); //成员函数原型};//定义Y类class Y {//声明本类的友元函数//X类的disp()为本例的友元函数friend void X::disp(Y py,char *name);//普通函数putY() 为本例的友元函数friend v...
【C++】友元--最全解析（友元是什么？我们应该如何理解友元？友元可以应用在那些场景？）
最新发布
weixin_45031801的博客
04-22 5240
在C++编程语言中，友元函数（Friend Function）是一种特殊的函数，具有访问类中私有成员和保护成员的权限，尽管它不是类的成员函数。友元函数的存在使得类的设计更加灵活，能够在需要时授予外部函数访问类的私有成员的能力。本文将详细介绍C++中的友元函数，包括其定义、使用场景、优缺点以及示例。
C 友元函数与友元类
King逍灬遥
10-21 1222
C++友元函数与友元类 在C++中，一个类中可以有public、protected、private三种属性的成员，通过对象可以访问public成员，只有本类中的函数可以访问本类的private成员。所以，通过友元（friend）能够打破封装性。借助友元（friend），可以使得其他类中的成员函数以及全局范围内的函数访问当前类的private成员。有时需要定义一些函数，这些函数不是类的一部分，但又...
c语言友元,C++ 中友元函数与友元类详解
weixin_29854111的博客
05-22 503
C++ 中友元函数与友元类详解总的来说，友元分为两类：友元函数与友元类。友元是针对类而言，它提供了一种非类的成员函数来访问类的非公有成员的一种机制。可以把一个函数指定为某类的友元，这个函数称为这个类的友元函数。也可以将类A指定为类B的友元，则类A是类B的友元类，类A的所有成员函数均是类B的友元函数，均可以访问类B的非公有成员。友元函数的注意事项：(1)友元函数不是类的成员函数，在函数体中访问对象的...
关于友元函数
wuxinliulei的专栏
10-04 2666
1、为什么要引入友元函数： 类具有封装性和隐蔽性，只有类的成员函数才能访问类的私有成员，程序中的其他函数式无法访问类的私有成员。但是，有些时候，要求程序设计者必须确保每个类都能够提供足够的成员函数对所有可能遇到的访问请求进行处理（即有可能去访问其他类的私有成员）。并且，由于某些成员函数的频繁调用，由于函数参数的传递、C++严格的类型检查和安全性检查都将带来时间上的开销，从而影响程序的运行效率。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值