C++基础知识复习与总结（6）---友元friend、友元函数和友元类

为了在类之间进行数据共享时，提高效率，C++引入了友元的概念。友元主要有三个方面的应用：

1. 将普通函数声明为类的友元函数；
2. 将一个类声明为其他类的友元类；
3. 将一个类中的成员函数声明为其他类的友元函数。

下面分别介绍。

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;
}

从上面的程序中可以看出，友元函数访问类的成员变量时，有以下特点：

1. 访问静态static成员时，可以通过”类名::变量名”和”对象名::变量名”方式访问；
2. 访问非静态成员时，只能通过“对象名::变量名”方式访问。

2、友元类

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

#include<iostream>
using namespace std;

class A;
class B{
    public:
        friend class A;    //声明类A为类B的友元类
    private:
        int b;
};
class 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的友元
}

程序运行，符合预期。

---

通过以上分析，将友元的特点总结如下：

1. 由于友元函数没有this指针，访问静态static成员时，可以通过”类名::变量名”和”对象名::变量名”方式访问；
2. 访问非静态成员时，只能通过“对象名.变量名”方式访问。
3. 虽能提高效率，但破坏了程序的封装，尽量减少friend的使用；
4. 在声明类的成员函数为其他类的友元时，函数实现要放在其他类的定义之后。