当我们希望一个非成员函数访问类的私有成员时，我们将其声明为该类的友元函数。这使得它具有与静态成员函数相同的访问权限。无论哪种方式，你都可以获得一个与该类的任何实例都没有关联的函数。
什么情况下必须使用友元函数? 何时必须使用静态函数? 如果两者都可以解决问题，如何权衡它们的适用性？默认情况下是否应该优先考虑其中之一?
例如，当实现一个工厂来创建只有私有构造函数的类foo的实例时，该工厂函数应该是foo的静态成员（您将调用foo::create()）还是友元函数（您将调用create_foo()）？
Bjarne Stroustrup的《C++程序设计语言》第11.5节指出，普通成员函数有三个特点：
友元函数只有一个特点。
静态函数具有1和2两个特点。
这个问题似乎涉及到程序员需要引入一个不适用于任何类的实例的函数（因此可以选择静态成员函数）。因此，我将限制本答案的范围为以下设计情况，即在静态函数f()和友元自由函数f()之间进行选择：
struct A
{
static void f(); // Better this...
private:
friend void f(); // ...or this?
static int x;
};
int A::x = 0;
void A::f() // Defines static function
{
cout << x;
}
void f() // Defines friend free function
{
cout << A::x;
}
int main()
{
A::f(); // Invokes static function
f(); // Invokes friend free function
}
在不了解f()和A的语义（稍后我会回来讨论这个问题）的情况下，这种局限性场景有一个简单的答案：static函数更好。我认为有两个原因。
通用算法：
主要原因是可以编写以下模板：
template<typename T> void g() { T::f(); }
f()，那么这将允许我们编写一个单一的函数，以通用方式在任何这样的类上调用f()。f()作为自由的非成员函数，则无法编写等效的通用函数。虽然我们可以将f()放入命名空间中，以便使用N::f()语法来模仿A::f()语法，但仍然不可能编写如上所示的g<>()模板函数，因为命名空间名称不是有效的模板参数。f()放入命名空间中，就不能直接在类定义中内联其定义，而不引入任何其他声明f()的声明。struct A
{
static void f() { cout << x; } // OK
private:
friend void N::f() { cout << x; } // ERROR
static int x;
};
A的定义之前加上以下声明：namespace N
{
void f(); // Declaration of f() inside namespace N
}
struct A
{
...
private:
friend void N::f() { cout << x; } // OK
...
};
f()的意图。f()，同时保持f()在命名空间中，我们仍然需要在A类定义之前引入f()的声明：否则编译器会抱怨f()必须在命名空间N内声明才能合法使用N::f名称。f()在三个不同的地方提到而不是两个（声明和定义）：A定义之前，在命名空间N内声明；
- 在A定义内部的friend声明；
- 在命名空间N内定义f()。f()的声明和定义不能合并的原因是f()应该访问A的内部，因此，在定义f()时必须看到A的定义。然而，正如先前所述，在进行相应的friend声明之前，必须看到N内部的f()声明。这实际上强制我们分离f()的声明和定义。f()声明为static而不是将其作为A的friend或反之，这是由话题的范围驱动的。friend函数仍然是逻辑上外部于类定义的算法。static关键字或friend关键字，以及我们是否想在定义类时写入A::类作用域限定符而非N::命名空间作用域限定符。因此，我不会再进一步评论这个问题。友元函数是非成员函数，因此它们比静态成员函数提供更好的封装。Scott Meyers在第23项建议使用非成员函数。并且在这里：http://cpptips.com/nmemfunc_encap - Gusev Slava区别在于明确表达类和函数之间关系的意图。
当您想要有意地指示两个不相关的类或类和函数之间存在强耦合和特殊关系时，使用friend。
当函数在逻辑上是其所属类的一部分时，请使用static成员函数。
静态函数只能访问一个类的成员。友元函数可以访问多个类，如下面的代码所示：
class B;
class A { int a; friend void f(A &a, B &b); };
class B { int b; friend void f(A &a, B &b); };
void f(A &a, B &b) { std::cout << a.a << b.b; }
f()可以访问A类和B类的数据。
One reason to prefer a friend over static member is when the function needs to be written in assembly (or some other language).
For instance, we can always have an extern "C" friend function declared in our .cpp file
class Thread;
extern "C" int ContextSwitch(Thread & a, Thread & b);
class Thread
{
public:
friend int ContextSwitch(Thread & a, Thread & b);
static int StContextSwitch(Thread & a, Thread & b);
};
And later defined in assembly:
.global ContextSwitch
ContextSwitch: // ...
retq
Technically speaking, we could use a static member function to do this, but defining it in assembly won't be easy due to name mangling (http://en.wikipedia.org/wiki/Name_mangling)
Another situation is when you need to overload operators. Overloading operators can be done only through friends or non-static members. If the first argument of the operator is not an instance of the same class, then non-static member would also not work; friend would be the only option:
class Matrix
{
friend Matrix operator * (double scaleFactor, Matrix & m);
// We can't use static member or non-static member to do this
};
标准要求操作符=() []和->必须是成员函数，而类特定的new、new[]、delete和delete[]运算符必须是静态成员。如果出现不需要类对象调用函数的情况，则将函数定义为静态函数。对于所有其他函数：
如果一个函数需要流I/O的操作符=() []和->，或者它需要左侧参数的类型转换，
或者它可以仅使用类的公共接口实现，那么将其定义为非成员函数（在前两种情况下需要友元函数）
如果它需要虚拟行为，
则添加一个虚拟成员函数来提供虚拟行为，并基于该函数进行实现
否则，
将其定义为成员函数。
静态函数是一种没有访问 this 的函数。
友元函数是一种可以访问类的私有成员的函数。
如果函数不需要读取或修改类的特定实例的状态（意味着您不需要修改内存中的对象），或者如果您需要使用指向类成员函数的函数指针，则可以使用静态函数。在第二种情况下，如果您需要修改驻留对象的状态，则需要传递this并使用本地副本。在第一种情况下，可能会出现这样的情况，即执行某个任务的逻辑不依赖于对象的状态，但是您的逻辑分组和封装将其作为特定类的成员。
当您创建的代码不是类的成员且不应该成为类的成员，但具有绕过私有/受保护封装机制的合法目的时，您可以使用友元函数或类。其中一个目的可能是您有两个需要一些共同数据的类，但编写两次逻辑会很糟糕。实际上，我只在我编写的类中的1％左右使用了此功能。它很少需要。