C++基础知识友元friend、友元函数和友元类

为了在类之间进行数据共享时，提高效率，C++引入了友元的概念。友元主要有三个方面的应用：
将普通函数声明为类的友元函数；
将一个类声明为其他类的友元类；
将一个类中的成员函数声明为其他类的友元函数。
下面分别介绍。

1、普通函数声明为友元函数

将一个普通函数，声明为某个类的友元函数后(在函数声明前加上“friend”关键字)，该函数就可以访问类中的任何成员。观察下面的代码：

#include<iostream>
using namespace std;

class friend_test{
private:
int a=3; //非静态成员变量
static int b; //声明静态成员变量
public:
friend void friend_func(friend_test &f); //将函数friend_func()函数，声明为该类的友元函数。由于友元函数没有this指针
};
int friend_test::b=4; //定义静态成员变量

//friend_func()函数的实现
void friend_func(friend_test &f)
{
cout<<"访问基础类friend_test的私有成员变量： "<<f.a<<endl;
cout<<"访问基础类friend_test的静态成员变量： "<<friend_test::b<<endl;
cout<<"访问基础类friend_test的静态成员变量： "<<f.b<<endl;
}

int main()
{
friend_test f; //声明friend_test类的对象
friend(f); //程序运行正常，按预期输出结果

return 0;
}从上面的程序中可以看出，友元函数访问类的成员变量时，有以下特点：
访问静态static成员时，可以通过”类名::变量名”和”对象名::变量名”方式访问；
访问非静态成员时，只能通过“对象名::变量名”方式访问。

2、友元类

若将类A 声明为类B的友元类，那么类A中的所有成员函数都可以访问类B中的所有成员；反之，不成立，即友元不是双向的。
观察下面的代码：#include<iostream>
using namespace std;

class A;
class B{
public:
friend class A; //声明类A为类B的友元类
private:
int b;
};
c
4000
lass A{
public:
void func1(B &BB); //声明类A的成员函数
void func2(B &BB);
};
void A::func1(B &BB)
{
cout<<"访问类B的成员变量： "<<BB.b<<endl;
}
void B::func2(B &BB)
{
cout<<"本函数用不到类B的成员变量"<<endl;
}
int main()
{
A AA; //声明类A的对象
B BB; //声明类B的对象

A.func1(BB); //调用类A的成员函数，在成员函数中访问类B的成员变量
A.func2(BB);
}
通过以上代码，可以发现类A为类B的友类，类A中所有的成员函数都可以访问类B中的所有成员。那么，此时会带来一个问题，若类A中的某个函数如上面的“func2()”不需要访问类B的成员变量，只有函数“func1()”需要访问类B的成员。
由于友元的引入本来就破坏了“封装”，使得面向对象的颜面有点受损。那么，可以仅仅设置类A的成员函数func1()为类B的友元函数，从而类B的成员对函数“func2()”就不可见了^-^
上面所述就是将类的成员函数声明为其他类的友元函数的目的。

3、类的成员函数声明为其他类的友元函数

正如上面所说，若将类A的某个成员函数”func_A()”声明为类B的友元函数后，函数”func_A”就可以访问类B中的所有成员。
观察下面的例子：#include<iostream>
using namespace std;

class B;
class A{
public:
void func_A(B &BB); //类A的成员函数
void func();
};
//类A的成员函数实现
void A::func()
{
cout<<"我只是个普通的宝宝~~~"<<endl;
}
class B{
public:
friend void A::func_A(B &BB); //将类A的func_A()成员函数声明为类B的友元
private:
int b=5; //类B的成员变量
};
//类A中为类B友元的成员函数实现,必须放在类B定义之后
void A::func_A(B &BB)
{
cout<<"通过类A的成员函数访问类B的成员变量： "<<BB.b<<endl;
}
int main()
{
A AA; //类A的对象
B BB； //类B的对象
A.func(); //访问类A的成员函数
A.func_A(); //访问类A的成员函数，为类B的友元
}
通过以上分析，将友元的特点总结如下：
由于友元函数没有this指针，访问静态static成员时，可以通过”类名::变量名”和”对象名::变量名”方式访问；
访问非静态成员时，只能通过“对象名.变量名”方式访问。
虽能提高效率，但破坏了程序的封装，尽量减少friend的使用；
在声明类的成员函数为其他类的友元时，函数实现要放在其他类的定义之后。