友元函数及友元类
友元函数友元类及用法
友元函数友元类及⽤法友元函数可以修改访问类内部的私有成员,友元函数的参数之⼀是类元素,类指针或者是类引⽤,意思是修改某个对象中的类私有成员(对象⼀般是访问不了类私有成员的).若F类是A类的友元类,那么F类的所有成员函数都是A类的友元函数,在F类⾥声明⼀个A类的对象a,在F类内部,这个对象a可以直接访问A类的私有成员.友员类通常设计为⼀种对数据操作或类之间传递消息的辅助类#include "iostream"using namespace std;class A1{public:A1(){a1 = 100;a2 = 200;}int getA1(){return this->a1;}//声明⼀个友元函数friend void setA1(A1 *p, int a1); //什么这个函数是这个类的好朋友protected:private:int a1;int a2;};void setA1(A1 *p, int a1){p->a1 = a1;}//friend 破坏了类的封装性。
//friend关键字是⼀个关系户//why ⽆奈之际 java class//java---》1.class==》class==>java类//java类的反射 sun jdk api//cc++ 1预编译gcc -E 2汇编 gcc -i 3编译gcc -c 3、链接ld ===》汇编代码//friend//应⽤场景。
//const关键字冒牌货c//register//typedef 混号王void main11(){A1 mya1;cout<<mya1.getA1()<<endl;setA1(&mya1, 300);cout<<mya1.getA1()<<endl;system("pause");}class A{//b是a的好朋友friend class B;public:void display(){cout<<x<<endl;}protected:private:int x;};class B{public:void setA(int x){Aobj.x = x;}void printA(){cout<<Aobj.x<<endl; }protected:private:A Aobj;};void main(){B b1;b1.setA(100);b1.printA();system("pause");}。
友元的概念和定义(精)
4 ．在下面有关友元函数的描述中，正确的说法 是： A．友元函数是独立于当前类的外部函数 B ．一个友元函数不能同时定义为两个类的友 元函数 C．友元函数必须在类的外部定义 D．在外部定义友元函数时，必须加关键字 friend
友元函数是一种说明在类定义体内的非成员函
数。 friend 〈返回值类型〉〈函数名〉(〈参数表〉) {〈函数体〉} 说明： (1) 友元函数是在类中说明的一个函数，它不是该 类的成员函数，但允许访问该类的所有成员。它是 独立于任何类的一般的外界函数。友元并不在类的 范围中,它们也不用成员选择符(.或->)调用，除非 它们是其它类的成员。
第4章 友元
4.1 友元的概念和定义
4.2 友元函数 4.3 友元成员 4.4 友元类 4.5 友元综合举例
4.1 友元的概念和定义
一个对象的私有数据成员和成员函数只 能在类定义的范围内使用，也就是说只能 通过它的公有成员函数来访问。 数据隐藏给两个类共享同一函数或数据 带来了额外开销，这是因为每次访问这些 共享内容都需要通过函数调用来完成。
使用friend关键字，友元提供了在不同类的 成员函数之间、类的成员函数与一般函数之间进 行数据共享的机制。通过友元，一个普通函数或 另一个类中的成员函数可以访问类中的私有成员 和保护成员。 友元的正确使用能提高程序的运行效率，但 破坏了类的封装性和数据的隐蔽性，导致程序可 维护性变差，因此一定要谨慎使用。 友元分为友元函数、友元成员和友元类三种， 友元声明可放在类的公有、私有或保护部分，结 果是一样的。
友元函数的ቤተ መጻሕፍቲ ባይዱ明：
(2) 由于友元函数不是类的成员，所以没有 this指针，访问该类的对象的成员时，必须 使用对象名，而不能直接使用类的成员名。 (3) 虽然友元函数是在类中说明的，但其名字 的作用域在类外，作用域的开始点在说明点， 结束点和类名相同。因此，友元说明可以代 替该函数的函数说明。 (4) 如果在说明友元时给出了该函数的函数体 代码，则它是内联的。
友元函数和友元类
友元函数和友元类⼀个类中可以有 public、protected、private 三种属性的成员，通过对象可以访问 public 成员，只有本类中的函数可以访问本类的 private 成员。
在类的外部就没有办法访问类的private成员吗？不是的。
现在，我们来介绍⼀种例外情况——友元（friend）。
借助友元（friend），可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。
1、友元函数在当前类以外定义的、不属于当前类的函数也可以在类中声明，但要在前⾯加 friend 关键字，这样的函数称为友元函数。
友元函数可以是不属于任何类的⾮成员函数，也可以是其他类的成员函数。
友元函数可以访问当前类中的所有成员，包括public、protected和private属性的成员。
所以，可以说友元函数破坏了类的封装性。
定义⽅式：class A{private:int i;friend void FriendFun(A *ptr,int x);public:void MemberFun(int x);};...void FriendFun(A *ptr, int x){ptr->i = x;}void A::MemberFun(int x){i = x;}说明：1）友元函数在类中的位置与访问权限⽆关，即“friend void FriendFun(A *ptr,int x);”语句放在private或者public都没有影响;2）友元函数通过对象参数访问私有成员，即需要输⼊参数中需要有对象的指针。
下⾯看⼀个简单例⼦：#include <iostream>using namespace std;class TestFriend{public:TestFriend(int a,int b){this->a = a;this->b = b;}int get_a(){return this->a;}friend void modifyTest(TestFriend *pT,int a);private:int a;int b;};void modifyTest(TestFriend *pT,int a){pT->a = a;}int main() {TestFriend tf(1,2);cout << tf.get_a() << endl;modifyTest(&tf,4);cout << tf.get_a() << endl;return0;}modifyTest()是⼀个全局范围内的函数，它不属于任何类，它的作⽤是修改对象pT中的a值，在类TestFriend中a为私有成员，原则上不能通过对象访问，但是加⼊友元之后便可以访问。
友元函数和友元类的定义及使用
友元函数和友元类的定义及使用C++实验报告实验名称友元函数和友元类的定义及使用实验目的理解对象与类的关系，掌握对象的创建和使用掌握构造函数、析构函数的概念及使用方法掌握内存的动态分配的概念和使用方法掌握对象数组和对象指针掌握函数调用中参数的传递掌握友元函数和友元类的定义及使用class 类名 {private:数据成员或成员函数protected:数据成员或成员函数public:数据成员或成员函数};实验内容有Distance类和Point类，将Distance类定义为Point类的友元类来实现计算两点之间距离实验代码// point.hclass Distance;class Point{public:Point(int xx=0,int yy=0){X=xx;Y=yy;}friend class Distance;private:int X,Y;};class Distance{public:float fDist(Point a,Point b);};//point.cpp#include"iostream"#include"math.h"using namespace std;#include"point.h"#include"math.h"int _tmain(int argc, _TCHAR* argv[]){Point myp1(1,1),myp2(4,5);Distance d;cout<<"The distance is: ";cout<<d.fdist(myp1,myp2)<<endl;< p=""> return 0;}float Distance::fDist(Point p1,Point p2) {double x,y;x=p1.X -p2.X ;y=p1.Y -p2.Y ;return float(sqrt(x*x+y*y));}心得体会通过本次试验,让我更加熟练运用了友元函数和友元类的定义及使用，加快了学习的进程，知识的掌握实验名称运算符重载实验目的理解为什么要进行运算符重载，在什么情况下进行运算符重载。
c友元函数和友元类用法详解
c友元函数和友元类用法详解C++中的友元函数和友元类是一种特殊的函数和类，它们可以访问类的私有成员变量和类的私有成员函数。
本文将详细介绍C++中友元函数和友元类的用法，以及在实际编程中应用友元函数和友元类所带来的优势。
首先，让我们来了解一下C++中什么是友元函数和友元类。
友元函数是一种特殊的函数，它允许外部函数访问类的私有成员变量和私有成员函数，而不需要对类进行任何修改。
友元函数还可以在类外定义，以便更加方便地使用它来访问类的私有成员变量和私有成员函数。
友元类是一种特殊的类，它允许一个类的私有成员函数访问另一个类的私有成员函数和私有成员变量，而不需要对类进行任何修改。
友元类也可以定义在类外，但其功能与友元函数不同，友元类可以访问另一个类的整个实例，而友元函数只能访问另一个类的私有成员变量和私有成员函数。
定义友元函数和友元类的用法其实非常简单，我们只需要在类的声明中使用关键字“friend”来指定友元的函数或类就可以了： class A {private:int a;public:void setA (int a);friend void foo (A& A); //友元函数};class B {private:int b;public:void setB (int b);friend class C; //友元类};以上的代码定义了两个类：A类和B类，其中A类定义了一个友元函数foo，而B类定义了一个友元类C。
定义完友元函数和友元类之后，就可以使用它们来访问类的私有成员变量和私有成员函数了。
在实际使用中，友元函数和友元类有着诸多的优势，比如可以更加方便的封装类的私有成员，以及更加方便的实现代码的重构。
首先，友元函数和友元类可以帮助我们更好地封装类的私有成员，使类的私有成员不能被外部类访问。
同时，可以使用友元函数和友元类来实现类的重构，这样可以更加方便地实现代码的复用，让程序更加简洁和易读。
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 函数什么也不做。
托尔斯泰test11111
41、友元函数和友元类友元提供了不同类的成员函数之间、类的成员函数和一般函数之间进行数据共享的机制。
通过友元，一个不同函数或者另一个类中的成员函数可以访问类中的私有成员和保护成员。
友元的正确使用能提高程序的运行效率，但同时也破坏了类的封装性和数据的隐藏性，导致程序可维护性变差。
1）友元函数有元函数是可以访问类的私有成员的非成员函数。
它是定义在类外的普通函数，不属于任何类，但是需要在类的定义中加以声明。
friend 类型函数名(形式参数);一个函数可以是多个类的友元函数，只需要在各个类中分别声明。
2）友元类友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。
friend class 类名;使用友元类时注意：(1) 友元关系不能被继承。
(2) 友元关系是单向的，不具有交换性。
若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
(3) 友元关系不具有传递性。
若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明41、友元函数和友元类友元提供了不同类的成员函数之间、类的成员函数和一般函数之间进行数据共享的机制。
通过友元，一个不同函数或者另一个类中的成员函数可以访问类中的私有成员和保护成员。
友元的正确使用能提高程序的运行效率，但同时也破坏了类的封装性和数据的隐藏性，导致程序可维护性变差。
1）友元函数有元函数是可以访问类的私有成员的非成员函数。
它是定义在类外的普通函数，不属于任何类，但是需要在类的定义中加以声明。
friend 类型函数名(形式参数);一个函数可以是多个类的友元函数，只需要在各个类中分别声明。
2）友元类友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。
friend class 类名;使用友元类时注意：(1) 友元关系不能被继承。
(2) 友元关系是单向的，不具有交换性。
友元关系式
友元关系式摘要：1.友元关系的定义与作用2.友元关系的分类3.友元关系的声明与使用4.友元关系的注意事项正文：一、友元关系的定义与作用友元关系是C++中用于实现类与类之间的一种互助关系，它允许一个类的成员函数或者整个类访问另一个类的私有成员和保护成员。
这种关系为类的设计者提供了一种在类之间共享数据和功能的灵活方式，同时又保证了数据的封装性和安全性。
二、友元关系的分类友元关系可以分为两类：友元函数和友元类。
1.友元函数：友元函数是在一个类中声明的，可以访问另一个类的所有成员。
友元函数通常用于解决函数与类之间的耦合问题，使得函数可以更好地复用。
2.友元类：友元类是在一个类中声明的，可以访问另一个类的所有成员和友元函数。
友元类可以访问另一个类的所有内容，包括私有成员、保护成员和公有成员，使得类的设计更加灵活。
三、友元关系的声明与使用1.友元关系的声明：在类中使用关键字friend 声明友元关系。
友元关系的声明分为友元函数和友元类。
- 友元函数声明：friend 返回类型类名::成员函数名(参数列表);- 友元类声明：friend class 类名;2.友元关系的使用：在声明了友元关系的类中，可以直接访问另一个类的成员和函数，无需使用访问修饰符。
四、友元关系的注意事项1.友元关系是一种“双刃剑”，它虽然为类的设计提供了便利，但同时也破坏了封装性。
因此，在实际编程中，应谨慎使用友元关系，避免过度暴露类的实现细节。
2.友元关系并不能代替继承关系。
友元关系主要用于解决功能复用和类间数据共享的问题，而继承关系主要用于实现类的层次结构和代码重用。
在实际编程中，应根据需求选择合适的关系。
3.在使用友元关系时，要注意避免出现死循环。
当两个或多个类互相声明为友元类时，可能会导致死循环，使得程序无法正常编译和运行。
C++运算符重载三种形式（成员函数，友元函数，普通函数）详解
C++运算符重载三种形式（成员函数，友元函数，普通函数）详解三种重载⽅式⾸先，介绍三种重载⽅式：1//作为成员函数重载（常见）2class Person{3 Private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8bool operator<(const Person& b);910 };11bool Person::operator<(const Person& b)12 {13//作为成员函数时，*this即为左操作数a14 ...15 }1//作为友元函数重载2class Person{3private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8 friend bool operator<(const Person& a,const Person& b);910 };11bool operator<(const Person& a,const Person& b)12 {13 ...14 }1//作为普通函数重载（不推荐）2class Person{3public://注意，重载运算符为普通函数时，使⽤到的类成员必须为public4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}89 };10bool operator<(const Person& a,const Person& b)11 {12 ...13 }作为成员函数重载先介绍第⼀种：bool Person::operator<(const Person& b)，bool是函数返回类型，Person::只是指定了成员函数所属类名。
友元类的定义和用法
友元类的定义和⽤法
1.概述
①友元：是定义⼀个类是，该主动声明哪些其他类或函数是它的朋友，进⽽给他们定向提供对类的访问特权。
②友元是C++提供的⼀种破坏数据封装和数据隐藏的机制。
③通过友元将⼀个模块声明为另⼀个模块的友元，⼀个模块能够引⽤到另⼀个模块中本是被隐藏的信息。
④可以使⽤友元函数和友元类。
建议：为了确保数据完整性，及数据封装与隐藏原则，建议尽量不使⽤或少使⽤。
2、友元函数
①友元函数是在类的声明中由关键字friend修饰说明的⾮成员函数，在它的函数体中能通过对象名访问 private和protected 成员。
②作⽤：增加灵活性，使程序员可以在封装和快速性⽅⾯做合理选择。
③访问对象中的成员必须通过对象名。
④友元是单向的。
友元函数的定义⽅法（以定义⼀个Point类为例）
（该函数传⼊引⽤，节约⼯耗）
此时，就会遇到在函数中改变对象私有信息的危险，破坏数据的封装。
例如：
输出：
对⽐原先的输出：
如果想防⽌对象的私有数据被更改 , 可以在传⼊引⽤时加 const修饰例如：
这样在函数中再想更改对象的私有数据时就会报错，例如：
⾄于const的⽤法相信⼤家都见过了，在后⾯的博客中会加以补充。
c++友元函数、友元类声明和使用
c++友元函数、友元类声明和使⽤转⾃：友元函数(friend function)1. 什么是友元函数?⼀个类的私有数据成员通常只能由类的函数成员来访问，⽽友元函数可以访问类的私有数据成员，也能访问其保护成员2. 友元函数的⽤处体现在哪⾥?2.1 使⽤友元函数可提⾼性能，如：⽤友元函数重载操作符和⽣成迭代器类2.2 ⽤友元函数可以访问两个或多个类的私有数据，较其它⽅法使⼈们更容易理解程序的逻辑关系3. 使⽤友元函数前应注意：3.1 类的友元函数在类作⽤域之外定义，但可以访问类的私有和保护成员3.2 尽管类定义中有友元函数原型，友元函数仍然不是成员函数3.3 由于友元函数不是任何类的成员函数，所以不能⽤句柄(对象)加点操作符来调⽤3.4 public, private, protected成员访问符与友员关系的声明⽆关，因此友元关系声明可在类定义的任何位置，习惯上在类定义的开始位置 3.5 友元关系是指定的，不是获取的，如果让类B成为类A的友元类，类A必须显式声明类B为⾃⼰的友元类3.6 友元关系不满⾜对称性和传递性3.7 如果⼀个友元函数想与两个或更多类成为友元关系，在每个类中都必须声明为友元函数4. 注：由于C++属于混合语⾔，常在同⼀个程序中采⽤两种函数调⽤且这两种函数调⽤往往是相反的。
类C语⾔的调⽤将基本数据或对象传递给函数，C++调⽤则是将函数(或信息)传递给对象#include <iostream>using namespace std;class Car{friend void display(Car); //类"Car"的朋友display() //友元函数的声明private:int speed;char color[20];public:void input( ){cout<<"Enter the color : ";cin>>color;cout<<"Enter the speed : ";cin>>speed;}};void display(Car x) //友元函数的定义{cout<<"The color of the car is : "<<x.color<<endl;cout<<"The speed of the car is : "<<x.speed<<endl;}int main( ){Car mine;mine.input( ); //访问成员函数display(mine); //友元函数的使⽤ //将对象"mine"传给友元函数return 0;}输出结果：Enter the color: green 回车Enter the speed: 100 回车The color of the car is : greenThe speed of the car is : 100#include <iostream>using namespace std;class Virus; //类'Virus'未定义前要⽤到，需事先告诉编译器'Virus'是⼀个类class Bacteria{private:int life;public:Bacteria() { life=1; }friend void Check(Bacteria, Virus); //类'Bacteria'中，将Check声明为友元函数};class Virus{private:int life;public:Virus() : life(0) {}friend void Check(Bacteria, Virus); //类'Virus'中，将Check声明为友元函数};void Check (Bacteria b, Virus v) //友元函数的定义{if (b.life==1 || v.life==1){cout<<"\nSomething is alive.";}if (b.life==1){cout<<"\nA bacteria is alive.";}if (v.life==1){cout<<"\nA virus is alive.";}}int main() { Bacteria fever; Virus cholera; Check(fever, cholera); //友元函数的调⽤ return 0; } 输出结果： Something is alive. A bacteria is alive. 友元类(frie nd class) 1. 友元类可以访问与之为友元关系的类的所有私有成员 2. 友元类使⽤较少 #include <iostream> using namespace std; class Add { private: int x,y; public: Add() { x=y=4; } friend class Support; //类'Support'现在是类'Add'的朋友 }; class Support { public: void Sum(Add ob)//此函数可访问类'Add'的所有私有成员{ cout<<"The sum of the 2 members is : "<<(ob.x+ob.y)<<endl; } }; int main() { Add ad; Support sup; sup.Sum(ad); return 0; } 输出结果： The sum of the 2 members is : 8。
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修饰，那么这个函数就成了该类的友元，可以访问该类的一切成员。
Cpp_5友元
友元成员函数举例
class Student; class Teacher { //…... public: void assignGrades(Student& s); protected: int noofStudents; Student * pList[100]; };
14
class Student; { friend void Teacher::assignGrades(Student&s); public: //…... protected: //…… int gpa; }; void Teacher:: ::assignGrades(Student&s) { s.gpa=4.0;}
运行例题 进VC环境
友元成员函数
友元成员函数是在类声明中由关键字 friend修饰说明的另一个类的成员函数 ，在它的函数体中能够通过对象名访问 该类中的private 和 protected成员 作用：增加灵活性，使程序员可以在封 装和快速性方面做合理选择。 访问对象中的成员必须通过对象名。
11
double fDist( Point& a, Point& b) { double dx=a.X-b.X; double dy=a.Y-b.Y; return sqrt(dx*dx+dy*dy); } int main() { Point p1(3.0, 5.0), p2(4.0, 6.0); double d=Distance(p1, p2); cout<<"The distance "<<d<<endl; return 0; }
YourClass(int t=0):topSecret(t){} int GetTopSecret(){return topSecret;}
c++关于友元函数的例子
1. 友元定义:一般来说，仅仅只有类的成员函数能访问类的私有或者保护成员，如果我们声明一个公共的函数作为这个类的友元，这个函数也可以访问类的私有成员。
友元是C++里面用来破坏类的封装的一个机制。
我们可以使用类的友元或者类的友元函数.2.友元函数友元函数是类的非成员函数（普通函数），在类的里面声明，必须在函数前面加上关键词“friend”。
和普通函数类似，友元函数能够在类的里面或者外面被实现。
友元函数必须通过类的对象名来访问类的数据成员。
友元函数的例子-computing distance between two points源程序：#include <iostream.h>#include <math.h>class Point{public:Point(double xx=0, double yy=0);double GetX() {return X;}double GetY() {return Y;}friend double Dist(Point &a, Point &b);private:double X,Y;};Point::Point(double xx, double yy){X=xx; Y=yy;}double Dist( 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, 5.0), p2(4.0, 6.0);double d=Dist(p1, p2);cout<<"The distance is "<<d<<endl;cout<<p1.GetX()<<"\t"<<p1.GetY()<<endl; }运行结果:3. 友元类如果一个B类是另一个A类的友元，那么B类所有的成员函数能够访问A类的所有成员，反之，亦然。
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() 是一个全局范围内的非成员函数，它不属于任何类，它的作用是输出学生的信息。
c++友元函数、友元类、友成员函数
c++友元函数、友元类、友成员函数友元函数：不是类成员函数，是⼀个类外的函数，但是可以访问类所有成员。
class Point{public:friend void fun(Point t);//友元函数private:int a;protected:int b;};void fun(Point t){t.a = 100;t.b = 2000;cout << t.a << "" << t.b << endl;}int main(){Point test;fun(test);system("pause");return0;}运⾏结果：友元类：类A是类B的友元类，则A就可以访问B的所有成员（成员函数，数据成员）。
（类A，类B⽆继承关系）class Point{friend class Line;public:void fun(){this->x = 100;this->y = 120;}private:int x;protected:int y;};class Line{public:void printXY(){t.fun();cout << t.x << "" << t.y << endl;}private:Point t;};int main(){Line test;test.printXY();system("pause");return0;}运⾏结果：友成员函数：使类B中的成员函数成为类A的友元函数，这样类B的该成员函数就可以访问类A的所有成员（成员函数、数据成员）了 1class Point;//在此必须对Point进⾏声明，如不声明将会导致第5⾏（void fun(Point t);）“Point”报错（⽆法识别的标识符）23class Line{4public:5void fun(Point t);6//void Line::fun(Point t)//在此编译器⽆法获知class Point中到底有哪些成员，所以应在Point后⾯定义7//{8// t.x = 120;9// t.y = 130;10// t.print();11//}1213};1415class Point{16public:17 friend void Line::fun(Point t);18 Point(){}19void print()20 {21 cout << this->x << endl;22 cout << this->y << endl;23 }24private:25int x;26protected:27int y;28};2930void Line::fun(Point t)//应在此定义fun函数31{32 t.x = 120;33 t.y = 130;34 t.print();35}3637int main()38{39 Point test;40 Line LL;41 LL.fun(test);42 system("pause");43return0;44 }运⾏结果：总结：关键字“friend”描述的函数就是友元函数，“friend”所在类的所有成员都可被友元函数访问。
友元函数
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; }
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
友元函数及友元类已有 20621 次阅读 2009-5-9 15:43 |个人分类:C/C++什么是友元（friend）？允许另一个类或函数访问你的类的东西。
友元可以是函数或者是其他的类。
类授予它的友元特别的访问权。
通常同一个开发者会出于技术和非技术的原因，控制类的友元和成员函数（否则当你想更新你的类时，还要征得其它部分的拥有者的同意）。
分清成员函数，非成员函数和友元函数成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。
所以，如果有个函数必须进行动态绑定，就要采用虚拟函数，而虚拟函数必定是某个类的成员函数。
关于这一点就这么简单。
如果函数不必是虚拟的，情况就稍微复杂一点。
Ø类的主要特点之一是数据隐藏，即类的私有成员只能在类定义的范围内使用，也就是说私有成员只能通过它的成员函数来访问。
Ø但是，有时候需要在类的外部访问类的私有成员。
为此，就需要寻找一种途径，在不放弃私有数据安全性的情况下，使得类外部的函数或类能够访问类中的私有成员，在C++中就用友元作为实现这个要求的辅助手段。
ØC++中的友元为数据隐藏这堵不透明的墙开了一个小孔，外界可通过这个小孔窥视类内部的秘密，友元是一扇通向私有成员的后门。
Ø友元可分为：友元函数，友元成员，友元类。
Ø友元函数不是当前类的成员函数，而是独立于当前类的外部函数，但它可以访问该类的所有对象的成员，包括私有成员和公有成员。
Ø在类定义中声明友元函数时，需在其函数名前加上关键字friend。
此声明可以放在公有部分，也可以放在私有部分。
友元函数可以定义在类的内部，也可以定义在类的外部。
1.友元函数虽然可以访问类对象的私有成员，但它毕竟不是成员函数。
因此，在类的外部定义友元函数时，不必像成员函数那样，在函数名前加上“类名::”。
2.友元函数一般带有一个该类的入口参数。
因为友元函数不是类的成员，所以它不能直接引用对象成员的名称，也不能通过this指针引用对象的成员，它必须通过作为入口参数传递进来的对象名或对象指针来引用该对象的成员。
3.当一个函数需要访问多个类时，友元函数非常有用，普通的成员函数只能访问其所属的类，但是多个类的友元函数能够访问相应的所有类的数据。
例程序2使用一个友元函数访问两个不同的类4.友元函数通过直接访问对象的私有成员，提高了程序运行的效率。
在某些情况下，如运算符被重载时，需要用到友元。
但是友元函数破坏了数据的隐蔽性，降低了程序的可维护性，这与面向对象的程序设计思想是背道而驰的，因此使用友元函数应谨慎。
Ø除了一般的函数可以作为某个类的友元外,一个类的成员函数也可以作为另一个类的友元,这种成员函数不仅可以访问自己所在类对象中的私有成员和公有成员,还可以访问friend声明语句所在类对象中的私有成员和公有成员,这样能使两个类相互合作、协调工作,完成某一任务。
Ø例程序3使用友元成员函数访问另一个类说明：1.一个类的成员函数作为另一个类的友元函数时，必须先定义这个类。
例如上例中，类boy的成员函数为类girl的友元函数，必须先定义类boy。
并且在声明友元函数时，要加上成员函数所在类的类名，如：friend void boy::disp(girl &);2.程序中还要使用“向前引用”，因为函数disp()中将girl &作为参数，而girl要晚一些时候才定义。
Ø不仅函数可以作为一个类的友元，一个类也可以作为另一个类的友元。
这种友元类的说明方法是在另一个类声明中加入语句“friend 类名;”，其中的“类名”即为友元类的类名。
此语句可以放在公有部分也可以放在私有部分，例如：class Y{//……};class X{//……friend Y;//……};Ø当一个类被说明为另一个类的友元时，它的所有的成员函数都成为另一个类的友元函数，这就意味着为友元的类中的所有成员函数都可以访问另一个类的私有成员。
例程序4友元类说明：1.友元关系是单向的，不具有交换性（我是你的朋友，不能推断出：你是我的朋友）。
2.友元关系也不具有传递性（我是你的朋友，你是他的朋友，不能推断出：我是他的朋友）。
通过下面几个程序我们来了解一下友元函数程序1 使用友元函数#include <iostream.h>#include <string.h>class girl{private:char *name;int age;public:girl(char *n,int d){ name=new char[strlen(n)+1];strcpy(name,n);age=d;}friend void disp(girl &); //声明为友元函数~girl(){delete name;}};void disp(girl &x) //定义友元函数{cout<<"girl\'s nameis:"<<<<",age:"<<x.age<<endl;}void main(){girl e("Chen Xingwei",18);disp(e); //调用友元函数}程序2使用一个友元函数访问两个不同的类#include <iostream.h>#include <string.h>class boy; //向前引用class girl{char name[25];int age;public:void init(char N[],int A);friend void prdata(const girl plg,const boy plb); //声明函数为girl 类的友元函数};void girl::init(char N[],int A){ strcpy(name,N);age=A;}class boy{char name[25];int age;public:void init(char N[],int A);friend void prdata(const girl plg,const boy plb); //声明函数为boy类的友元函数};void boy::init(char N[],int A){ strcpy(name,N);age=A;}void prdata(const girl plg,const boy plb){cout<<"女孩"<<<<','<<plg.age<<"岁；";cout<<"男孩"<<<<','<<plb.age<<"岁。
\n";}void main(){ girl G1,G2,G3;boy B1,B2,B3;G1.init("Stacy",12);G2.init("Judith",13);G3.init("Leah",12);B1.init("Jim",11);B2.init("Micheal",13);B3.init("Larry",12);prdata(G1,B1);prdata(G2,B2);prdata(G3,B3);}程序3使用友元成员函数访问另一个类#include <iostream.h>#include <string.h>class girl; //向前引用class boy{char *name;int age;public:boy(char *N,int A){ name=new char[strlen(N)+1];strcpy(name,N);age=A;}void disp(girl &); //声明disp()为类boy的成员函数~boy(){delete name;}};class girl{char *name;int age;public:girl(char *N,int A){ name=new char[strlen(N)+1];strcpy(name,N);age=A;}friend void boy::disp(girl &); //声明类boy的成员函数disp()为类girl 的友元函数~girl(){delete name;}};void boy::disp(girl &x){cout<<"boy\'s nameis:"<<name<<",age:"<<age<<endl; //访问本类对象成员cout<<"girl\'s nameis:"<<<<",age:"<<x.age<<endl; //访问友元类对象成员}void main(){ boy b("chen hao",25);girl g("zhang wei",18);b.disp(g);}友元类程序4 boy为girl的友元类#include <iostream.h>#include <string.h>class girl;class boy{char *name;int age;public:boy(char *n,int d){ name=new char[strlen(n)+1];strcpy(name,n);age=d;}void disp(girl &); //声明disp()为类boy的成员函数~boy(){delete name;}};class girl{char *name;int age;friend boy; //声明类boy是类girl的友元public:girl(char *n,int d){ name=new char[strlen(n)+1];strcpy(name,n);age=d;}~girl(){delete name;}};void boy::disp(girl &x) //定义函数disp()为类boy的成员函数，也是类girl 的友元函数{ cout<<;"boy\'s name is:"<<name<<",age:"<<age<<endl; cout<<"girl\'s nameis:"<<<<",age:"<<x.age<<endl;}void main(){ boy b("chen hao",25);girl g("zhang wei",18);b.disp(g);}。