昨天发现一个关于友元的有趣的编译差别。_c++吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：227,278贴子：
昨天发现一个关于友元的有趣的编译差别。收藏
在BCB6上写了一个库，库的功能是，生成一个组件管理器，然后组件管理器统一管理某种不定数量的组件，管理器负责创建和销毁组件，通过管理器内的指针数组来定向组件，本来是挺简单的一个事情。管理器需求是一个进程最多只能有一个实例，于是就用了构造函数私有化，然后加静态初始化函数，来实现唯一实例。由于想控制组件必须由管理器生成销毁，所以就吧组件的构造函数也私有化了，在管理器中搞一个静态友元生成函数，这个代码实现简单，然后在BCB6下面过了。然后昨天我试了一下DEV和CB，然后竟然过不了，报错，一大堆错误。。。搞的头大，然后我又去看了一下代码，发现没有啥错误，唯一可能的错误就是友元定义。于是就随手网上拉了一个友元实例代码，然后少许改编一下，把例子中的友元函数给私有化，放在BCB6上，果然就过了。然后这个简单的代码放在DEV和CB上果然不能过。发现一个非常有趣的现象，BCB可以声明一个类的私有方法为友元，但GCC却不行。
//===========上例子程序代码============//*************************************************************////
//// 关于友元函数和限定类实例的最大数量实例代码
////*************************************************************////---------------------------------------------------------------------------#include&iostream&
#pragma hdrstop//---------------------------------------------------------------------------#pragma argsused#define
_MAX_BOYS 4
//这个宏义是定义了b0y类最大产生对象的数量。
class boy{private:
boy(char *N,int A);
/*&&---关键在这里，这行代码BCB6能过，GCC不能过。
把这个私有的构造函数挪到public块中，GCC就能过。*/public:
static boy* newboy(char *n,int a);//静态初始化函数，确保类只生成有限的对象个数
void disp();
};class girl{private:
girl(char *N,int A);
//通过声明私有构造函数限制其他代码创造对象
boy::boy(char *N,int A);
//通过声明类的私有友元函数，来确保类必须在某个对象的特定函数中生成。
//但是要记得在所有者对象结构之前释放对象。
friend void boy::disp();
/*这行验证声明友元构造函数不等于声明友元类,去除友元声明将产生编译错误。
这个例子说明了声明某个类的构造函数为友元，
但类本身并不是友元，类中的其他函数无法访问本类的私有变量或函数 */public:
}; boy* boy::newboy(char *n,int a) { static int counter=0; if(counter&_MAX_BOYS) {counter++;return new boy(n,a);}
//判断对象数量，_MAX_BOYS最大数来限定对象生成的数量 else
cout&&&Boy超过限定数量初始化失败，程序限定Boy最多不超过&&&counter&&&个。&&&
return NULL;
}boy:: boy(char *N,int A){
mg=new girl(&ggg&,12);
}girl:: girl(char *N,int A){
}void boy::disp(){
cout&&&boy's name is:&&&name&&&,age:&&&age&&
cout&&&girl's name is:&&&mg-&name&&&,age:&&&mg-&age&&
//借助友元，在boy的成员函数disp中，通过指针访问girl的私有变量
//正常情况下，只允许在girl的成员函数中访问girl的私有变量
// open the file &file_name.txt&
// for reading
boy * Boy[10]={NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
for(int i=0;i&10;i++)
cout&&&【第&&&i+1&&&个Boy】&&&
Boy[i]=boy::newboy(&Boy&,13);
if(Boy[i]!=NULL)Boy[i]-&disp(); //测试Boy是否超过了数量，超过数量的不能调用对象方法，否则会产生异常
getchar();
}//---------------------------------------------------------------------------
难道这么冷清？这种帖子都没人顶？
代码太长，这种情况建议用单例模式
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或第9章 C++程序设计_图文_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
第9章 C++程序设计
上传于||暂无简介
大小：1.29MB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢C++运算符重载函数作为类成员函数和友元函数
例10.2中对运算符&+&进行了重载，使之能用于两个复数的相加。在该例中运算符重载函数operator+作为Complex类中的成员函数。
可能有的读者会提出这样的问题：&+&是双目运算符，为什么在例10.2程序中的重载函数中只有一个参数呢？实际上，运算符重载函数有两个参数，由于重载 函数是Complex类中的成员函数，有一个参数是隐含的，运算符函数是用this指针隐式地访问类对象的成员。可以看到，重载函数operator+访 问了两个对象中的成员，一个是this指针指向的对象中的成员，一个是形参对象中的成员。如 this-&real+c2.real，this-&real就是c1.real。上节中已说明，在将运算符函数重载为成员函数后，如果出现 含该运算符的表达式，如c1+c2，编译系统把它解释为：
& & c1.operator+(c2)
即通过对象c1调用运算符重载函数，并以表达式中第二个参数(运算符右侧的类对象c2)作为函数实参。运算符重载函数的返回值是Complex类型，返回 值是复数c1和c2之和(Complex(c1.real + c2.real,&c1.imag+c2.imag))。
运算符重载函数除了可以作为类的成员函数外，还可以是非成员函数。可以将例10.2改写为例10.3。
[例10.3] 将运算符&+&重载为适用于复数加法，重载函数不作为成员函数，而放在类外，作为Complex类的友元函数。
#include &iostream&
using namespace std;
class Complex
Complex( ){real=0;imag=0;}
Complex(double r,double i){real=r;imag=i;}
friend Complex operator + (Complex &c1,Complex &c2);
void display( );
double real;
double imag;
Complex operator + (Complex &c1,Complex &c2)
return Complex(c1.real+c2.real, c1.imag+c2.imag);
void Complex::display( )
cout&&&(&&&real&&&,&&&imag&&&i)&&&endl;
int main( )
Complex c1(3,4),c2(5,-10),c3;
cout&&&c1=&; c1.display( );
cout&&&c2=&; c2.display( );
cout&&&c1+c2 =&; c3.display( );
与例10.2相比较，只作了一处改动，将运算符函数不作为成员函数，而把它放在类外，在Complex类中声明它为友元函数。同时将运算符函数改为有两个参数。在将运算符&+&重载为非成员函数后，C++编译系统将程序中的表达式c1+c2解释为 & & operator+(c1,&c2) 即执行c1+c2相当于调用以下函数： & & Complex operator + (Complex &c1，Complex &c2) & & { & & & & return Complex(c1.real+c2.real， c1.imag+c2.imag); & & } 求出两个复数之和。运行结果同例10.2。
为什么把运算符函数作为友元函数呢？因为运算符函数要访问Complex类对象中的成员。如果运算符函数不是Complex类的友元函数，而是一个普通的函数，它是没有权利访问Complex类的私有成员的。 在上节中曾提到过：运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数。现在分别讨论这3种情况。
首先，只有在极少的情况下才使用既不是类的成员函数也不是友元函数的普通函数，原因是上面提到的，普通函数不能直接访问类的私有成员。 在剩下的两种方式中，什么时候应该用成员函数方式，什么时候应该用友元函数方式？二者有何区别呢？如果将运算符重载函数作为成员函数，它可以通过this 指针自由地访问本类的数据成员，因此可以少写一个函数的参数。但必须要求运算表达式第一个参数(即运算符左侧的操作数)是一个类对象，而且与运算符函数的 类型相同。因为必须通过类的对象去调用该类的成员函数，而且只有运算符重载函数返回值与该对象同类型，运算结果才有意义。
在例10.2中，表达式 c1+c2中第一个参数c1是Complex类对象，运算符函数返回值的类型也是Complex，这是正确的。如果c1不是Complex类，它就无法通 过隐式this指针访问Complex类的成员了。如果函数返回值不是Complex类复数，显然这种运算是没有实际意义的。 如想将一个复数和一个整数相加，如c1+i，可以将运算符重载函数作为成员函数，如下面的形式： & & Complex Complex∷operator+(int &i)& //运算符重载函数作为Complex类的成员函数 & & { & & & & return Complex(real+i，imag); & & } 注意在表达式中重载的运算符&+&左侧应为Complex类的对象，如： & & c3=c2+i; 不能写成 & & c3=i+c2;& //运算符&+&的左侧不是类对象，编译出错 如果出于某种考虑，要求在使用重载运算符时运算符左侧的操作数是整型量(如表达式i+c2，运算符左侧的操作数i是整数)，这时是无法利用前面定义的重载 运算符的，因为无法调用i.operator+函数。可想而知，如果运算符左侧的操作数属于C++标准类型(如int)或是一个其他类的对象，则运算符重 载函数不能作为成员函数，只能作为非成员函数。如果函数需要访问类的私有成员，则必须声明为友元函数。可以在Complex类中声明： & & friend Complex operator+(int &i，Complex &c); //第一个参数可以不是类对象 在类外定义友元函数： & & Complex operator+(int &i,&Complex &c) //运算符重载函数不是成员函数 & & { & & & & return Complex(i+c.real,&c.imag); & & } 将双目运算符重载为友元函数时，在函数的形参表列中必须有两个参数，不能省略，形参的顺序任意，不要求第一个参数必须为类对象。但在使用运算符的表达式中，要求运算符左侧的操作数与函数第一个参数对应，运算符右侧的操作数与函数的第二个参数对应。如： & & c3=i+c2;& //正确，类型匹配 & & c3=c2+i;& //错误，类型不匹配 请注意，数学上的交换律在此不适用。
如果希望适用交换律，则应再重载一次运算符&+&。如 & & Complex operator+(Complex &c， int &i) //此时第一个参数为类对象 & & { & & & & return Complex(i+c.real,&c.imag); & & } 这样，使用表达式i+c2和c2+i都合法，编译系统会根据表达式的形式选择调用与之匹配的运算符重载函数。可以将以上两个运算符重载函数都作为友元函 数，也可以将一个运算符重载函数(运算符左侧为对象名的) 作为成员函数，另一个(运算符左侧不是对象名的)作为友元函数。但不可能将两个都作为成员函数，原因是显然的。 C++规定，有的运算符(如赋值运算符、下标运算符、函数调用运算符)必须定义为类的成员函数，有的运算符则不能定义为类的成员函数(如流插入&&&&和流提取运算符&&&&、类型转换运算符)。 由于友元的使用会破坏类的封装，因此从原则上说，要尽量将运算符函数作为成员函数。但考虑到各方面的因素，一般将单目运算符重载为成员函数，将双目运算符重载为友元函数。在学习了本章第10.7节例10.9的讨论后，读者对此会有更深入的认识。 说明：有的C++编译系统(如Visual C++ 6.0)没有完全实现C++标准，它所提供不带后缀.h的头文件不支持把成员函数重载为友元函数。上面例10.3程序在GCC中能正常运行，而在Visual C++ 6.0中会编译出错。但是Visual C++所提供的老形式的带后缀.h的头文件可以支持此项功能，因此可以将程序头两行修改如下，即可顺利运行： & & #include &iostream.h& 以后如遇到类似情况，亦可照此办理。
相关内容：
编程爱好者
WEB编程开发}