C++友元函数

　　此文整理自C++_友元函数及模板友元。

　 1. 引入友元函数原因

　　　　在实现类之间数据共享时，减少系统开销，提高效率。

      　　具体来说：为了使其他类的成员函数直接访问该类的私有变量。

      　　即：允许外面的类或函数去访问类的私有变量和保护变量，从而使两个类共享同一函数。

      　　优点：能够提高效率，表达简单、清晰。

      　　缺点：友元函数破环了封装机制，尽量不使用友元函数，除非不得已的情况下才使用友元函数。

　 2. 使用友元函数时机

      　　1）运算符重载的某些场合需要使用友元。

      　　2）两个类要共享数据的时候

　 3. 如何使用友元函数

　  3.1 友元函数的参数

 　　　　因为友元函数没有this指针，则参数要有三种情况：

      　　1）要访问非static成员时，需要对象做参数；--常用(友元函数常含有参数)

      　　2）要访问static成员或全局变量时，则不需要对象做参数

      　　3）如果做参数的对象是全局对象，则不需要对象做参数

　  3.2 友元函数的位置

　　　　因为友元函数是类外的函数，所以它的声明可以放在类的私有段或公有段且两者没有区别。

　  3.3 友元函数的调用

　　　　可以直接调用友元函数，不需要通过对象或指针。

　  3.4 友元函数的分类

　　　　根据这个函数的来源不同，可以分为三种方法：

　　3.4.1 普通函数友元函数

      　　1）目的：使普通函数能够访问类的友元

      　　2）语法：

　　　　　　声明位置：公有私有均可，常写为公有

　　　　　　声明： friend + 普通函数声明

　　　　　　实现位置：可以在类外或类中

　　　　　　实现代码：与普通函数相同（不加不用friend和类::）

　　　　　　调用：类似普通函数，直接调用

       　　3）示例代码：

#include <iostream>

using namespace std;

class Example
{
public:
    Example(const int val = 0) : num(val){};
    virtual ~Example() {};
    friend void display(const Example& exam);

private:
    int num;

};

void display(const Example& exam)
{
    cout << exam.num << endl;
}

void main()
{
    Example example(10);
    display(example);
}

　　3.4.2 类Y的所有成员函数都为类X友元函数—友元类

      　　1）目的：使用单个声明使Y类的所有函数成为类X的友元

          　　它提供一种类之间合作的一种方式，使类Y的对象可以具有类X和类Y的功能

           　　具体来说：

              　　前提：A是B的友元（=》A中成员函数可以访问B中有所有成员，包括私有成员和公有成员）

              　　则：在A中，借助类B，可以直接使用“B . 私有变量”的形式访问私有变量

      　　2）语法：

　　　　　　声明位置：公有私有均可，常写为私有(把类看成一个变量)

           　　声明： friend + 类名---不是对象啊

           　　调用：

      　　3）示例代码：

#include <iostream>

using namespace std;

class Boy;
class Girl
{
public:
    Girl(){ name = "Lucy"; age = 18; };
    virtual ~Girl(){};

private:
    char * name;
    int age;
    friend Boy;   //声明类Boy是类Girl的友元  

};

class Boy
{
public:
    Boy(){ name = "Jimmy"; age = 20; };
    virtual ~Boy(){};
    void display(Girl& girl);

private:
    char * name;
    int age;

};

void Boy::display(Girl& girl) //函数disp()为类Boy的成员函数，也是类Girl的友元函数 
{
    //正常情况，Boy的成员函数disp中直接访问Boy的私有变量
    cout << "Boy's name is: " << name << ", age: " << age << "." << endl;

    //借助友元，在Boy的成员函数disp中，借助Girl的对象，直接访问Girl的私有变量
    //而正常情况下，只允许在Girl的成员函数中访问Girl的私有变量
    cout << "Girl's name is: " << girl.name << ", age: " << girl.age << "." << endl;

}


int main()
{
    Boy boy;
    Girl girl;
    boy.display(girl);  //b调用自己的成员函数，但是以girl为参数，友元机制体现在函数display中

    return 0;
}

　　3.4.3 类Y的一个成员函数为类X的友元函数

      　　1）目的：使类Y的一个成员函数成为类X的友元

           　　具体而言：而在类Y的这个成员函数中，借助参数X，可以直接以X。私有变量的形式访问私有变量

     　　 2）语法：

　　　　　　声明位置：声明在公有中 （本身为函数）

　　　　　　声明：friend + 成员函数的声明

　　　　　　调用：先定义Y的对象y---使用y调用自己的成员函数---自己的成员函数中使用了友元机制

      　　3）示例代码：

#include <iostream>

using namespace std;

class Girl;
class Boy
{
public:
    Boy(){ name = "Jimmy"; age = 20; };
    virtual ~Boy(){};
    void display(Girl& girl);

private:
    char * name;
    int age;

};

class Girl
{
public:
    Girl(){ name = "Lucy"; age = 18; };
    virtual ~Girl(){};

private:
    char * name;
    int age;
    friend void Boy::display(Girl& girl);   //声明类Boy的成员函数是类Girl的友元函数

};

//函数display()为类Boy的成员函数，也是类Girl的友元函数 
void Boy::display(Girl& girl)
{
    //正常情况，Boy的成员函数disp中直接访问Boy的私有变量
    cout << "Boy's name is: " << name << ", age: " << age << "." << endl;

    //借助友元，在Boy的成员函数disp中，借助Girl的对象，直接访问Girl的私有变量
    //而正常情况下，只允许在Girl的成员函数中访问Girl的私有变量
    cout << "Girl's name is: " << girl.name << ", age: " << girl.age << "." << endl;

}

int main()
{
    Boy boy;
    Girl girl;
    boy.display(girl);  //b调用自己的成员函数，但是以girl为参数，友元机制体现在函数display中

    return 0;
}

　 4. 模板友元函数

　　在微软官方网站，有一个例子是用来说明如何建立模板友元的。下边是

　  4.1 模板友元函数

　　例子：

#include <iostream>
using namespace std;

template <class T> class Array {
    T* array;
    int size;

public:
    Array(int sz) : size(sz) {
        array = new T[size];
        memset(array, 0, size * sizeof(T));
    }

    Array(const Array& a) {
        size = a.size;
        array = new T[size];
        memcpy_s(array, a.array, sizeof(T));
    }

    T& operator[](int i) {
        return *(array + i);
    }

    int Length() { return size; }

    void print() {
        for (int i = 0; i < size; i++)
            cout << *(array + i) << " ";

        cout << endl;
    }

    template<class T>
    friend Array<T>* combine(Array<T>& a1, Array<T>& a2);
};

template<class T>
Array<T>* combine(Array<T>& a1, Array<T>& a2) {
    Array<T>* a = new Array<T>(a1.size + a2.size);
    for (int i = 0; i < a1.size; i++)
        (*a)[i] = *(a1.array + i);

    for (int i = 0; i < a2.size; i++)
        (*a)[i + a1.size] = *(a2.array + i);

    return a;
}

int main() {
    Array<char> alpha1(26);
    for (int i = 0; i < alpha1.Length(); i++)
        alpha1[i] = 'A' + i;

    alpha1.print();

    Array<char> alpha2(26);
    for (int i = 0; i < alpha2.Length(); i++)
        alpha2[i] = 'a' + i;

    alpha2.print();
    Array<char>*alpha3 = combine(alpha1, alpha2);
    alpha3->print();
    delete alpha3;
}

　

　　A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
　　a b c d e f g h i j k l m n o p q r s t u v w x y z
　　A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z　　

　　这个例子中，比较值得注意的是在类中声明模板友元函数部分：

template<class T>
friend Array<T>* combine(Array<T>& a1, Array<T>& a2);

　　template<class T>这一句不可丢。友元函数的定义为：

template<class T>
Array<T>* combine(Array<T>& a1, Array<T>& a2) {
    Array<T>* a = new Array<T>(a1.size + a2.size);
    for (int i = 0; i < a1.size; i++)
        (*a)[i] = *(a1.array + i);

    for (int i = 0; i < a2.size; i++)
        (*a)[i + a1.size] = *(a2.array + i);

    return a;
}

　  4.2 模板友元类

　　例子：

// template_friend3.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

template <class T>
class X
{
private:
    T* data;
    void InitData(int seed) { data = new T(seed); }
public:
    void print() { cout << *data << endl; }
    template <class U> friend class Factory;
};

template <class U>
class Factory
{
public:
    U* GetNewObject(int seed)
    {
        U* pu = new U;
        pu->InitData(seed);
        return pu;
    }
};

int main()
{
    Factory< X<int> > XintFactory;
    X<int>* x1 = XintFactory.GetNewObject(65);
    X<int>* x2 = XintFactory.GetNewObject(97);

    Factory< X<char> > XcharFactory;
    X<char>* x3 = XcharFactory.GetNewObject(65);
    X<char>* x4 = XcharFactory.GetNewObject(97);
    x1->print();
    x2->print();
    x3->print();
    x4->print();
}

　　65
　　97
　　A
　　a

　 5. 其他知识点

　　　　1）友元函数和类的成员函数的区别：成员函数有this指针，而友元函数没有this指针。

　　　　2）A是B的友元《=》A是B的朋友《=》借助B的对象，在A中可以直接通过“B.成员变量”（可以是公有，也可以为私有变量） 的方式访问B。