实用C语言中friend友元函数详细解析

合集下载

friend 友元函数

friend 友元函数

friend 友元函数关于友元函数友元函数是指该函数对象的可访问性,可以被类的某些特定函数或特定类的所有函数访问,而不必声明这些函数为类的成员函数。

友元函数不属于任何类,只有在类的定义中显式地为他们指定友元权限,由于他们有独立于类的实体,所以可以提供一种可以直接访问类的成员而不必使用成员函数的方法。

友元函数的作用是把多个类的实现封装起来,而可以通过友元函数来访问类的不同部分。

友元函数也可以把一系列复杂的操作细分为一些更简单的步骤。

下面以一个例子来说明。

下面是一个定义结构体Cat的例子:struct Cat{string name;int age;void eat(string food);void sleep();};上面的示例中,Cat有name和age两个成员变量,以及eat和sleep两个成员函数。

我们可以通过eat和sleep来访问这个类的成员变量,但是如果我们需要在其他类中实现一些操作,比如比较两只猫的年龄,我们就需要定义一个友元函数来访问Cat类的age成员变量了:bool compareCats(Cat c1, Cat c2){return c1.age < c2.age;}在Cat类中添加上友元函数声明:struct Cat{string name;int age;friend bool compareCats(Cat c1, Cat c2);void eat(string food);void sleep();};当定义完Cat类,我们就可以在其他类的函数中使用compareCats函数来比较两只猫的年龄了。

这就是友元函数的作用,它可以让多个类的实现封装起来,从而使用友元函数把一系列复杂的操作细分为一些更简单的步骤。

另外,友元函数也可以被抽象为一个成员函数,以更加方便地使用它。

C 06《友元和常成员》

C  06《友元和常成员》

VC++第六次课 2004.3.17 《友元和常成员》一、友元1、友元函数,①在类中说明,②但不是该类的成员,③允许访问该类的对象的所有成员。

简称友元,关键字friend。

例子:┌──────────────────────────────────┐class Location {private:float X, Y;…………friend float distance(Location &, Location &);};float distance(Location &a, Location &b){float dx = a.X - b.X;float dy = a.Y - b.Y;return sqrt(dx*dx + dy*dy);}└──────────────────────────────────┘优点:①效率,省去调用类的成员函数的开销,②随时通过使用友元增加类的接口。

缺点:破坏了封装性2、友元成员除了自由函数可以说明为友元之外,成员函数也可以说明为另一个类的友元,但要先进行定义性说明。

例子:┌──────────────────────────────────┐class two; //先对two做引用性说明class one {private:int a;public:void func(two &);void func2(..)};class two { //two的定义性说明private:int b;friend void one::func(two &); //友元friend class one; //one是two的友元类};void one::func(two &r){a = r.b;}└──────────────────────────────────┘3、友元类将类one说明为类two的友元类,意味者类one的所有成员函数都是类two的友元函数。

C++友元函数和友元类(C++friend)详解

C++友元函数和友元类(C++friend)详解

C++友元函数和友元类(C++friend)详解私有成员只能在类的成员函数内部访问,如果想在别处访问对象的私有成员,只能通过类提供的接⼝(成员函数)间接地进⾏。

这固然能够带来数据隐藏的好处,利于将来程序的扩充,但也会增加程序书写的⿇烦。

是从结构化的C语⾔发展⽽来的,需要照顾结构化设计程序员的习惯,所以在对私有成员可访问范围的问题上不可限制太死。

C++ 设计者认为,如果有的程序员真的⾮常怕⿇烦,就是想在类的成员函数外部直接访问对象的私有成员,那还是做⼀点妥协以满⾜他们的愿望为好,这也算是眼前利益和长远利益的折中。

因此,C++ 就有了友元(friend)的概念。

打个⽐⽅,这相当于是说:朋友是值得信任的,所以可以对他们公开⼀些⾃⼰的隐私。

友元分为两种:友元函数和友元类。

友元函数在定义⼀个类的时候,可以把⼀些函数(包括全局函数和其他类的成员函数)声明为“友元”,这样那些函数就成为该类的友元函数,在友元函数内部就可以访问该类对象的私有成员了。

将全局函数声明为友元的写法如下:friend 返回值类型函数名(参数表);将其他类的成员函数声明为友元的写法如下:friend 返回值类型其他类的类名::成员函数名(参数表);但是,不能把其他类的私有成员函数声明为友元。

关于友元,看下⾯的程序⽰例。

1. #include<iostream>2. ug namespace std;3. class CCar; //提前声明CCar类,以便后⾯的CDriver类使⽤4. class CDriver5. {6. public:7. void ModifyCar(CCar* pCar); //改装汽车8. };9. class CCar10. {11. private:12. int price;13. friend int MostExpensiveCar(CCar cars[], int total); //声明友元14. friend void CDriver::ModifyCar(CCar* pCar); //声明友元15. };16. void CDriver::ModifyCar(CCar* pCar)17. {18. pCar->price += 1000; //汽车改装后价值增加19. }20. int MostExpensiveCar(CCar cars[], int total) //求最贵⽓车的价格21. {22. int tmpMax = -1;23. for (int i = 0; i<total; ++i)24. if (cars[i].price > tmpMax)25. tmpMax = cars[i].price;26. return tmpMax;27. }28. int main()29. {30. return 0;31. }这个程序只是为了展⽰友元的⽤法,所以 main 函数什么也不做。

C++中友元的实例详解

C++中友元的实例详解

C++中友元的实例详解C++中友元的实例详解尽管友元被授予从外部访问类的私有部分的权限,但他们并不与⾯向对象的编程思想相悖;相反他提⾼了公共接⼝的灵活性。

⼀、友元类友元声明可以位于公有、私有活保护部分、其所在位置⽆关紧要我直接贴出⼀个摘⾃< c++ primer plus >的例⼦来演⽰ c++ 友元类其中 Remote 为 Tv的友元类。

Tv.h#ifndef TV_H_#define TV_H_/*⼀个类电视 */class Tv{public:friend class Remote; //Remote类可以访问Tv Privite 的私有部分enum {off,on //开关};enum{MinVal,MaxVal=20 //⾳量};enum {Antena,Cable //使⽤的天线、还是电缆};enum{TV ,DVD //⼯作模式};Tv(int s = off, int mc = 125) :state(s), volume(5), maxchannel(mc),channel(5), mode(Cable), input(TV) {}void onoff() { state = (state == on) ? off : on; }bool ison()const { return state == on; }bool volup(); //增⼤声⾳bool voldown(); //减⼩声⾳void chanup(); //频道 +void chandown();//频道 -void set_mode() { mode = (mode == Antena) ? Cable : Antena; }void set_input() { input = (input == TV) ? DVD : TV; }void settings()const; //显⽰所有设置private:int state; // 开或者关int volume; // ⾳量int maxchannel; //最⼤int channel; //当前频道int mode; // ⼴播还是电缆int input; //Tv 或者 DVD};/*Remote 的定义(遥控器) */class Remote {private :int mode; // 控制 TV 或 DVDpublic:Remote(int m = Tv::TV) :mode(m) {}bool volup(Tv & t) { return t.volup(); }bool voldown(Tv & t) { return t.voldown(); }void onoff(Tv & t) { return t.onoff(); }void chanup(Tv & t) { return t.chanup(); }void chandown(Tv & t) { return t.chandown(); }void set_chan(Tv &t, int c) { t.channel = c; } //访问了Tv的私有成员void set_mode(Tv &t) { t.set_mode(); }void set_input(Tv &t) { t.set_input(); }};#endif // TV_H_Tv.cpp#include "stdafx.h"#include "Tv.h"#include <iostream>bool Tv::volup() {if (volume < MaxVal) {volume++;return true;}else {return false;}}bool Tv::voldown() {if (volume > MinVal) {volume--;return true;}else {return false;}}void Tv::chanup() {if (channel < maxchannel) channel++;else channel = 1;}void Tv::chandown() {if (channel > 1) channel--;else channel = maxchannel;}void Tv::settings() const {using std::cout;using std::endl;cout << "TV is " << (state == off ? "off" : "on") << endl;if (state == on) {cout << "Volume setting =" << volume << endl;cout << "Channel setting = " << channel << endl;cout << "Mode = " << (mode == Antena ? "antenna" : "cable") << endl; cout << "Input = " << (input == TV ? "TV" : "DVD") << endl;}}测试代码:#include "stdafx.h"#include "tv.h"#include <iostream>int main(){using std::cout;Tv s42;cout << "Initial settings for 42 \" Tv: \n";s42.settings();s42.onoff();s42.chanup();cout << " \n Adjusted settings for 42 \" Tv: \n";s42.chanup();cout << "\n Adjusted settings for 42 \" Tv: \n";s42.settings();Remote grey;grey.set_chan(s42, 10);grey.volup(s42);grey.volup(s42);cout << " \n s42 \" settings after using remote: \n";s42.settings();Tv s58(Tv::on);s58.set_mode();grey.set_chan(s58, 58);cout << " \n s58 \" setting: \n";s58.settings();system("pause");return 0;}运⾏结果:Initial settings for 42 " Tv:TV is offAdjusted settings for 42 " Tv:Adjusted settings for 42 " Tv:TV is onVolume setting =5Channel setting = 7Mode = cableInput = TVs42 " settings after using remote:TV is onVolume setting =7Channel setting = 10Mode = cableInput = TVs58 " setting:TV is onVolume setting =5Channel setting = 58Mode = antennaInput = TV请按任意键继续. . .上述代码中将Remote类设置成为了Tv类的友元类,但事实上我们看到:唯⼀访问Tv的成员的⽅法是void set_chan(Tv &t, int c) { t.channel = c; } ,因此它是唯⼀需要友元的⽅法。

C 中的FRIEND友元函数

C  中的FRIEND友元函数

C++中的friend友元函数(2011-03-2321:01:46)转载分类:C标签:friend友元教育友元函数是可以直接访问类的私有成员的非成员函数。

它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend。

我们已知道类具有封装和信息隐藏的特性。

只有类的成员函数才能访问类的私有成员,程序中的其他函数是无法访问私有成员的。

非成员函数可以访问类中的公有成员,但是如果将数据成员都定义为公有的,这又破坏了隐藏的特性。

另外,应该看到在某些情况下,特别是在对某些成员函数多次调用时,由于参数传递,类型检查和安全性检查等都需要时间开销,而影响程序的运行效率。

为了解决上述问题,提出一种使用友元的方案。

友元是一种定义在类外部的普通函数,但它需要在类体内进行说明,为了与该类的成员函数加以区别,在说明时前面加以关键字friend。

友元不是成员函数,但是它可以访问类中的私有成员。

友元的作用在于提高程序的运行效率(即减少了类型检查和安全性检查等都需要的时间开销),但是,它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。

友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类。

友元函数的特点是能够访问类中的私有成员的非成员函数。

友元函数从语法上看,它与普通函数一样,即在定义上和调用上与普通函数一样。

#include"cmath"#include"iostream"using namespace std;class Point{public:Point(double xx,double yy){x=xx;y=yy;}void GetXY();friend double Distance(Point&a,Point&b);protected:private:double x,y;};void Point::GetXY(){//cout<<"("<<this->x<<","<<this->y<<")"<<endl;cout<<"("<<x<<","<<y<<")"<<endl;}double Distance(Point&a,Point&b){double length;length=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));//它可以引用类中的私有成员return length;}int main(void){Point p1(3.0,4.0),p2(6.0,8.0);p1.GetXY();//成员函数的调用方法,通过使用对象来调用p2.GetXY();double d=Distance(p1,p2);//友元函数的调用方法,同普通函数的调用一样,不要像成员函数那样调用cout<<d<<endl;system("pause");return0;}说明:在该程序中的Point类中说明了一个友元函数Distance(),它在说明时前边加friend 关键字,标识它不是成员函数,而是友元函数。

什么是友元函数

什么是友元函数

什么是友元函数?
答:和继承一样,可以说子继承父,友元就是朋友,它不是类的组成部分,因此被称为直接函数调用。

友元函数不能隐式访问类成员,而必须将成员操作符用于作为参数传递的对象。

友元函数要在一个类体内说明,形式为:friend 类型名友元函数名(形参表);然后在类体外对友元函数进行定义,定义的格式和普通函数相同,但可以通过对象作为参数直接访问对象的私有成员;
友元函数说明如下:①.必须在类的说明中说明友元函数,说明时以关键字friend开头,后跟友元函数的函数原型,友元函数的说明可以出现在类的任何地方,包括在private和public 部分。

②注意友元函数不是类的成员函数,所以友元函数的实现和普通函数一样,在实现时不用”::”指示属于那个类,只有成员函数才使用”::”作用域符号。

③友元函数不能直接访问类的成员,只能访问对象成员。

④友元函数可以访问对象的私有成员,但普通函数不行;⑤调用友元函数时,在实际参数中需要指出要访问的对象!。

友元函数

友元函数

友元函数友元函数友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。

类授予它的友元特别的访问权。

通常同一个开发者会出于技术和非技术的原因,控制类的友元和成员函数(否则当你想更新你的类时,还要征得其它部分的拥有者的同意)。

目录友元函数(friend)?友元函数要在一个类体内说明,形式为:友元函数(friend)?友元函数要在一个类体内说明,形式为:展开友元函数(friend)?定义格式(c++):friend <返回类型> <函数名> (<参数列表>);分清成员函数,非成员函数和友元函数成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。

所以,如果有个函数必须进行动态绑定(见条款38),就要采用虚拟函数,而虚拟函数必定是某个类的成员函数。

关于这一点就这么简单。

如果函数不必是虚拟的,情况就稍微复杂一点。

(条款38: 决不要重新定义继承而来的缺省参数值)举例看下面表示有理数的一个类:class rational {public:rational(int numerator = 0, int denominator = 1);int numerator() const;int denominator() const;private:...};这是一个没有一点用处的类。

(用条款18的术语来说,接口的确最小,但远不够完整。

)所以,要对它增加加,减,乘等算术操作支持,但是,该用成员函数还是非成员函数,或者,非成员的友元函数来实现呢?当拿不定主意的时候,用面向对象的方法来考虑!有理数的乘法是和rational类相联系的,所以,写一个成员函数把这个操作包到类中。

class rational {public:...const rational operator*(const rational& rhs) const;};(如果你不明白为什么这个函数以这种方式声明——返回一个const值而取一个const的引用作为它的参数——参考条款21-23。

C语言第三章2

C语言第三章2

类模板使用方式: 类模板使用方式: Compare <int> cmp1(4,7); 在尖括号内指定实际的类型名,在进行编译时, 在尖括号内指定实际的类型名,在进行编译时,编译 系统就用int取代类模板中的类型参数 取代类模板中的类型参数。 系统就用 取代类模板中的类型参数。
类模板形式定义形式: 类模板形式定义形式: Template<class numtype> class Compare { public: Compare(numtype a,numtype b) {x=a;y=b;} numtype max() {return(x>y)?x:y;} numtype min() {return(x<y)?x:y;} private: numtype x,y; };
程序的Date类需要被前向引用,即先使用,后定义。 类需要被前向引用,即先使用,后定义。 程序的 类需要被前向引用 只包含类名,不包括类体。 只包含类名,不包括类体。 3、一个函数可以被多个类声明为“朋友”,这样可以引 、一个函数可以被多个类声明为“朋友” 用多个类中的私有数据。 用多个类中的私有数据。
关于友元的两点说明: 关于友元的两点说明: (1)友元的关系是单向的而不是双向的; )友元的关系是单向的而不是双向的; (2)友元的关ຫໍສະໝຸດ 不能传递。 )友元的关系不能传递。
3.11 类模板 函数模板:建立一个通用函数, 复习 函数模板:建立一个通用函数,其函数类型 和形参类型不具体指定, 和形参类型不具体指定,用一个虚拟的类型来代 表。 例: #include<iostream> using namespace std; template<typename T>;//模板声明,其中 为 模板声明, 模板声明 其中T为 类型参数 定义一个通用函数, T max(T a,T b,T c)//定义一个通用函数,用T作 定义一个通用函数 作 虚拟类型名 { if(b>a) a=b; if(c>a) a=c; return a; }

友元函数——精选推荐

友元函数——精选推荐

友元函数
引⼊友元的原因
类的私有成员只能通过类的成员函数访问,有时候需要在类的外部访问类的私有成员。

在不放弃私有成员安全性的情况下,使得⼀个普通函数或者类的成员函数可以访问到封装于某⼀类中的信息。

友元是⼀扇通往私有成员的后门。

友元函数
可以是⾮成员函数,也可以是另⼀个类的成员函数,统称为成员函数。

友元函数不属于当前类的成员函数,⽽是独⽴于当前类的外部函数,但它可以访问该类的所有成员,包括私有成员,保护成员,和公有车成员。

C语言中friend友元函数详细解析

C语言中friend友元函数详细解析

C语言中friend友元函数详细解析C语言中friend友元函数详细解析友元函数是可以直接访问类的私有成员的非成员函数。

它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend。

我们已知道类具有封装和信息隐藏的特性。

只有类的成员函数才能访问类的私有成员,程序中的其他函数是无法访问私有成员的。

非成员函数可以访问类中的公有成员,但是如果将数据成员都定义为公有的,这又破坏了隐藏的特性。

另外,应该看到在某些情况下,特别是在对某些成员函数多次调用时,由于参数传递,类型检查和安全性检查等都需要时间开销,而影响程序的运行效率。

为了解决上述问题,提出一种使用友元的方案。

友元是一种定义在类外部的普通函数,但它需要在类体内进行说明,为了与该类的成员函数加以区别,在说明时前面加以关键字friend。

友元不是成员函数,但是它可以访问类中的私有成员。

友元的作用在于提高程序的运行效率(即减少了类型检查和安全性检查等都需要的时间开销),但是,它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。

友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类。

友元函数的特点是能够访问类中的私有成员的非成员函数。

友元函数从语法上看,它与普通函数一样,即在定义上和调用上与普通函数一样。

复制代码代码如下:#include "cmath"#include "iostream"using namespace std;class Point{public:Point(double xx,double yy){x=xx;y=yy;}void GetXY();friend double Distance(Point &a,Point &b);protected:private:double x,y;};void Point::GetXY(){//cout<<"("<x<<","<y<<")"<<endl;cout<<"("<<x<<","<<y<<")"<<endl;}double Distance(Point &a,Point &b){double length;length=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); //它可以引用类中的私有成员return length;}int main(void){Point p1(3.0,4.0),p2(6.0,8.0);p1.GetXY(); //成员函数的调用方法,通过使用对象来调用p2.GetXY();double d = Distance(p1,p2); //友元函数的调用方法,同普通函数的调用一样,不要像成员函数那样调用cout<<d<<endl;system("pause");return 0;}说明:在该程序中的Point类中说明了一个友元函数Distance(),它在说明时前边加friend关键字,标识它不是成员函数,而是友元函数。

跟我学C++语言编程技术——友员函数与友员类

跟我学C++语言编程技术——友员函数与友员类

友员类应用目的 在类的封装和共享两方面合理选择:类的主要优 点是实现数据隐藏与保护,从而将数据与方法相 互组合产生独立的代码块,但这样将使各个类相 互孤立,无法实现类之间的共享。但在应用需求 中可能要实现多个类之间的共享,这可以采用友 元类的方式来实现。
类的引用性前向说明 当类名使用在定义之前时,需要使用前向说明以便 编译器知道此标识符是类名,从而正确地编译。
为什么需要友员函数
在封装和快速性两方面合理选择----OOP中类的 主要优点是可以实现数据隐藏与保护,即不允许 非成员函数对它访问,这样可以提高数据使用的 安全性。但在访问数据的效率方面则下降(因为 正常时应该通过public型的方法பைடு நூலகம்访问)。但在 某些应用场合下,非成员函数体中需要通过对象 名直接访问类中的private成员,以达到高速高效 率地访问数据,这可以通过友员函数来实现。 有些函数需要放在类的外面或者类设计完以后再 加以补充的,此时可能不能设计为类中的成员函 数,但是又需要访问类中的私有成员。
友员函数与成员函数在编程方面的不同点
友员函数在类体内应该采用 friend 加以限定, 但成员函数不需要。 友员函数体在类体外不需要采用“类名::”加以 限定。 调用它时不需要采用“对象名.成员名”方式, 而是直接调用它。 由于友员函数不是成员函数,因而无this指针, 在函数体中访问对象中的成员时必须通过对象 名(可将形参定义为引用),而在成员函数体 内可以直接访问成员数据。
本讲的回顾
在本讲的最后对本讲做一个简要的回顾
友员函数与一般函数(非成员函数)在编程方面的 不同点 友员函数在类体内应该采用 friend 加以限定,但 非成员函数不需要在类中声明。 在友员函数体内可以利用对象访问类中的 private 成员,但非成员函数则不能。

C++总结 友元类和友元函数

C++总结 友元类和友元函数

C++总结友元类和友元函数《windows环境多线程编程原理与应用》中解释:如果将类的封装比喻成一堵墙的话,那么友元机制就像墙上了开了一个门,那些得到允许的类或函数允许通过这个门访问一般的类或者函数无法访问的私有属性和方法。

友元机制使类的封装性得到消弱,所以使用时一定要慎重。

友元类的说明将外界的某个类在本类别的定义中说明为友元,那么外界的类就成为本类的“朋友”,那个类就可以访问本类的私有数据了。

class Merchant{private :intm_MyMoney;intm_MyRoom;… …public:Friend class Lawyer;Intgetmoney();… …};class Lawyer{private:… …public:… …};只有你赋予某个类为你的友元时,那个类才有访问你的私有数据的权利。

说明一个函数为一个类的友元函数则该函数可以访问此类的私有数据和方法。

定义方法是在类的定义中,在函数名前加上关键字friend.《挑战30天C/C++》这样解释:在说明什么是友元之前,我们先说明一下为什么需要友元与友元的缺点:通常对于普通函数来说,要访问类的保护成员是不可能的,如果想这么做那么必须把类的成员都生命成为public(共用的),然而这做带来的问题遍是任何外部函数都可以毫无约束的访问它操作它,c++利用friend修饰符,可以让一些你设定的函数能够对这些保护数据进行操作,避免把类成员全部设置成public,最大限度的保护数据成员的安全。

友元能够使得普通函数直接访问类的保护数据,避免了类成员函数的频繁调用,可以节约处理器开销,提高程序的效率,但所矛盾的是,即使是最大限度大保护,同样也破坏了类的封装特性,这即是友元的缺点,在现在cpu速度越来越快的今天我们并不推荐使用它,但它作为c++一个必要的知识点,一个完整的组成部分,我们还是需要讨论一下的。

在类里声明一个普通数学,在前面加上friend修饰,那么这个函数就成了该类的友元,可以访问该类的一切成员。

C++中友元详解

C++中友元详解

C++中友元详解2008-09-01 21:28:47分类:C/C++问题的提出我们已知道类具备封装和信息隐藏的特性。

只有类的成员函数才能访问类的私有成员,程式中的其他函数是无法访问私有成员的。

非成员函数能够访问类中的公有成员,但是假如将数据成员都定义为公有的,这又破坏了隐藏的特性。

另外,应该看到在某些情况下,特别是在对某些成员函数多次调用时,由于参数传递,类型检查和安全性检查等都需要时间开销,而影响程式的运行效率。

为了解决上述问题,提出一种使用友元的方案。

友元是一种定义在类外部的普通函数,但他需要在类体内进行说明,为了和该类的成员函数加以区别,在说明时前面加以关键字friend。

友元不是成员函数,但是他能够访问类中的私有成员。

友元的作用在于提高程式的运行效率,但是,他破坏了类的封装性和隐藏性,使得非成员函数能够访问类的私有成员。

友元能够是个函数,该函数被称为友元函数;友元也能够是个类,该类被称为友元类。

友元函数友元函数的特点是能够访问类中的私有成员的非成员函数。

友元函数从语法上看,他和普通函数相同,即在定义上和调用上和普通函数相同。

下面举一例子说明友元函数的应用。

#include#includeclass Point{public:Point(double xx, double yy) { x=xx; y=yy; }void Getxy();friend double Distance(Point &a, Point &b);private:double x, y;};void Point::Getxy(){cout<<"("<<<","<<<")"<< FONT>}double Distance(Point &a, Point &b){double dx = a.x - b.x;double dy = a.y - b.y;return sqrt(dx*dx+dy*dy);}void main(){Point p1(3.0, 4.0), p2(6.0, 8.0);p1.Getxy();p2.Getxy();double d = Distance(p1, p2);cout<<"Distance is"<<< FONT>}说明:在该程式中的Point类中说明了一个友元函数Distance(),他在说明时前边加friend关键字,标识他不是成员函数,而是友元函数。

友元成员函数

友元成员函数

友元成员函数C++言是一种面向对象的编程语言,它为程序员提供了一系列强大的特性和功能。

友元成员函数是C++中一种重要的概念,它可以让对象访问其他对象的私有成员。

友元成员函数的实现机制可以帮助程序员有效的处理一些私有成员的访问问题。

所谓的友元成员函数,即不是成员函数,也不是非成员函数,而是一种特殊的函数,它既不属于某一个类的成员函数,也不属于非成员函数,而是属于友元函数。

友元函数可以访问对象的私有成员,它可以用来访问两个类之间的成员,因此它是一种函数特性,它可以用来访问受保护成员和私有成员。

友元成员函数的语法格式有以下几类形式:(1)声明友元函数:类名::friend数名(参数列表);(2)声明友元类:friend class名;(3)重载运算符:friend名 operator算符(参数列表);在实际应用中,友元成员函数可以帮助程序员有效的处理私有成员的访问问题,并保护私有成员不受外界影响。

除此之外,友元成员函数还可以提高代码的可读性,将复杂性隐藏起来,从而使代码更简洁,更易于管理。

不过,在使用友元成员函数时,程序员也需要特别注意。

首先,友元函数的声明和定义必须位于友元函数的作用域内,并且需要注意友元函数的参数定义。

其次,友元函数不能访问类的私有成员,也不能调用类的构造函数。

最后,友元函数不能改变类的私有成员的值,只能读取其值。

此外,友元函数也不能修改类的静态变量。

使用友元成员函数既可以拓展类的功能,也可以提高类的可读性。

但是,程序员在使用友元成员函数时,需要特别注意以上几点,同时也要谨慎使用,以避免程序出现不可预料的错误。

总之,友元成员函数是C++中一种重要的概念,它可以帮助程序员有效的处理私有成员的访问问题,并可以拓展类的功能和提高类的可读性,但是程序员在使用友元成员函数时,也要注意以上几点,以避免出现不可预料的错误。

友元运算符函数

友元运算符函数
于任何类对象的,它没有this指针。若重载的 是双目运算符,则参数表中有两个操作数;若 重载的是单目运算符,则参数表中只有一个操 作数。
2.双目运算符重载 当用友元函数重载双目运算符时,两个操作数都要传递给运算符 函数。请看下面的例子。 例4-5 在例4-3中,曾经用成员运算符函数进行复数运算,现在我
{++op.x; ++op.y; return op; } void main() {coord ob(10,20); ob.print(); ++ob; ob.print(); operator++(ob); ob.print(); return 0; }
//隐式调用友元运算符函数operator++() //显式调用友元运算符函数operator++()
//输出复数A1 //输出复数A2 //输出复数相加的结果A3 //输出复数相减的结果A4 //输出复数相乘的结果A5 //输出复数相除的结果A6
一般而言,采用友元函数重载双目运算符@后, 可以采用以下两种方法使用:
aa@bb;
//隐式调用
operator@(aa,bb); //显式调用
双目友元运算函数operator@ 所需的两个操作 数都在参数表中由对象aa和bb显式地提供。
friend complex operator/(complex a,complex b); //用友元运 算符函//数重载复数"/"
};
complex::complex(double r,double i)
{real=r;imag=i;}
complex operator+(complex a,complex b)

C++ friend友元函数和友元类

C++ friend友元函数和友元类

友元函数和友元类在实际开发中较少使用,想快速学习C++的读者可以跳过本节。

一个类中可以有public、protected、private 三种属性的成员,通过对象可以访问public 成员,只有本类中的函数可以访问本类的private 成员。

现在,我们来介绍一种例外情况——友元(friend)。

借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的private 成员。

fnend 的意思是朋友,或者说是好友,与好友的关系显然要比一般人亲密一些。

我们会对好朋友敞开心扉,倾诉自己的秘密,而对一般人会谨言慎行,潜意识里就自我保护。

在C++中,这种友好关系可以用friend 关键字指明,中文多译为“友元”,借助友元可以访问与其有好友关系的类中的私有成员。

如果你对“友元”这个名词不习惯,可以按原文friend 理解为朋友。

友元函数在当前类以外定义的、不属于当前类的函数也可以在类中声明,但要在前面加friend 关键字,这样就构成了友元函数。

友元函数可以是不属于任何类的非成员函数,也可以是其他类的成员函数。

友元函数可以访问当前类中的所有成员,包括public、protected、private 属性的。

1) 将非成员函数声明为友元函数。

请大家直接看下面的例子:1.#include<iostream>ing namespace std;3.4.class Student{5.public:6.Student(char*name,int age,float score);7.public:8.friend void show(Student *pstu);//将show()声明为友元函数9.private:10.char*m_name;11.int m_age;12.float m_score;13.};14.15.Student::Student(char*name,int age,float score):m_name(name),m_age(age),m_score(score){}16.17.//非成员函数18.void show(Student *pstu){19.cout<<pstu->m_name<<"的年龄是"<<pstu->m_age<<",成绩是"<<pstu->m_score<<endl;20.}21.22.int main(){23.Student stu("小明",15,90.6);24.show(&stu);//调用友元函数25.Student *pstu =new Student("李磊",16,80.5);26.show(pstu);//调用友元函数27.28.return0;29.}运行结果:小明的年龄是15,成绩是90.6李磊的年龄是16,成绩是80.5show() 是一个全局范围内的非成员函数,它不属于任何类,它的作用是输出学生的信息。

友元函数

友元函数

1.4 将一个函数(全局或成员的)声明为多个类的友元函数
在这种情况下,该函数可以同时访问多个类的 private 成员。
class Date; //对 Date 类的提前引用声明 class Time{ public: Time(int=1,int=1,int=1); friend void call(Time&,Date&);//声明函数 call 为本类的友元成员函数 private: int hour; int min; int sec; }; class Date{ public: Date(int=1,int=1,int=2008); friend void call(Time&,Date&); //声明函数 call 为本类的友元成员函数 private: int year; int mon; int day; }; Time::Time(int h,int m,int s){ hour=h; min=m; sec=s; } Date::Date(int m,int d,int y){ mon=m; day=d; year=y; } void call(Time &t,Date &d) {
cout<<"TIME:"<<t.hour<<"-"<<t.min<<"-"<<t.sec<<endl; cout<<"DATE:"<<d.mon<<"-"<<d.day<<"-"<<d.year<<endl; } int main(){ Time t; Date d; call(t,d); system("PAUSE"); return EXIT_SUCCESS; }

friend函数

friend函数

friend函数朋友情谊,聚一起,深信从此,情久永在。

Friends are an essential part of our lives. They provide support, laughter, and just overall companionship. Having friends makes us feel secure, as well as give us someone to rely on during tough times. One way to make friends is through the usage of friendship functions, or friend functions.什么是朋友函数?Friend functions are functions within a class that is declared with the keyword “friend.” This keyword essentially allows any function to have access to the class’s priva te and protected members, allowing for greater flexibility and utility. Because of this, it is important to use this feature judiciously, as too much access can lead to security issues.朋友函数的功能Friend functions are usually used to enable communication between two classes. By giving one class access to the internals of another class, this solution can often be used to neatly connect two sets of logic without resorting to large and miscellaneous assets. By its nature, this use of friend functions can range from simple to complex, depending on the implementation.如何在C ++代码中使用朋友函数?In a C++ program, using a friend function requires a few steps. First, the friend keyword must be used to designate the function as a friend of the class. Then, the function must be defined outside of the class, but have access to all of the private members of the class. After this, the function can be called with a pointer to the class as a parameter, allowing the function to access the class's internals.朋友函数注意事项Despite its many use cases, there are a few considerations to bear in mind when using friend functions. First and foremost, they should not be overused , as granting too much access to a class’s internals can lead to serious security breaches. Secondly, if a friend function is used to communicate between two classes, then both classes should be thoroughly tested for unexpected behavior- otherwise, bugs could potentially arise. Lastly, if the function is ever removed, calling it will still cause an error, making it important to constantly keep its existence in check.结论Friend functions can be incredibly useful for extending the flexibility and reuse of a codebase, and can be invaluable for rightly connecting two sets ofdata or functions. However, as with any feature, its usage should be judicious, and all edge cases should be thoroughly tested. If used correctly, friend functions can be a great tool that make programming far easier.。

类外定义友元函数

类外定义友元函数

类外定义友元函数友元函数是指在类外部定义的,可以访问该类的私有成员的函数。

它是通过在类中声明友元函数来实现的。

在类中声明友元函数时需要使用关键字friend。

例如:```cppclass MyClass {private:int myVar;public:friend void myFriend(MyClass); // 声明友元函数};友元函数可以是类的成员函数,也可以是全局函数。

无论友元函数是哪种类型,其特点都是能够访问类的私有成员变量和私有成员函数。

1. 保护隐藏的实现细节。

在某些情况下,程序员希望隐藏类的实现细节,只让类的成员函数能够访问和修改类的私有变量。

有时候也需要外部函数能够访问类中私有变量,这个时候就可以使用友元函数来实现。

友元函数可以访问类的私有成员,但不是类的成员函数,因此可以保护隐藏的实现细节。

2. 提高程序的运行效率。

在一个大型的程序中,如果需要频繁地访问类的成员变量,那么每次通过类的成员函数访问就会导致大量的函数调用和参数传递,从而影响程序的运行效率。

这个时候可以使用友元函数来提高程序的运行效率,因为友元函数可以直接访问类的私有成员变量,不需要通过类的成员函数进行访问。

3. 实现类的非成员函数。

有时候需要实现类的非成员函数,但是这个函数需要访问类的私有成员变量或者私有成员函数,这个时候可以使用友元函数来完成任务。

需要注意一下友元函数的使用限制和注意事项:1. 友元函数并不属于类的成员函数,因此不可以通过this指针来访问类的成员变量和成员函数。

2. 友元函数必须在类中声明,但是可以在类外部进行定义。

3. 友元函数不能继承,因为friend关键字只适用于当前类,对于子类没有任何作用。

4. 友元函数可以是全局函数,也可以是其他类的成员函数。

5. 友元函数不会影响类的封装性,因为友元函数只能在类中声明,但是在类的外部无法访问其成员变量。

友元函数提供了一种特殊的访问私有成员的方式,可以用于实现一些需要访问私有成员的函数。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

C语言中friend友元函数详细解析
友元函数是可以直接访问类的私有成员的非成员函数。

它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend。

我们已知道类具有封装和信息隐藏的特性。

只有类的成员函数才能访问类的私有成员,程序中的其他函数是无法访问私有成员的。

非成员函数可以访问类中的公有成员,但是如果将数据成员都定义为公有的,这又破坏了隐藏的特性。

另外,应该看到在某些情况下,特别是在对某些成员函数多次调用时,由于参数传递,类型检查和安全性检查等都需要时间开销,而影响程序的运行效率。

为了解决上述问题,提出一种使用友元的方案。

友元是一种定义在类外部的普通函数,但它需要在类体内进行说明,为了与该类的成员函数加以区别,在说明时前面加以关键字friend。

友元不是成员函数,但是它可以访问类中的私有成员。

友元的作用在于提高程序的运行效率(即减少了类型检查和安全性检查等都需要的时间开销),但是,它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。

友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类。

友元函数的特点是能够访问类中的私有成员的非成员函数。

友元函数从语法上看,它与普通函数一样,即在定义上和调用上
与普通函数一样。

复制代码代码如下:
#include cmath
#include iostream
using namespace std;
class Point
{
public:
Point(double xx,double yy)
{
x=xx;
y=yy;
}
void GetXY();
friend double Distance(Point a,Point b);
protected:
private:
double x,y;
};
void Point::GetXY()
{
//cout(x,y)endl;
cout(x,y)endl;
}
double Distance(Point a,Point b)
{
double length;
length=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); //它可以引用类中的私有成员
return length;
}
int main(void)
{
Point p1(3.0,4.0),p2(6.0,8.0);
p1.GetXY(); //成员函数的调用方法,通过使用对象来调用
p2.GetXY();
double d = Distance(p1,p2); //友元函数的调用方法,同普通函数的调用一样,不要像成员函数那样调用
coutdendl;
system(pause);
return 0;
}
说明:在该程序中的Point类中说明了一个友元函数Distance(),它在说明时前边加friend关键字,标识它不是成员函
数,而是友元函数。

它的定义方法与普通函数定义一样,而不同于成员函数的定义,因为它不需要指出所属的类。

但是,它可以引用类中的私有成员,函数体中的a.x,b.x,a.y,b.y都是类的私有成员,它们是通过对象引用的。

在调用友元函数时,也是同普通函数的调用一样,不要像成员函数那样调用。

本例中,p1.Getxy()和p2.Getxy()这是成员函数的调用,要用对象来表示。

而Distance(p1, p2)是友元函数的调用,它直接调用,不需要对象表示,它的参数是对象。

(该程序的功能是已知两点坐标,求出两点的距离。

)
下面对上面的代码进行输入、输出流的重载:
复制代码代码如下:
#include
#include
using namespace std;
class Point
{
public:
Point(double xx,double yy)
{
x=xx;
y=yy;
}
void GetXY();
friend double Distance(Point a,Point b);
friend ostream operator (ostream a,Point b);
protected:
private:
double x,y;
};
// friend ostream operator(ostream o,A another);
ostream operator (ostream out,Point b) //在类中声明的时候,可以是ostream a,函数定义的时候也可以是ostream out {
out(b.x,b.y)endl;
return out;
}
void Point::GetXY()
{
//cout(x,y)endl;
//cout(x,y)endl;
cout*this;
}
double Distance(Point a,Point b)
{
double length;
length=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); return length;
}
int main(void)
{
Point p1(3.0,4.0),p2(6.0,8.0);
p1.GetXY();
p2.GetXY();
double d = Distance(p1,p2);
coutdendl;
system(pause);
return 0;
}。

相关文档
最新文档