友元(友元函数、友元类和友元成员函数) C++ - zhuguanhao - 博客园
随笔 - 22, 文章 - 0, 评论 - 4, 引用 - 0
& & & & 有些情况下，允许特定的非成员函数访问一个类的私有成员，同时仍阻止一般的访问，这是很方便做到的。例如被重载的操作符，如输入或输出操作符，经常需要访问类的私有数据成员。
& & & &&友元(frend)机制允许一个类将对其非公有成员的访问权授予指定的函数或者类，友元的声明以friend开始，它只能出现在类定义的内部，友元声明可以出现在类中的任何地方：友元不是授予友元关系的那个类的成员，所以它们不受其声明出现部分的访问控制影响。通常，将友元声明成组地放在类定义的开始或结尾是个好主意。
1、友元函数
&& & 友元函数是指某些虽然不是类成员函数却能够访问类的所有成员的函数。类授予它的友元特别的访问权，这样该友元函数就能访问到类中的所有成员。
#include &iostream&
using namespace
friend void set_show(int x, A &a);
//该函数是友元函数的声明
void set_show(int x, A &a)
//友元函数定义，为了访问类A中的成员
cout && a.data &&
int main(void)
set_show(1, a);
& & & &&友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。
关于友元类的注意事项：
(1) 友元关系不能被继承。(2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。(3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明。
#include &iostream&
using namespace
friend class C;
//这是友元类的声明
//友元类定义，为了访问类A中的成员
void set_show(int x, A &a) { a.data = cout&&a.data&&}
int main(void)
c.set_show(1, a);
3、友元成员函数
& & & & 使类B中的成员函数成为类A的友元函数，这样类B的该成员函数就可以访问类A的所有成员了。
& & & & 当用到友元成员函数时，需注意友元声明和友元定义之间的相互依赖，在该例子中，类B必须先定义，否则类A就不能将一个B的函数指定为友元。然而，只有在定义了类A之后，才能定义类B的该成员函数。更一般的讲，必须先定义包含成员函数的类，才能将成员函数设为友元。另一方面，不必预先声明类和非成员函数来将它们设为友元。
#include &iostream&
using namespace
//当用到友元成员函数时，需注意友元声明与友元定义之间的互相依赖。这是类A的声明
void set_show(int x, A &a);
//该函数是类A的友元函数
friend void B::set_show(int x, A &a);
//该函数是友元成员函数的声明
void show() { cout && data && }
void B::set_show(int x, A &a)
//只有在定义类A后才能定义该函数，毕竟，它被设为友元是为了访问类A的成员
cout && a.data &&
int main(void)
b.set_show(1, a);
友元小结：
& & & & 在需要允许某些特定的非成员函数访问一个类的私有成员（及受保护成员），而同时仍阻止一般的访问的情况下，友元是可用的。
& & & & 可以灵活地实现需要访问若干类的私有或受保护的成员才能完成的任务；
& & & &&便于与其他不支持类概念的语言(如、汇编等)进行混合编程；
& & & &&通过使用友元函数重载可以更自然地使用C++语言的IO流库。
& & & &&一个类将对其非公有成员的访问权限授予其他函数或者类，会破坏该类的封装性，降低该类的可靠性和可维护性。
参考资料：
1、《C++ Prime》第4版 第12章类的友元小节
http://blog.csdn.net/u/article/details/C++中的friend友元函数详细解析
&更新时间：日 09:25:42 & 作者：
友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类。友元函数的特点是能够访问类中的私有成员的非成员函数。友元函数从语法上看，它与普通函数一样，即在定义上和调用上与普通函数一样
友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend。
我们已知道类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程序中的其他函数是无法访问私有成员的。非成员函数可以访问类中的公有成员，但是如果将数据成员都定义为公有的，这又破坏了隐藏的特性。另外，应该看到在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递，类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。
为了解决上述问题，提出一种使用友元的方案。友元是一种定义在类外部的普通函数，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效率（即减少了类型检查和安全性检查等都需要的时间开销），但是，它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。
友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类。
友元函数的特点是能够访问类中的私有成员的非成员函数。友元函数从语法上看，它与普通函数一样，即在定义上和调用上与普通函数一样。 代码如下:#include "cmath"#include "iostream"class Point{public:&&&&& Point(double xx,double yy)&&&&& {&&&&&&&&& x=&&&&&&&&& y=&&&&& }&&&&& void GetXY();&&&&& friend double Distance(Point &a,Point &b);protected:private:&&&&& double x,y;};void Point::GetXY(){&&&& //cout&&"("&&this-&x&&","&&this-&y&&")"&&&&&& cout&&"("&&x&&","&&y&&")"&&}double Distance(Point &a,Point &b){&&&&&&&& length=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));&&&& //它可以引用类中的私有成员&&&&}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&&&&&& system("pause");&&&& return 0;}说明：在该程序中的Point类中说明了一个友元函数Distance()，它在说明时前边加friend关键字，标识它不是成员函数，而是友元函数。它的定义方法与普通函数定义一样，而不同于成员函数的定义，因为它不需要指出所属的类。但是，它可以引用类中的私有成员，函数体中的a.x，b.x，a.y，b.y都是类的私有成员，它们是通过对象引用的。在调用友元函数时，也是同普通函数的调用一样，不要像成员函数那样调用。本例中，p1.Getxy()和p2.Getxy()这是成员函数的调用，要用对象来表示。而Distance(p1, p2)是友元函数的调用，它直接调用，不需要对象表示，它的参数是对象。(该程序的功能是已知两点坐标，求出两点的距离。)
下面对上面的代码进行输入、输出流的重载： 代码如下:#include &cmath&#include &iostream&class Point{public:&&&&& Point(double xx,double yy)&&&&& {&&&&&&&&&& x=&&&&&&&&&& y=&&&&& }&&&&& 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&&")"&&&&&&}void Point::GetXY(){&&&& //cout&&"("&&this-&x&&","&&this-&y&&")"&&&&&& //cout&&"("&&x&&","&&y&&")"&&&&&& cout&&*}double Distance(Point &a,Point &b){&&&&&&&& length=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));&&&&}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&&&&&& system("pause");&&&& return 0;}
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具class A{public:
bool kk(int i){return i&1;}};typedef bool (A::* XXX)(int);int main(){
XXX p = NULL;
p = &A:: // pointer to member function kk in class A;
A *pa = new A;
(pa-&*p)(10); // to call a member function from pointer, must specific a pointer to class first}
收获园豆：4
|园豆：557
其他回答(1)
不能,静态函数可以.你申明友元函数时应该把 Preprocess*&作为参数传入.
class Preprocess{public:
Preprocess(void);
~Preprocess(void);public:
typedef vector&string&(Preprocess::*FUNCSEG)(string,set&string&);
vector&string& goodWordsinPieceArticle(string rawtext,set&string& stopwords);
int ConstructMap(map&string,vector&pair&int,int&&&&mymap,char *dbfield,FUNCSEG seg)
set&string&
vector&string&wordcollection = (this-&*seg)(rawtext,stopwords);
void WriteTotalArff(int DFthreshlod,bool isbagOfwordsexsist)
char * dbfield="CAbstract";
FUNCSEG seg=&Preprocess::goodWordsinPieceA
map&string,vector&pair&int,int&&&
ConstructMap(mymap,dbfield,seg);
把你的代码简化了下,如上所示.
收获园豆：1
园豆：44916
园豆：44916
清除回答草稿
&&&您需要以后才能回答，未注册用户请先。先看下操作重载的定义和要求：
要进行操作符重载首先要求是自定义类型的运算
写法格式：返回值 operator运算符(参数列表){}
重载的要求：
1、内置类型的操作符不能被重载
2、不能为内置类型定义其他的操作符
3、操作符重载不能改变操作符的优先级
4、操作数个数不能改变
重载运算符时，函数声明在类内和类外是有区别的，比方说+-*/等需要2个操作数的运算符，
当声明在类的外部时，则参数列表为2个参数，第一个参数为运算符左边的操作数，而第二个参数为
操作符右边的操作数：如下
classType operator+(classType& left, classType& right);
而当函数声明在类的内部时，即为类的成员函数时，
classType operator+(classType& right );
而第一个操作数就是调用该操作符的对象的引用，第二个操作数是传进来的参数，
所以，如果要重载&&运算符，一般写法是这样的
ostream& operator&&(ostream& os, const classType& obj);
则第一个参数是该运算符的第一个操作数，然而，却不是类对象，
所以当该类运算符重载时写在类的内部时，又为了访问类内除public外的其它变量或函数，
则应当声明为友元函数：
friend ostream& operator&&(ostream& os, const classType& obj);
所以，为什么有些运算符的重载要声明为友元函数，是类似的。
c++友元函数及运算符重载
前言： c++的类和java的类机制着实不大一样，不仅仅是语法，还包括一些特殊的东西，如c++用友元函数来破坏类的封装性，使得外界（友元函数体）可以访问类的私有属性，而java呢，java则可以通过反...
重载输入输出运算符
原文链接：http://blog.csdn.net/lyh__521/article/details/重载输入输出运算符
我们平时可以用流 std:: 输出、输入字符...
输出运算符重载&&为什么一定要使用友元呢
因为当我们使用成员函数的时候，比如
Coordinate operator+(const Coordinate &coor)
temp.m_iX = this0&...
为什么operator&&&&运算符重载一定要为友元函数呢？
如果是重载双目操作符（即为类的成员函数），就只要设置一个参数作为右侧运算量，而左侧运算量就是对象本身。。。。。。
或。。。。。。。。就只能申明为友元函数了。。。
如果一定要声明为成员函...
C++之运算符重载函数作为友元函数
#include &iostream&class Complex{ public:
real=0; ...
C++运算符重载（注意点），友元（使用和优缺点）
运算符重载实例代码class A{
A(int _a=0,int _b=0):a(_a),b(_b){}
A operator+(A & tm...
重载运算符与友元函数
本次博客 主要学习运算符重载和友元函数。其中
运算符重载能够将平时用于内置类型的变量的操作符(如+，-，*，/等)用于类对象；
友元这种C++机制使得非成员函数可以访问私有数据。...
C++ 重载运算符 友元函数作为重载运算符 重载运算符+
以友元函数作为重载运算符的方式重载运算符+
下面的例子来自于课本
class Complex
c++中输入输出流为什么必须重载为友元
若是将输入输出流重载为类的成员函数，形式为:
cout.operator
因为cout类的opetator
操作符重载过程中，需要用的类的成员变量，所以只是重载为全局函数，无法使用类的成员变量，所以讲...
没有更多推荐了，151 条评论分享收藏感谢收起赞同 2 条评论分享收藏感谢收起写回答