友元函数详解

什么是友元函数(friend)？

    类的机制实现了数据的隐藏与封装，类的数据成员一般定义为私有成员(private)，一部分成员函数定义为公有(public)，通过公有函数提供类与外界的数据交换接口。类的外部，也就是通过实例来访问私有(private)或保护(protected)成员，这是被禁止的。

    但有些情况需要定义一些函数，这些函数不是类的一部分，但又需要频繁地访问类的数据成员，C++增加了一种称之为“友元(friend)”函数的申明，将“特权”赋给一些函数(可以是全局函数，也可以是其它类的成员函数)，使之能够访问该类的私有和保护成员。

友元函数的语法

    友元函数声明时只需在友元的名称前加上关键字friend，其格式如下：

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

友元函数的用途

    使用友元函数优势可提高程序的运行效率，即减少了类型检查和安全性检查等都需要时间开销。
    友元函数可方便的重载操作符和生成迭代器类。
    用友元函数可以访问两个或多个类的私有数据，较其它方法使人们更容易理解程序的逻辑关系。
    但破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。

友元函数同类的关系

    友元函数必须在类里面申明，但友元函数一定不是该类的成员函数。
    由于友元函数不是任何类的成员函数，所以不能用句柄(对象)加点操作符来调用。
    友元函数的声明可以放在类的私有部分，也可以放在公有部分，它们是没有区别的，都说明是该类的一个友元函数。因此友元关系声明可在类定义的任何位置，习惯上在类定义的开始位置。
    一个函数可以是多个类的友元函数，只需要在各个类中分别声明。
    友元关系是指定的，不是获取的，如果让类B成为类A的友元类，类A必须显式声明类B为自己的友元类。
    如果一个友元函数想与两个或更多类成为友元关系，在每个类中都必须声明为友元函数。
    友元函数的调用与一般函数的调用方式和原理一致。
    友元关系不满足对称性和传递性。
    友元函数的声明在派生类无效，除非派生类中再申明一次，当然类型转换为基类时，使用没有任何问题。

全局函数做友元函数

    要使用全局函数作友元函数，全局函数中要使用当前这个类的实例，因此，全局函数的定义必须放在这个类的后面。

#include <iostream>
using namespace std;

class Car
{
    friend void display(Car); //声明全局函数做友元函数，允许访问Car的所有成员

private:
    int speed;
protected:
    char color[20];
public:
    void input( )
    {
        cout<<"Enter the color : ";
        cin>>color;
        cout<<"Enter the speed : ";
        cin>>speed;
    }
};

void display(Car x) //全局函数的定义
{
    cout<<"The color of the car is : "<<x.color<<endl;
    cout<<"The speed of the car is : "<<x.speed<<endl;
}

int main( )
{
    Car mine;
    //mine.display(mine); //该句编译出错，因为友元不是成员函数
    mine.input( ); //访问成员函数
    display(mine); //调用友元函数，将对象"mine"传给友元函数
    return 0;
}

其它类的成员函数做友元函数

#include <iostream>
#include <string>
using namespace std;

class ca;    //事先申明ca类，确保cb类的定义不出错

class cb {    //在ca类之前定义cb类，确保在ca类里申明cb的test()作友元时不出错
public:
    void test(ca& a);    //由于ca类事先申明，这儿不出错
};

class ca {
    string id;
    void setId(string s) {
        id = s;
    }
protected:
    string name;
    void setName(string s) {
        name = s;
    }
public:
    void print() {
        cout << id << "  " << name << "  " << endl;
    }
    friend void cb::test(ca& a);    //申明cb类的test()函数作友元，允许它访问私有保护成员
};

void cb::test(ca& a) {  //作友元的成员函数的实装必须在ca类的后面，否则ca类的成员就未定义了。
    a.id = "123";        //这是ca类的私有成员
    a.setName("abc");    //这是ca类的保护成员
}

int main ( )
{
    ca a;
    cb b;
    b.test(a);
    a.print();

    return 0;
}

将一个函数声明为多个类的友元函数

#include <iostream>
using namespace std;

class Virus; //类'Virus'未定义前要用到，需事先告诉编译器'Virus'是一个类

class Bacteria
{
private:
    int life;
public:
    Bacteria() { life=1; }
friend void Check(Bacteria, Virus); //类'Bacteria'中，将Check声明为友元函数
};

class Virus
{
private:
    int life;
public:
    Virus() : life(0) {}
friend void Check(Bacteria, Virus); //类'Virus'中，将Check声明为友元函数
};

void Check (Bacteria b, Virus v) //友元函数的定义
{
    if (b.life==1 || v.life==1)
    {
        cout<<"\nSomething is alive.";
    }
    if (b.life==1)
    {
        cout<<"\nA bacteria is alive.";
    }
    if (v.life==1)
    {
        cout<<"\nA virus is alive.";
    }
}

int main()
{
    Bacteria fever;
    Virus cholera;
    Check(fever, cholera); //友元函数的调用
    return 0;
}

使用友元进行运算符重载

#include <iostream>
#include <string>
using namespace std;

class pos {
    int x1, y1;    //矩形座标
public:
    pos() {
        x1 = 0, y1 = 0;
    }
    pos(int m1, int n1) {
        x1 = m1, y1 = n1;
    }
    void print() {
        cout << "  x1=" << x1;
        cout << "  y1=" << y1;
        cout << endl;
    }
    //pos operator++();                 //这是类的运算符的重载
    friend pos operator++(pos &ob);   //这是全局运算符的重载
};

pos operator++(pos &ob) {
    ob.x1++, ob.y1++;

    return ob;
}

int main ( )
{
    pos r(12, 20);
    r.print();

    rect obj;
    obj = r++;
    obj.print();

    return 0;
}