C/C++友元

（1）概念

（1）为什么要使用友元

在实现类之间数据共享时，减少系统开销，提高效率。如果类A中的函数要访问类B中的成员（例如：智能指针类的实现），那么类A中该函数要是类B的友元函数。

即：为了使其他类的成员函数直接访问该类的私有变量，允许外面的类或函数去访问类的私有变量和保护变量，从而使两个类共享同一函数。

实际上具体大概有下面两种情况需要使用友元函数：
（1）运算符重载的某些场合需要使用友元。
（2）两个类要共享数据的时候。

优点：能够提高效率，表达简单、清晰；
缺点：友元函数破环了封装机制，尽量不使用友元函数，除非不得已的情况下才使用友元函数；

因为友元函数是类外的函数，所以它的声明可以放在类的私有段或公有段且没有区别，可以直接调用友元函数，不需要通过对象或指针；

（2）友元分类

（1）普通类的友元函数

class INTEGER
{
    friend void Print(const INTEGER& obj);//声明友元函数
};

void Print(const INTEGER& obj）
{
}

void main()
{
    INTEGER obj;
    Print(obj);//直接调用
}

（2）友元类（所有成员函数都是友元函数）

class girl;

class boy
{
public:
　　void disp(girl &);
};
//函数disp()为类boy的成员函数，也是类girl的友元函数
void boy::disp(girl &x)
{
    //借助友元，在boy的成员函数disp中，借助girl的对象，直接访问girl的私有变量
    cout<<"girl's name is:"<",age:"<class girl
{
private：
　　char *name;
　　int age;
　　//声明类boy是类girl的友元
　　friend class boy;
};

（3）在看一个详细示例

//point.h文件

class Point {

private:
    int x, y;

public:
    Point(int x, int y) {
        this->x = x;
        this->y = y;
    }

    void getXY();

    friend int distance(Point &a, Point &b);
    friend class You;
};

class You {
public:
    double Multi(Point &a) {
        return a.x * a.y + 1;
    }
};

void showPoint();

//point.cpp文件

#include 
#include "point.h"
using std::cout;
using std::endl;

void Point::getXY() {
    cout << x << ":" << y << endl;
}

int distance(Point &a, Point &b) {
    int x = a.x + b.x;
    int y = b.y + b.y;
    return x + y;
}

void showPoint() {
    Point p1(2, 3), p2(4, 5);

    p1.getXY();

    cout << distance(p1, p2) << endl;

    You you;
    cout << you.Multi(p1) << endl;
}

（4）部分操作符重载为什么要使用友元

写法格式：返回值 operator运算符(参数列表){}

操作符重载不改变优先级，操作数个数不改变；

重载运算符时，函数声明在类内和类外是有区别的，比方说+-*/等需要2个操作数的运算符；

（1）声明在类外：
当声明在类的外部时，则参数列表为2个参数，第一个参数为运算符左边的操作数，而第二个参数为操作符右边的操作数；

classType operator+(classType& left, classType& right);

（2）声明在类内，即类的成员函数：

classType operator+(classType& right);

而第一个操作数就是调用该操作符的对象的引用，第二个操作数是传进来的参数；

所以重载<<运算符，一般写法是：

ostream& operator<<(ostream& os, const classType& obj);

则第一个参数是该运算符的第一个操作数，然而却不是类对象。
所以当该类运算符重载时写在类的内部时，又为了访问类内除public外的其它变量或函数，则应当声明为友元函数。

friend ostream& operator<<(ostream& os, const classType& obj);

//示例
std::ostream & operator<<(std::ostream & os, const Time & t) {
    os << t.hours << " hours, " << t.minutes << " minutes";
    return os;
}