先上一段代码。定义了两个类，都有私有变量num。分别用全局函数、友元函数计算两者的和。
#include<iostream>  
using namespace std;  
  
class B;
class A;	// 此行可不加，这里加此行是因为下面举例子有用  
class A {  
public:  
    A(int n = 0): num(n) {} // 构造函数  
    friend void sum_1(A &a, B &b);  // 全局函数 sum_1  
    void sum_2(B &b);               // 成员函数 sum_2  
private:  
    int num;  
};  
  
class B {  
public:  
    B(int n = 0) : num(n) {}    // 构造函数  
    friend void sum_1(A &a, B &b);  // 全局函数 sum_1  
    friend void A::sum_2(B &b);     // 友元函数 A::sum_2  
private:  
    int num;  
};  
// 全局函数  
void sum_1(A &a, B &b) {  
    int sum = a.num + b.num;    // 访问了两个对象的私有变量  
    cout << a.num << " + " << b.num << " = " << sum << endl;  
}  
// 友元函数  
void A::sum_2(B &b) {  
    int sum = num + b.num;  // 访问了参数对象的私有变量  
    cout << num << " + " << b.num << " = " << sum << endl;  
}  
  
int main() {  
    A a(1);  
    B b;  
    sum_1(a, b);  	// 调用全局函数
    a.sum_2(b);  	// 调用a的成员函数
    system("PAUSE");  
    return 0;  
}  

1. 提前声明要使用的类
若注释掉此行
class B;

编译器会报错：error C2061: 语法错误: 标识符“B”
本例中，先对类 B 进行了声明，但是没有定义。因为在类 A 的定义中，出现的函数 sum_1 和 sum_2 均要用到类B 名，所以必须事先声明“B”是一个类名，这样编译器才不会因为不知道”B“是什么而报错。
2. 必须将先定义的类的成员函数作为后定义类的友元函数，调换顺序会出现语法错误
本例中，若将 A、B 类的定义顺序调换，其余均不变，则出现语法错误
#include<iostream>  
using namespace std;  
  
class B;
class A;	// 此行可不加，这里加此行是因为下面举例子有用 
class B {  	// A、B类的定义顺序变了
.../*中间的语句不变*/   
}; 
class A {  
.../*中间的语句不变*/  
};  
  
.../*后面的语句不变*/

在友元函数的实现中，会出现

这说明B类中没有成功的把A类的成员函数sum_2声明为自己的友元函数。

道理很很简单，和第1点很相似。若先定义B类，那么我们观察一下B类定义中的如下语句
friend void A::sum_2(B &b);		// 友元函数 A::sum_2

该语句通过类名加域运算符，将A类的成员函数sum_2声明为友元函数。等等，是不是发现了什么，这是A类根本还没有定义，编译器只知道A是一个类名，A中具体有什么全然不知。如此，那么这一个语句当然无效咯！

这是我作业中的一题，我按照正常的逻辑做是这样
下面是我的代码
//main.cpp
#include"CTime.h"
#include"CDate.h"
#include<stdlib.h>
void main() {
	CTime t1(10, 13, 56);
	CDate d1(2004, 15, 12);
	CTime *p1 = &t1;
	t1.ShowValue(&d1);
	system("pause");
}
//CTime.h
class CTime {
private:
	int hour;
	int minute;
	int second;
public:
	void SetValue();
	void ShowValue(CDate *);
	CTime(int, int, int);
};
//CDate.h
class CDate {
private:
	int year;
	int month;
	int day;
public:
	CDate(int, int, int);
        friend void CTime::ShowValue(CDate *);
};
//CTime.cpp
#include<iostream>
#include"CTime.h"
void CTime::SetValue() {
	std::cin >> hour >> minute >> second;
}
void CTime::ShowValue(CDate *d1) {
	std::cout << d1->day << "/" << d1->month << "/" << d1->year << std::endl;
	std::cout << hour << ":" << minute << ":" << second << std::endl;
}
CTime::CTime(int h,int m,int s):hour(h),minute(m),second(s){}
//CDate.cpp
#include"CDate.h"
CDate::CDate(int y,int m,int d):year(y),month(m),day(d){}
这样写发现，VS2015会出现编译错误

于是我查找资料说在CTime.h要声明class CDate，在CDate.h中要申明class CTime
但是我发现还是编译无法通过
然后我在CDate中把CTime申明为友元类

然后在CTime.cpp中把CDate.h引用进去
发现即可运行成功。
代码如下

//CTime.h
class CDate;	//后来添加的声明
class CTime {
private:
	int hour;
	int minute;
	int second;
public:
	void SetValue();
	void ShowValue(CDate *);
	CTime(int, int, int);
};
//CDate.h
class CTime;	//后来添加的声明
class CDate {
private:
	int year;
	int month;
	int day;
public:
	CDate(int, int, int);
	friend class CTime;	//把CTime声明为友元类
};
//CTime.cpp
#include<iostream>
#include"CTime.h"
#include"CDate.h"	//一定要引用进来
void CTime::SetValue() {
	std::cin >> hour >> minute >> second;
}
void CTime::ShowValue(CDate *d1) {
	std::cout << d1->day << "/" << d1->month << "/" << d1->year << std::endl;
	std::cout << hour << ":" << minute << ":" << second << std::endl;
}
CTime::CTime(int h,int m,int s):hour(h),minute(m),second(s){}
把这三个文件中的代码修改完即可成功运行

废话少说，直接上代码。

#include <iostream>
using namespace std;
/*
将另一个类中的成员函数声明为友元函数的三步曲
*/

/*第一步：增加前向声明，并定义一个需要实现友元函数的类*/

class TV;//前向声明
class Remote {
private:

public:
	void setCh(TV&,int);//前向声明是为了这里使用类名
};

/*第二步：定义另一个声明友元函数的类*/

class TV {
private:
	string name;
	int channel;
	int volume;
public:
	TV(string n,int c, int v) {
		channel = c; volume = v; name = n;
	}
	friend void Remote::setCh(TV&,int);//Remote类定义在前是为了告诉编译器友元函数的原型
};

/*第三步：实现第一个类中的成员函数，即第二个类中的友元函数*/

void Remote::setCh(TV& tv,int n) {//最后实现友元函数是为了使用tv对象
	if (tv.name == "创维")
		tv.channel = n;
	else
		tv.channel = 100;
	cout << tv.name << ":当前处于" << tv.channel << "频道。\n";
}

//声音控制函数自己体会，在此省略。

int main()
{
	TV tv1("创维", 5, 10);
	TV tv2("杂牌", 8, 6);
	Remote remote;
	remote.setCh(tv1,5);
	remote.setCh(tv2,5);
	return 0;
}


 

问题是这样的：
我有一个类Xth，它有一个private成员 damage，现在想用另一个类 Badao的成员函数 use() 来打印这个值；其实这个问题有很简单
清晰的实现方法，比如在Xth中定义一个专门用来获取damage的值的public函数，等等；但是我第一个想到的是用友元函数玩一波骚操作
问题在与，两个类分别写在各自的头文件中，我一开始以为，两者必须要包含对方的头文件，但是这样根本无法通过编译。

引用某大佬在另一个类似问题上的回答：

友元函数显然是可以的，但是你说的头文件相互包含的问题是可以避免的 你在Book类里面声明Manage类的成员函数为友元函数，因此必然要包含Manage类的头文件，而且你最好使用提前声明，加一句class Manage；

你在Manage类里面的函数（声明为友元的函数），可以用的是Book类的声明，也就是只用声明class Book，不用包含头文件，因为在头文件中不需要展开具体的函数，因此不需要包含Book类的头文件，只需要在Manage类的cpp文件中包含Book类的头文件即可。

以下是代码
main.cpp:
---------------------------------------------
#include <iostream>
#include "Badao.h"
#include "Xth.h"
using namespace std;

int main()
{
    Badao die;
    Xth one;
    die.use(one);
    cout << "Hello world!" << endl;
    return 0;
}

Xth.h
--------------------------------------------
#ifndef XTH_H
#define XTH_H
#include "Badao.h"
class Badao;
class Xth
{
    friend void Badao::use(Xth &);
    public:
        Xth();
        virtual ~Xth();

    protected:

    private:
        int damage=1000;
};
#endif // XTH_H

Xth.cpp
------------------------------------------
#include "Xth.h"
#include "Badao.h"

Xth::Xth()
{
    //ctor
}

Xth::~Xth()
{
    //dtor
}

Badao.h
------------------------------------------
#ifndef BADAO_H
#define BADAO_H

using namespace std;
class Xth;
class Badao
{
    public:
        Badao();
        void use(Xth &);
        virtual ~Badao();

    protected:

    private:
};

#endif // BADAO_H

Badao.cpp
-----------------------------------------
#include "Badao.h"
#include <iostream>
#include "Xth.h"

Badao::Badao()
{
    //ctor
}
void Badao::use(Xth &cw){
    cout<<cw.damage<<endl;
}
Badao::~Badao()
{
    //dtor
}