如何实现一个类函数声明为另一个类的友元，并且两个类在不同的文件中

[tiandu0803]

RT，主要是要求两个类的声明和实现分别在不同的文件中，即2个.h,2个.cpp，友元类中将用到另一个类的私有变量，举例如下，但是无论如何使用前向声明都会报错，求解决

//A.h
class A
{
private:
  int val_a;
  friend void B::GetValueA(B *pB);
  ...
}

//A.cpp
#include"A.h"
...

//B.h
class B
{
private:
  int val_b;
  void GetValueA(A *pA);
}

//B.cpp
#include"B.h"
void B::GetValueA(A *pA)
{
   val_b = pA->val_A;
}

//main.cpp
#include"A.h"
#include"B.h"
......

。

下面是一些我自己的理解：在A.h中声明了B的友元函数，这时必须要让编译器知道B的完整定义，所以必须#include"B.h",而在B.h中的GetValueA函数声明又用到了A类，所以必须要进行前向声明 class A;
但是B的实现中用到了A的变量，所以仅仅前向声明是不够的，需要完整的A的定义，这样就只有#include"A.h"
但是编译器仍会报错的，求解决办法！

[漫步者、]

class A
{
private:
  int val_a;
  friend void B::GetValueA(B *pB);
  ...
}
 
这中设计真不好，你要么放到类A外面，要么跟B.cpp放一起！就你现在的问题而言，在A.h中，添加class B就行了

[tiandu0803]

引用 1 楼 ganpengjin1 的回复:

class A
{
private:
  int val_a;
  friend void B::GetValueA(B *pB);
  ...
}
 
这中设计真不好，你要么放到类A外面，要么跟B.cpp放一起！就你现在的问题而言，在A.h中，添加class B就行了

抱歉 在A.h中代码有误，友元函数的参数应为 friend void B::GetValueA(A *pA);

[tiandu0803]

引用 2 楼 dahuaixiaohuai 的回复:

class A { protected: int val_a; friend void B::GetValueA(B *pB); ... } //A.cpp #include"A.h" ... //B.h #include"A.h" class B { friend class A; private: int val_b; void GetValueA(A *pA); }

抱歉 在A.h中代码有误，友元函数的参数应为 friend void B::GetValueA(A *pA);

[tiandu0803]

我试了两位的办法，不能通过编译，希望各位大大能想出其他办法！！

[一叶之舟]

class A { protected: int val_a; friend void B::GetValueA(B *pB); ... } //A.cpp #include"A.h" ... //B.h #include"A.h" class B { friend class A; private: int val_b; void GetValueA(A *pA); }

[漫步者、]

A.h
#ifndef _A_H
#define _A_H
class B;
class A
{
private:
	int val_a;
	friend class B;
};
#endif
[code=c]
B.h
#include "A.H"
#ifndef _B_H_
#define _B_H_
class B
{
private:
	int val_b;
	void GetValueA(A *pA);
};

void B::GetValueA(A *pA)
{
	val_b = pA->val_a;
}
#endif

[/code]

[Scorpiour]

头文件中先声明 class A; class B; 然后再分别include到各自class的定义文件中就可以了。

[tiandu0803]

引用 6 楼 ganpengjin1 的回复:

A.h
#ifndef _A_H
#define _A_H
class B;
class A
{
private:
	int val_a;
	friend class B;
};
#endif
[code=c]
B.h
#include "A.H"
#ifndef _B_H_
#define _B_H_
class B
{
private:
	int val_b;
	void GetValueA(A *pA);
};

void B::GetValueA(A *pA)
{
	val_b = pA->val_a;
}
#endif

[/code]

可是我需要将B的方法放在B.cpp中，如果放在B.h中，那么必须要是内联的，否则在main中#include会被报重定义的错误

[tiandu0803]

引用 6 楼 ganpengjin1 的回复:

A.h
#ifndef _A_H
#define _A_H
class B;
class A
{
private:
	int val_a;
	friend class B;
};
#endif
[code=c]
B.h
#include "A.H"
#ifndef _B_H_
#define _B_H_
class B
{
private:
	int val_b;
	void GetValueA(A *pA);
};

void B::GetValueA(A *pA)
{
	val_b = pA->val_a;
}
#endif

[/code]

另外 我这里需要实现的是对成员函数的友元，而不是类友元，麻烦大大能不能再想个解决办法

[tiandu0803]

引用 7 楼 Scorpiour 的回复:

头文件中先声明 class A; class B; 然后再分别include到各自class的定义文件中就可以了。

能具体写下么？貌似你的方法不行，因为我是对成员函数的友元，其中用到了方法，所以必须要类的完整声明（包括方法）才行

[tiandu0803]

引用 11 楼 ganpengjin1 的回复:

[quote=引用 9 楼 tiandu0803 的回复:] [quote=引用 6 楼 ganpengjin1 的回复:]

A.h
#ifndef _A_H
#define _A_H
class B;
class A
{
private:
	int val_a;
	friend class B;
};
#endif
[code=c]
B.h
#include "A.H"
#ifndef _B_H_
#define _B_H_
class B
{
private:
	int val_b;
	void GetValueA(A *pA);
};

void B::GetValueA(A *pA)
{
	val_b = pA->val_a;
}
#endif

[/code]

另外 我这里需要实现的是对成员函数的友元，而不是类友元，麻烦大大能不能再想个解决办法[/quote] 8,9L，一起回复了： 对成员函数的友元？这是什么？友元本来就是会破坏封装性，你对成员函数友元，我恐怕是无法实现，你要是另外的一个对象中的方法成员成为友元，你这不是乱设计吗？而且无法实现，唯一的办法，使之成为友元类 2，那个放在B。h中实现的方法你放到B.cpp一样，你自己移动一下就好了！我那是复制你的代码为了给你调试个结果而已！[/quote] 这里澄清一点，友元并不是破坏封装性，这种观点是偏激的（引用自C++PRIMER PLUS及C++ PRIMER）。其次很多时候类友元并不需要，仅仅是某个类的方法需要友元，所以友元函数还是很重要的，不然C++标准也不会定义这种功能。另外在这个友元问题中，头文件包含顺序很重要，还需要必要的前向声明。所以并非简单的移动一下就可以的。不过最后还是谢谢你了。

[漫步者、]

引用 9 楼 tiandu0803 的回复:

[quote=引用 6 楼 ganpengjin1 的回复:]

A.h
#ifndef _A_H
#define _A_H
class B;
class A
{
private:
	int val_a;
	friend class B;
};
#endif
[code=c]
B.h
#include "A.H"
#ifndef _B_H_
#define _B_H_
class B
{
private:
	int val_b;
	void GetValueA(A *pA);
};

void B::GetValueA(A *pA)
{
	val_b = pA->val_a;
}
#endif

[/code]

另外 我这里需要实现的是对成员函数的友元，而不是类友元，麻烦大大能不能再想个解决办法[/quote] 8,9L，一起回复了： 对成员函数的友元？这是什么？友元本来就是会破坏封装性，你对成员函数友元，我恐怕是无法实现，你要是另外的一个对象中的方法成员成为友元，你这不是乱设计吗？而且无法实现，唯一的办法，使之成为友元类 2，那个放在B。h中实现的方法你放到B.cpp一样，你自己移动一下就好了！我那是复制你的代码为了给你调试个结果而已！

[gnohzme]

1. 在类A中声明类B的某一成员函数为类A的友元函数时，类A和类B须写在同一个文件中，才可避免编译错误。具体实例如下：

//main.cpp
class A;
class B
{
 private:
             int b;
  public void func(A * pA);
};
class A
{
   private:
              int a;
   friend void B::func(A * pA);
};
void B::func(A * pA)
{
       b= pA->a;
}
int main()
{
   cout<<"Compile Success!"<<endl;
   return 0;
}

2. 若类A和类B分别定义在不同的文件中，则建议在类A中声明类B为类A的友元类，然后调用类B中的公有函数访问类A的私有成员。具体实例如下：

//A.h
#ifndef A_H_
#define A_H_
#include"B.h"
class B;
class A
{
  private:
              int a;
  friend class B;
};
#endif /* A_H_ */

//A.cpp
......

//B.h
#ifndef B_H_
#define B_H_
#include"A.h"
class A;
class B
{
  private:
             int b;
 void func(A * pA);
};
#endif

//B.cpp
#include"B.h"
......
void B::func(A * pA)
{
  b=pA->a;
}

//main.cpp
int main()
{
   return 0;
}

此时，编译通过，并可通过类B的对象访问类A对象的私有成员。