先上一段代码。定义了两个类，都有私有变量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中具体有什么全然不知。如此，那么这一个语句当然无效咯！

友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元，一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔，外界可以通过这个小孔窥视内部的秘密。

 

 友元的正确使用能提高程序的运行效率，但同时也破坏了类的封装性和数据的隐藏性，导致程序可维护性变差。

 

 友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元，一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔，外界可以通过这个小孔窥视内部的秘密。

 

 友元的正确使用能提高程序的运行效率，但同时也破坏了类的封装性和数据的隐藏性，导致程序可维护性变差。

 

 友元函数 ：

 

 友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend，其格式如下： 

 

 friend 类型 函数名(形式参数);

 友元函数的声明可以放在类的私有部分，也可以放在公有部分，它们是没有区别的，都说明是该类的一个友元函数。

 一个函数可以是多个类的友元函数，只需要在各个类中分别声明。

 友元函数的调用与一般函数的调用方式和原理一致。

 

 

 友元类 ：

 友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。

 当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。定义友元类的语句格式如下：

 friend class 类名; 

 其中：friend和class是关键字，类名必须是程序中的一个已定义过的类。

 

 1: #include <iostream>

 2: using namespace std;

 3:

 4: class Radius

 5: {

 6: friend class Circle; //声明Circle为Radius的友元类

 7: friend void Show_r(Radius &n); //声明Show_r为友元函数

 8: public:

 9: Radius(int x)

 10: {

 11: r = x;

 12: }

 13: ~Radius()

 14: {

 15: }

 16:

 17: private:

 18: int r;

 19: };

 20:

 21: void Show_r(Radius &n)

 22: {

 23: cout<<"圆的半径为: "<<n.r<<endl; //调用Radius对象的私有成员变量r

 24: }

 25:

 26: class Circle

 27: {

 28: public:

 29: Circle() {}

 30: ~Circle(){}

 31: double area(Radius a)

 32: {

 33: s = a.r * a.r * 3.1415926; //调用Radius对象的私有成员变量r

 34: return s;

 35: }

 36: private:

 37: double s;

 38: };

 39:

 40: int main(int argc, char *argv[])

 41: {

 42: Radius objRadius(9);

 43: Circle objCircle;

 44:

 45: Show_r( objRadius );

 46: cout<<"面积为："<<objCircle.area(objRadius)<<endl;

 47:

 48: return 0;

 49: }

 被声明两个类的友元声明

 

 如果我们决定一个函数必须被声明为两个类的友元则友元声明如下

 

 1: class Window; // 只声明

 2:

 3: class Screen

 4:

 5: {

 6:

 7: friend bool is_equal( Screen &, Window & );

 8:

 9: // ...

 10:

 11: };

 12:

 13: class Window 

 14:

 15: {

 16:

 17: friend bool is_equal( Screen &, Window & );

 18:

 19: // ...

 20:

 21: };

 作为一个类的函数又是另一个类的友元

 

 如果我们决定该函数必须作为一个类的成员函数并又是另一个类的友元，则成员函数声明和友元声明如下：

 

 1: class Window;

 2:

 3: class Screen

 4:

 5: {

 6:

 7: public:

 8:

 9: // copy 是类 Screen 的成员

 10:

 11: Screen& copy( Window & );

 12:

 13: // ...

 14:

 15: };

 16:

 17: class Window

 18:

 19: {

 20:

 21: // copy 是类 Window 的一个友元

 22:

 23: friend Screen& Screen::copy( Window & );

 24:

 25: // ...

 26:

 27: };

 
只有当一个类的定义已经被看到时它的成员函数才能被声明为另一个类的友元。这并不总是能够做到的。

 

 例如如果Screen 类必须把Window 类的成员函数声明为友元，而Window类必须把Screen 类的成员函数声明为友元。该怎么办呢？在这种情况下可以把整个Window类声明为Screen 类的友元。

 

 例如：

 

 

 

 1: class Window;

 2:

 3: class Screen

 4:

 5: {

 6:

 7: friend class Window;

 8:

 9: // ...

 10:

 11: };

 Screen 类的非公有成员现在可以被Window 的每个成员函数访问。

 

 使用友元类时注意：

 (1) 友元关系不能被继承。

 (2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。

 (3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明友元函数 ：

 

 友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend，其格式如下： 

 

 friend 类型 函数名(形式参数);

 友元函数的声明可以放在类的私有部分，也可以放在公有部分，它们是没有区别的，都说明是该类的一个友元函数。 

 一个函数可以是多个类的友元函数，只需要在各个类中分别声明。 

 友元函数的调用与一般函数的调用方式和原理一致。

 

 

 友元类 ： 

 友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。 

 当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。定义友元类的语句格式如下： 

 friend class 类名; 

 其中：friend和class是关键字，类名必须是程序中的一个已定义过的类。

 

 1: #include <iostream>

 2: using namespace std;

 3: 

 4: class Radius

 5: {

 6: friend class Circle; //声明Circle为Radius的友元类

 7: friend void Show_r(Radius &n); //声明Show_r为友元函数

 8: public:

 9: Radius(int x)

 10: {

 11: r = x;

 12: }

 13: ~Radius()

 14: {

 15: }

 16: 

 17: private:

 18: int r;

 19: };

 20: 

 21: void Show_r(Radius &n)

 22: {

 23: cout<<"圆的半径为: "<<n.r<<endl; //调用Radius对象的私有成员变量r

 24: }

 25: 

 26: class Circle

 27: {

 28: public:

 29: Circle() {}

 30: ~Circle(){}

 31: double area(Radius a)

 32: {

 33: s = a.r * a.r * 3.1415926; //调用Radius对象的私有成员变量r

 34: return s;

 35: }

 36: private:

 37: double s;

 38: };

 39: 

 40: int main(int argc, char *argv[])

 41: {

 42: Radius objRadius(9);

 43: Circle objCircle;

 44: 

 45: Show_r( objRadius );

 46: cout<<"面积为："<<objCircle.area(objRadius)<<endl;

 47: 

 48: return 0;

 49: }

 被声明两个类的友元声明

 

 如果我们决定一个函数必须被声明为两个类的友元则友元声明如下

 

 1: class Window; // 只声明

 2: 

 3: class Screen

 4: 

 5: {

 6: 

 7: friend bool is_equal( Screen &, Window & );

 8: 

 9: // ...

 10: 

 11: };

 12: 

 13: class Window 

 14: 

 15: {

 16: 

 17: friend bool is_equal( Screen &, Window & );

 18: 

 19: // ...

 20: 

 21: };

 作为一个类的函数又是另一个类的友元

 

 如果我们决定该函数必须作为一个类的成员函数并又是另一个类的友元，则成员函数声明和友元声明如下：

 

 1: class Window;

 2: 

 3: class Screen

 4: 

 5: {

 6: 

 7: public:

 8: 

 9: // copy 是类 Screen 的成员

 10: 

 11: Screen& copy( Window & );

 12: 

 13: // ...

 14: 

 15: };

 16: 

 17: class Window

 18: 

 19: {

 20: 

 21: // copy 是类 Window 的一个友元

 22: 

 23: friend Screen& Screen::copy( Window & );

 24: 

 25: // ...

 26: 

 27: };

 只有当一个类的定义已经被看到时它的成员函数才能被声明为另一个类的友元。这并不总是能够做到的。

 

 例如如果Screen 类必须把Window 类的成员函数声明为友元，而Window类必须把Screen 类的成员函数声明为友元。该怎么办呢？在这种情况下可以把整个Window类声明为Screen 类的友元。

 

 例如：

 

 

 

 1: class Window;

 2: 

 3: class Screen

 4: 

 5: {

 6: 

 7: friend class Window;

 8: 

 9: // ...

 10: 

 11: };

 Screen 类的非公有成员现在可以被Window 的每个成员函数访问。

 

 使用友元类时注意： 

 (1) 友元关系不能被继承。 

 (2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。 

 (3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否

废话少说，直接上代码。
 
#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;
}
 
 

这是我作业中的一题，我按照正常的逻辑做是这样
 
下面是我的代码
 
//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){}
把这三个文件中的代码修改完即可成功运行