关于友元成员函数为什么不能相互为友元函数的问题？

[azhou88]

#include <iostream>

using namespace std;
/*class fff;*/
class abc
{
public:
friend class fff;
/* friend void fff::fortuneffff();*/ //这句不可行
void fortune();
private:
int m;
};
class fff
{
public:
void fortuneffff();


private:
int x;

friend void abc::fortune();
};

void abc::fortune()
{
fff m1;
m1.x=888;
cout<<m1.x<<endl;

}
void fff::fortuneffff()
{
abc c;
c.m=1222;
cout<<c.m<<endl;

}
int main()

{
abc l;
l.fortune();
fff ll;
ll.fortuneffff();
return 0;
}

代码可能有点凌乱，我大致说一下，方便阅读。两个类，一个是abc,一个是fff. abc中的成员函数作为友元在fff中使用没有问题。

现在问题是，fff中的函数作为友元函数在abc使用出错，除非把友元函数修改成为友元类才ok.

friend void fff::fortuneffff(); 这句话可行吗？有什么解决的方法？

[熊熊大叔]

你这样设计不合理, 没有好的解决办法
class foo; //声明foo, 但没有foo内部的定义
class bar {
public:
friend class foo; //可以, foo已经声明
friend void foo::function1(); //不可以, foo:function1没有声明或定义
void function2(void);
};

class foo {
public:
friend void bar::function2(); //可以, bar::function2已经声明过
void function1(void);
};

[combobox2013]

引用 1 楼 truelance 的回复:

你这样设计不合理, 没有好的解决办法 class foo; //声明foo, 但没有foo内部的定义 class bar { public: friend class foo; //可以, foo已经声明 friend void foo::function1(); //不可以, foo:function1没有声明或定义 void function2(void); }; class foo { public: friend void bar::function2(); //可以, bar::function2已经声明过 void function1(void); };

请问友元是相互的吗？

[Adol1111]

良好的设计应该尽量避免友元类，极大程度的限制他的使用，更不要说互为友元了。

[azhou88]

自己给自己定一下，希望有识之士继续回答

[unituniverse2]

引用 3 楼 combobox2013 的回复:

[quote=引用 1 楼 truelance 的回复:] 你这样设计不合理, 没有好的解决办法 class foo; //声明foo, 但没有foo内部的定义 class bar { public: friend class foo; //可以, foo已经声明 friend void foo::function1(); //不可以, foo:function1没有声明或定义 void function2(void); }; class foo { public: friend void bar::function2(); //可以, bar::function2已经声明过 void function1(void); };

请问友元是相互的吗？ [/quote] 友员不相互、不继承、不传递

[unituniverse2]

类互相依赖的情况是有的。拿现实中的问题举例，就是所谓的共生关系。几个类对象需要相互依赖，但逻辑上却无法作为一个大类存在。多任务设计中很容易碰到这种问题（比如设计关键区，需要访问类和关键区对象类两个类型，几个访问类对象共同使用一个关键区对象）。以前的设计人员会强制的将这些封装到一个整体里面，但是结果往往是扩展的时候手续复杂甚至到荒谬的程度，或者干脆重新实现一个功能类似的拓扑结构。 我觉得像这样偏执的坚持按照一元oop设计不是一个好的解决方式。 操作符重载也需要友员。 但不要给自己滥用友员找借口。图一时快活结果维护的时候麻烦更大。毕竟一元oop造成发散的可能性小，设计成一元式更好理解（而不只是更容易写）的情况下就不要用分散式的

[Adol1111]

引用 6 楼 unituniverse2 的回复:

类互相依赖的情况是有的。拿现实中的问题举例，就是所谓的共生关系。几个类对象需要相互依赖，但逻辑上却无法作为一个大类存在。多任务设计中很容易碰到这种问题（比如设计关键区，需要访问类和关键区对象类两个类型，几个访问类对象共同使用一个关键区对象）。以前的设计人员会强制的将这些封装到一个整体里面，但是结果往往是扩展的时候手续复杂甚至到荒谬的程度，或者干脆重新实现一个功能类似的拓扑结构。 我觉得像这样偏执的坚持按照一元oop设计不是一个好的解决方式。 操作符重载也需要友员。 但不要给自己滥用友员找借口。图一时快活结果维护的时候麻烦更大。毕竟一元oop造成发散的可能性小，设计成一元式更好理解（而不只是更容易写）的情况下就不要用分散式的

+1 按照OO的思想，可以少量的使用友元函数，但最好不要使用友元类。在使用友元时总要想一下是否有这个必要，有没有更好的代替方案。破坏封装绝不是一种良好的设计。

[lm_whales]

友元函数的参数，最好有一个是该类的指针或者引用类型的。 和该类无关的函数，最好不要定义成友元。