C++友元函数讲解
C++教学 第9章+友元函数与运算符重载
float v1(A &a) { return PI*a.r*a.r*a.h;} //友元函数volum在类体外定义 float v3(A b) //普通函数 { return PI*b.getr()*b.getr()*b.geth();} void main() { A a1(25,40); A a2(25,40); cout<<v1(a1)<<"\n"; //友元函数的调用 cout <<a2.v2( )<<"\n"; cout<<v3(a1); }
对于大多数程序设计语言，运算符的定义由编译器给出，且 这种用法是不允许用户改变的。在C++中，允许用户重新定 义已有的运算符，并按规定要求去完成特定的操作。 使用成员函数或友元函数，通过操作对象成员，从而实现对 象参加运算的目的。
10
运算符重载函数的定义格式如下： （1）运算符重载函数定义为类的成员函数 函数类型 operator 运算符 （参数表） { …… }
15
9.3 一元运算符重载 C++中允许重载的一元运算符有: 自增运算符“++”、自减运算符“--”、 负号运算符“-”、逻辑非运算符“!”等。
16
9.3.1 用成员函数重载一元运算符
用成员函数重载“++”运算符的格式为： （1）++为前缀形式 函数类型 operator++（void） { 函数体 } （2）++为后缀形式 函数类型 operator++（int） { 函数体 } 重载自减运算符“--”的格式与重载“++”运算符类似。
C.C++友元函数&友元类
友元TAG:面向对象程序设计,面向对象的语言实现C++,友元TEXT:有时两个类或一个函数与某个类之间的关系十分密切，为了程序运行效率着想，希望这个函数和类可以像另一个类的成员一样无限制地存取它的所有成员，同时还希望在形式上尽量保持类的独立性和封装性。
为了解决这类问题，C++提供了友元的概念，一个类的友元可以存取这个类的所有成员，包括私有成员。
友元一般分为两种一一友元函数和友元类。
REF:.txt,友元函数.txt,友元类.txt友元函数TAG:面向对象程序设计,面向对象的语言实现C++,友元,友元函数TEXT:在类中可以将另一个函数声明为这个类的友元，这时,虽然这个函数可能是位于另一个文件中的外部函数或属于另一个类的成员函数，但它却具有了访问本类所有成员的权限，如同是本类的一个成员一样。
说明友元函数的方法如下。
[例2] 友元函数的说明示例。
#include "iostream.h"#include "math.h"class CPoint{private:double m_x;double m_y;public:CPoint(double x,double y){m_x=x;m_y=y;}double GetX(){ return m_x;}double GetY(){ return m_y; }friend double GetDistance(CPoint&a, CPoint&b);};double GetDistance(CPoint &a,CPoint &b){double x_increament=a.m_x- b.m_x;double y_increament=a.m_y- b.m_y;return sqrt(x_increament*x_increament+y_increament*y_increament)}void main(){CPoin pt1(3,5),pt2(6,8);cout<<"The distance is"<<GetDistance(pt1,pt2)<<endl;}上面程序中的函数GetDistance()被说明为类CPoint类的友元函数，因为计算两个点之间距离这个函数很常用，而这个丽数显然同类CPoint有着密切的联系。
C++中成员函数和友元函数的使用及区别详解
C++中成员函数和友元函数的使⽤及区别详解为什么使⽤成员函数和友元函数这个问题⾄关重要，直接影响着后⾯的理解：程序数据：数据是程序的信息，会受到程序函数的影响。
封装是⾯向对象编程中的把数据和操作数据的函数绑定在⼀起的⼀个概念，这样能避免受到外界的⼲扰和误⽤，从⽽确保了安全。
数据封装引申出了另⼀个重要的 OOP 概念，即数据隐藏。
数据封装是⼀种把数据和操作数据的函数捆绑在⼀起的机制，数据抽象是⼀种仅向⽤户暴露接⼝⽽把具体的实现细节隐藏起来的机制。
C++ 通过创建类来⽀持封装和数据隐藏（public、protected、private）。
我们已经知道，类包含私有成员（private）、保护成员（protected）和公有成员（public）成员。
默认情况下，在类中定义的所有项⽬都是私有的。
由于C++的封装和隐藏特性，只有类定义的成员函数可以访问类定义的私有数据。
成员函数是数据封装和数据隐藏的机制。
友元是C++提供的⼀种破坏数据封装和数据隐藏的机制。
成员函数的使⽤⾸先先看代码class Stock{ //class declarationprivate:std:: string company;long shares;double share_val;double total_val;void set_tot(){ total_val=shares* share_val;}public:void acquire(const std:: string & co, long n, double pr);void buy(long num, double price);void se11(long num, double price);void update(double price);void show();};//note semicolon at the end注意这⾥⾯的private可以不写，如果不写的话默认是私有的。
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 函数什么也不做。
第6讲 友元函数和友元类
友元函数
友元函数对类中成员的访问
– 一个类的友员函数与该类的类内成员函数一 样，享有对该类一切成员的访问权。 –但必须在参数表中显式指明要访问的对象。
友元函数的调用
–与一般函数的调用方式和原理一致。
一个函数可以是多个类的友元函数，不过需 要在各个类中分别声明
友元函数的定义和使用方法例子
#include <iostream.h> class X1 结果： { private: 用友元函数求各和：3 int x; 用普通函数调用类公共接口函数求和：3 public: X1(int i) { x=i; } void main() int getx(); { X1 m(1); friend void sum(X1 &a, X1 &b); //声明友元函数 X1 n(2); }; sum(m,n); int X1::getx() sum1(m,n); { return x;} } void sum(X1 &a,X1 &b) //定义函数 {cout<<"用友元函数求各和："<<a.x+b.x<<endl; //可以访问类的私有成员} void sum1(X1 &a,X1 &b) //定义普通函数 {cout<< "用普通函数调用类公共接口函数求和：" <<a.getx()+b.getx()<<endl; }
友元的分类
友员函数 友员类
2.6.1 友元函数 友元函数
–是可以直接访问类的私有成员的非成员函数。 –它是在类外定义的普通函数，不属于任何类，但需要 在类的定义中加以声明
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）？友元函数要在一个类体内说明,形式为:展开友元函数（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
类模板使用方式： 类模板使用方式： 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++运算符重载三种形式（成员函数，友元函数，普通函数）详解
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::只是指定了成员函数所属类名。
02 C++课件 类与对象(8)-友元
友元函数
注意: 注意: 访问对象中的成员必须通过对象名. 访问对象中的成员必须通过对象名. 虽然类中有友元函数的原型, 但是友元 虽然类中有友元函数的原型 , 仍然不是成员函数. 仍然不是成员函数.
友元函数
class A private: { private: 说明语句位置 int num ; public: public: 与访问描述无关 void MemberFun(int) ; friend void FriendFun(A * , int) ; } ; void FriendFun( A * ptr , int x ) 友员函数通过对象参数 { ptr -> num = x ; } 访问私有数据成员 void A:: MemberFun( int x ) { num = x ; } void A:: MemberFun( int x ) this{ this-> num = x ; }
第九讲 友元
友元
特点: 特点
友元可以访问与其有好友关系的类中的所有 友元可以访问与其有好友关系的类中的所有 成员包括私有成员. 包括私有成员 成员包括私有成员.
意义: 意义
提高访问效率增加灵活性,程序员可以在封 提高访问效率增加灵活性, 装和快速性方面做合理选择. 装和快速性方面做合理选择. 为了确保数据的完整性, 为了确保数据的完整性,及数据封装与隐藏 的原则,建议尽量不使用或少使用友元. 的原则,建议尽量不使用或少使用友元.
友元关系不具有交换性. 友元关系不具有交换性.
类A是类 的友元,但并不表示类B是类 的 是类B的友元,但并不表示类 是类A的 是类 的友元 是类 友元. 友元.
代码练习
设计描述位置的一个点类Point 设计描述位置的一个点类 其属性为其x,y坐标 坐标, 其属性为其 坐标, 包括设置坐标, 包括设置坐标,显示位置等方法 要求: 要求: 定义构造函数,复制构造函数; 定义构造函数,复制构造函数; 定义静态成员变量total,存放当前点的数目. 存放当前点的数目. 定义静态成员变量 存放当前点的数目 定义求两点距离的友元函数distance. 定义求两点距离的友元函数 .
c++中的友元
c++中的友元为什么要有友元函数？简单地说，通常对于普通函数来说,要访问类的保护成员是不可能的，如果想这么做那么必须把类的成员都生命成为public(共用的)，然而这做带来的问题遍是任何外部函数都可以毫无约束的访问它操作它，c++利用friend修饰符，可以让一些你设定的函数能够对这些保护数据进行操作，避免把类成员全部设置成public，最大限度的保护数据成员的安全。
除了友元函数外，还有友元类，两者统称为友元。
友元的作用是提高了程序的运行效率（即减少了类型检查和安全性检查等都需要时间开销），但它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员.一、使用友元函数调用类成员#include <cstring.h>#include <iostream.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 display(girl &); //声明为友元函数~girl(){delete name;}};//定义友元函数，这里把对象作为参数传递，为防止传值时，（对象）局部变量可能产生的巨大花费，一般以传引用的调用方式进行，若想保证源参数不被修改，可以加上const．void display(girl &x){cout<<"girl\'s name is:"<<<<",age:"<<x.age<<endl;}void main(){girl a("Alice",24);display(a); //调用友元函数}二、一个友元函数访问两个不同的类#include <iostream>#include <cstring>using namespace std;class boy; //需要先声明，因为girl成员函数中有对其的引用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<<"岁；"<<endl;cout<<"男孩"<<<<','<<plb.age<<"岁。
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++ 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() 是一个全局范围内的非成员函数，它不属于任何类，它的作用是输出学生的信息。
11.4.1 友元函数_C++从入门到精通_[共2页]
![11.4.1 友元函数_C++从入门到精通_[共2页]](https://img.taocdn.com/s3/m/686985ed580216fc710afdc5.png)
244 【范例分析】本范例中，定义了一个类Test ，在类中定义了该类的构造函数和析构函数，在main()函数中创建了4个对象分别调用构造函数进行初始化。
程序结束时，编译系统自动调用4个对象的析构函数，并输出信息。
本范例表明，析构函数与构造函数二者的调用次序相反，即最先构造的对象最后被析构，最后构造的对象最先被析构。
11.4 友元 本节视频教学录像：23分钟在C++中，为了使得类的私有成员和保护成员能够被其他类或其他成员函数访问，引入了友元的概念。
比如我们可以将客户定义为类的“朋友”，如果客户成为类的“朋友”，就可以直接存取类的保护成员和私有成员。
类的“朋友”称为类的友元，友元可以是一个普通函数、另一个类的成员函数或另外一个类。
11.4.1 友元函数当一个普通函数或一个类的成员函数需要经常访问另一个类中的数据时，由于不能直接访问另一个类的私有数据成员，而必须通过调用公用成员函数来实现，因此带来了很低的访问效率。
为了提高访问效率，C++允许在一个类中把一个普通函数或一个类的成员函数声明为它的友元函数。
被声明为一个类的友元函数具有直接访问该类的保护或私有成员的特权。
声明友元函数的语句以保留字friend 开始，后面跟一个函数或类的声明。
在C++中，将普通函数声明为友元函数的一般形式为：friend<数据类型><友元函数名>(参数表)；【范例11-9】 友元函数的应用。
➊ 在Visual C++ 6.0中，新建名称为“Friend Function ”的【C++ Source File 】源文件。
➋ 在代码编辑区域输入以下代码（代码11-9.txt ）。
01 #include <iostream.h>//是指标准库中输入输出流的头文件， cout 就定义在这个头文件里 02 class CPoint//定义类03 {04 public:05 CPoint( unsigned x, unsigned y )//定义构造函数 06 {07 m_x = x;08 m_y = y;//初始化成员 09 }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1 友元函数
//func.cpp #include<cmath> Point::Point(int x1,int y1): X(x1),y(y1) { } Line::Line(int a1,int b1,int c1) :a(a1),b(b1),c(c1) {}
double dis(Line m,Point n) { double d; d=abs(m.a*n.x+m.b*n.y +m.c)/(sqrt(m.a*m.a +m.b*m.b)); return d;} int main() { Point p(10,10); Line t(2,4,-3); cout<<“点到线的距 离:”<<dis(t,p)<<endl; } // 12.7456
友元函数
Biblioteka 概念:友元函数就是可以直接访问类的成员(包 括私有数据成员)的非成员函数.它是一个外部 函数. 一个外部函数只能通过类的授权而成为友元函 数.
友元函数
类如何授权一个函数作为友元函数? 答:通过在类的定义中声明函数,并且在该函数 的声明前加上关键字friend,这样类和该函数之 间创建了友元关系.关键字friend不能够在类的 定义之外使用. 注:类的访问限定符(public,private和 protected)对友元函数是不起作用的. 内容对应教材：9.10节
友
元
引子
因为C++的封装性和数据隐藏性,只有类自身 的函数才可以不受限制的访问类的非公有成员; 任何非成员函数直接访问类中非公有数据成员 都会导致编译错误. 例外情况:需要非成员函数去访问类的私有数 据成员. ♂解决办法:1,把私有属性(private)变为公有 (public)-----但这样做违背了数据封装性和数 据隐藏性; 2,可把对应的非成员函数定义为该 类的友元函数来解决.
[用例] #include<iostream> class A { int n; public: A() {n=5;} friend class B; }; class B { public:
void display( A t) { cout<< “n=“<<t.n<<endl;} }; int main() { A a; B b; b.display(a); }
1 友元函数
声明友元函数的方式是在类声明中用关键词friend声 明该函数，其格式 如下： friend 函数类型 友元函数名(参数表);
北京科海电子出版社 · <<<
1 友元函数
[用例]P152 例,补充完整,编译运行.
1 友元函数
【用例】编写一个程序，以友元函数方式计算一个点到一条直线的距 离。 解：设计一个点类Point，它有两个公有数据成员x和y，表示点的坐标 （因为要在类外使用，所以设计为公有的）。另一个类为直线类Line， 它有3个私有数据成员a、b和c，表示直线方程ax+by+c=0，该类中设
class Line //线类 { public: Line(int,int,int); friend double dis(Line,point); //计算 距离 private: int a,b,c; }; #endif
北京科海电子出版社 · <<<
计一个友元函数dist计算一个点到直线的距离。点（x，y）到直线
（ax+by+c=0）的距离d的计算公式如下：
d = ax + b y + c a +b
2 2
北京科海电子出版社 · <<<
1 友元函数
//file.h #ifndef FILE_H #define FILE_H class Point //点类 { Public: Point(int,int); int x,y; };
2友 元 类
C++中允许声明一个类为另一个类的友元类（friend class）。例如， 以下语句声明类B是类A的友元类： class A { ...
public:
friend class B; ...
};
北京科海电子出版社 · <<<
2友元类