类的主要特点之一就是数据隐藏，即类的私有成员无法在类的外部访问。但是，有时候需要在类的外部访问类的私有成员。解决方法就是使用友元函数。友元函数是一种特权函数，c++允许这个特权函数访问私有成员。

friend关键字只出现在声明处。

其他类，类成员函数，全局函数都可以声明为友元。

友元函数不是类的成员，不带this指针。

友元函数可访问对象任意成员属性，包括私有属性。

注意的是：

友元关系不能被继承

友元关系是单向的

友元关系不具有传递性

先思考一个问题，如何将不属于当前结构的函数访问当前结构中的成员？
在这里就引出了友元这个概念。在当前结构中声明结构外函数为友元函数，则该友元函数就可访问该结构中的所有成员。
友元又分为：友元函数和友元类。

目录
1.友元函数
1.1 如何对`<< 和 >>`进行重载呢？
2.友元类

1.友元函数
友元函数可访问类中的所有成员，但不是该类中的成员函数。
例：
class Date
{
	friend void Print(Date& d);//友元函数
public:
	Date(int year, int month, int day)//构造函数
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

void Print(Date& d)//外部函数
{
	cout << d._year << "-" << d._month << "-" << d._day << endl;
}

void TestClass()
{
	Date d1(2020,10,6);
	Date d2(2020, 10, 1);
	Print(d1);
}

结果：类外函数可访问类中的成员


1.1 如何对<< 和 >>进行重载呢？
若在类中对<<进行重载：



而将程序改成这样：可正常运行



结果为：



为什么会这样呢？
成员函数中，默认的第一个参数为this指针。则this指针需要作为重载符的左操作数。而在上述中，cout作为了左操作数。但这也不符合<<本身的定义，所以是不对的。则必须将该函数进行类外声明和实现，但是类外的函数又没办法访问类中成员，这里就要采用友元函数对<<进行重载。
class Date
{
	friend void Print(Date& d);//友元函数
	friend void operator<<(ostream& _cout, Date& d);
public:
	Date(int year, int month, int day)//构造函数
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

void operator<<(ostream& _cout,Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
}

void TestClass()
{
	Date d1(2020,10,6);
	Date d2(2020, 10, 1);
	cout << d1;
}

上述代码可正常运行。、
但运算符重载时，需考虑到，不改变运算符本身的含义。<<是可对结果进行连续输出的，所以上述代码无法进行连续输出，因为没有返回值类型。
做修改：返回输出流的引用


友元函数需要注意的点：

尽量不要用const修饰友元函数。在返回值为引用时，就会出错。
友元函数可在类中的任何地方声明，不受类的访问限定符限制
一个函数可以是多个类的友元函数

 

 
2.友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
例：B类是A类的友元类。
class Time
{
	friend class Date;
public:
	Time(int hour = 20, int mintue = 10, int second = 10)
		:_hour(hour)
		, _minute(mintue)
		, _second(second)
	{}
	void Print()
	{
		cout << _hour << "-" << _minute << "-" << _second << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
public:
	Date(int year, int month, int day)//构造函数
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	void SetTime(int hour, int minute, int second)
	{
		_t._hour = hour;//调用Time类的成员变量
		_t._minute = minute;
		_t._second = second;
	}
	void Print()
	{
		_t.Print();//调用Time类的成员函数
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};


void TestClass()
{
	Date d1(2020,10,6);
	Date d2(2020, 10, 1);
	d1.SetTime(21, 13, 5);
	d1.Print();
}

正常输出结果：


友元类中的注意事项：

友元关系是单向的，不具有交换性。B是A的友元，A未在B中friend，则A不是B的友元。
友元关系不能传递。B是A的友元，C是B的友元，C不一定是A的友元。

1，友元函数的定义和作用


我们已知道类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程序中的其他函数是无法访问私有成员的。非成员函数可以访问类中的公有成员，但是如果将数据成员都定义为公有的，这又破坏了隐藏的特性。另外，应该看到在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递，类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。

为了解决上述问题，提出一种使用友元的方案。友元是一种定义在类外部的普通函数，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效率（即减少了类型检查和安全性检查等都需要的时间开销），但是，它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。
2，上述的访问不是直接访问，对于普通私有成员变量是通过对象访问，对于私有静态变量是通过类访问。
为什么不能直接访问呢？
先了解一下为什么成员函数可以直接访问成员变量？
成员函数能够访问类的成员变量是因为传递了指向当前对象的this指针，它如果访问数据成员对其操作是this指向的对象的数据成员，是有实际意义的 。

友元函数不是成员函数，没有传递隐藏的this指针，只能间接访问。

这点其实和静态成员函数一样，静态成员函数也是没有this指针的，所以它只能访问静态成员变量或者通过对象访问非静态成员变量。
例子：
class Rect  
{  
public:  
	Rect()      // 构造函数，计数器加1  
	{  
		count++;  
	}  
	//Rect(const Rect& r)
	//{
	//	width = r.width;
	//	height = r.height;
	//	count++;
	//}
	~Rect()     // 析构函数，计数器减1  
	{  
		count--;  
	}  
	static int getCount()       // 返回计数器的值  
	{  
		return count;  
	} 
	friend int get();
private:  
	int width;  
	int height;  
	static int count;       // 一静态成员做为计数器  
};  

int Rect::count = 0;        // 初始化计数器  
int get()
{
	return Rect::count;//友元函数通过类访问私有静态成员变量
}
int main()  
{  
	Rect rect1;  
	cout<<"The count of Rect: "<<Rect::getCount()<<endl;//通过类访问公有静态成员函数，输出1  

	Rect rect2(rect1);   // 使用rect1复制rect2，此时应该有两个对象  
	cout<<"The count of Rect: "<<Rect::getCount()<<endl; //输出1
	cout << get() << endl;//输出1
	//cout << Rect::count << endl;//不能编译通过，不能访问私有成员
	system("pause");
	return 0;  
}  
3，类和类之间的友元关系不能继承。

下边转载自：
http://blog.csdn.net/shandianling/article/details/7469361



C++ Primer中有如下描述：友元关系不能继承。基类的友元对派生类的成员没有特殊访问

权限。如果基类被授予友元关系，则只有基类具有特殊访问权限，该基类的派生类不能访问授予友元关系的类。

 然而通过实践发现，VS编译器并没有安装上述描述来处理，下面的规则与上述描述相悖，却符合VS编译器的处理规则。

注：有待通过g++编译器来验证。

1 友元类的继承问题

1.1 A类的友元B的派生类C 不能访问A类的private或protect成员变量。但可以通过B提供的接口来访问A。(废话肯定可以)



[cpp] view
 plain copy





#include <iostream>   

using namespace   std;   

class B;   

class A   

{   

    int a;   

public:   

    A(int x=0) { a=x; }   

    friend class B;   

};   

class B   

{   

    int b;   

public:   

    void fun(A& ob){ cout << ob.a << endl;}   

};   

  

class C:public B  

{   

public:   

    //void fun2(A& ob){ cout <<ob.a <<endl;}   //派生类新加的函数却不能访问A，此句会报错  

};   

  

void   main()   

{   

    A a(55);   

    C c;   

    c.fun(a); //C是B的派生类   通过基类B的函数fun仍然可以访问   

}   


1.2.  Base的友元可以通过Base的派生类Drived访问Base的private，protect成员变量，但不能访问Drived的private，protect成员变量。（这一点似乎与《C++ primer》里说的有点冲突）

个人理解：Drived的对象本身就包含Base，Base的友元Frnd自然就可以访问Base的部分。





[cpp] view
 plain copy





#include <iostream>   

using namespace std;   

class Base   

{   

    int m_a;   

public:   

    Base(int x=0){ m_a=x; }   

    friend class Frnd;   

};   

  

class Drived:public Base   

{   

private:  

    int m_c;  

public:   

    Drived(int x):Base(x){m_c=x;}   

};  

  

class Frnd   

{  

public:   

    void fun(Base& ob) { cout <<ob.m_a << endl; }   

    void fun2(Drived& ob)   

    {  

        cout << ob.m_a<<endl;  

        //cout <<ob.m_c<<endl; //编译错误  

    }   

};   

  

int main()   

{   

    Drived d(1);   

    Frnd f;   

    f.fun(d);   

    f.fun2(d);  

    system("pause");  

    return 0;  

}   

3 友元类的传递问题

A的友元是B，B的友元是C，那A的友元是C？　不是，友元类不具有传递性。

这里在GitHub上看redis相关的代码发现的。再次记录下。

 

友元的特点就是他是普通函数，并不是成员函数。他可以调用这个类的私有成员。

 

这里有个实际用法：



如上的redisAsyncCommand函数，其中第二个参数为函数指针。

这里不能反成员函数指针。因为成员函数指针里面会带一个类名。

或许通过

QMAKE_CXXFLAGS += -Wno-pmf-conversions

这种方式可以转，但会出现一些问题。

官方推荐用友元去解决：



其中详细如下：



这里可以看到privdata及为传过来的this指针。