你必须非常小心何时何地使用friend关键字，和你一样，我很少使用它。下面是一些关于使用friend和替代用法的注意事项。

假设你想比较两个对象，看它们是否相等。你可以:

使用访问器方法进行比较(检查每个ivar并确定是否相等)。 或者，您可以通过将所有成员设为public直接访问它们。

第一个选项的问题是，这可能会有很多访问器，这比直接变量访问(稍微)慢，更难读取，而且很麻烦。第二种方法的问题是完全破坏了封装。

如果我们可以定义一个外部函数，它仍然可以访问类的私有成员，那就更好了。我们可以用friend关键字做到这一点:

class Beer {
public:
    friend bool equal(Beer a, Beer b);
private:
    // ...
};

equal(Beer, Beer)方法现在可以直接访问a和b的私有成员(可能是char *brand, float percentAlcohol等)。这是一个相当做作的例子，您可能会更早地将friend应用于重载的==操作符，但我们会讲到这一点。

有几件事需要注意:

A friend is NOT a member function of the class It is an ordinary function with special access to the private members of the class Don't replace all accessors and mutators with friends (you may as well make everything public!) Friendship isn't reciprocal Friendship isn't transitive Friendship isn't inherited Or, as the C++ FAQ explains: "Just because I grant you friendship access to me doesn't automatically grant your kids access to me, doesn't automatically grant your friends access to me, and doesn't automatically grant me access to you."

我只有在用另一种方法更难的时候才会用朋友。另一个例子是，由于Mat2x2, Mat3x3, Mat4x4, Vec2, Vec3, Vec4等的互操作性，许多向量数学函数经常被创建为朋友。而且做朋友比到处使用访问器要容易得多。正如所指出的，friend在应用于<<(非常方便调试)、>>和==运算符时通常很有用，但也可以用于这样的事情:

class Birds {
public:
    friend Birds operator +(Birds, Birds);
private:
    int numberInFlock;
};


Birds operator +(Birds b1, Birds b2) {
    Birds temp;
    temp.numberInFlock = b1.numberInFlock + b2.numberInFlock;
    return temp;
}

就像我说的，我不经常使用friend这个词，但偶尔它正是你所需要的。希望这能有所帮助!

看来我迟到了14年。但情况是这样的。

TLDR TLDR

有了友类，您就可以将封装扩展到组成数据结构的类组。

TLDR

Your data structure in general consists of multiple classes. Similarly to a traditional class (supported by your programming language), your data structure is a generalized class which also has data and invariants on that data which spans across objects of multiple classes. Encapsulation protects those invariants against accidental modification of the data from the outside, so that the data-structure's operations ("member functions") work correctly. Friend classes extend encapsulation from classes to your generalized class.

太长

类是一种数据类型，它带有指定数据类型值子集(称为有效状态)的不变量。对象是类的有效状态。类的成员函数将给定对象从有效状态移动到另一个有效状态。

对象数据不能从类成员函数外部修改，这一点很重要，因为这可能会破坏类不变量(即将对象移动到无效状态)。封装禁止从类外部访问对象数据。这是编程语言的一个重要安全特性，因为它使无意中破坏类不变量变得很困难。

类通常是实现数据结构的自然选择，因为数据结构的属性(例如性能)依赖于其数据上的不变量(例如红黑树不变量)。然而，有时单个类不足以描述一个数据结构。

数据结构是将数据从有效状态移动到另一有效状态的数据、不变量和函数的任何集合。这是一个类的泛化。细微的区别在于，数据可能分散在不同的数据类型上，而不是集中在单一的数据类型上。

数据结构示例

A prototypical example of a data structure is a graph which is stored using separate objects for vertices (class Vertex), edges (class Edge), and the graph (class Graph). These classes do not make sense independently. The Graph class creates Vertexs and Edges by its member functions (e.g. graph.addVertex() and graph.addEdge(aVertex, bVertex)) and returns pointers (or similar) to them. Vertexs and Edges are similarly destroyed by their owning Graph (e.g. graph.removeVertex(vertex) and graph.removeEdge(edge)). The collection of Vertex objects, Edge objects and the Graph object together encode a mathematical graph. In this example the intention is that Vertex/Edge objects are not shared between Graph objects (other design choices are also possible).

一个Graph对象可以存储所有顶点和边的列表，而每个顶点可以存储一个指向其所属Graph的指针。因此，Graph对象表示整个数学图，只要需要数学图，就可以传递它。

不变的例子

图数据结构的一个不变量是顶点被列在它的所有者图的列表中。这个不变量跨越了Vertex对象和Graph对象。多个类型的多个对象可以参与给定的不变量。

封装的例子

与类类似，数据结构得益于封装，它可以防止数据被意外修改。这是因为数据结构需要保留不变量，以便能够以承诺的方式运行，就像类一样。

In the graph data structure example, you would state that Vertex is a friend of Graph, and also make the constructors and data-members of Vertex private so that a Vertex can only be created and modified by Graph. In particular, Vertex would have a private constructor which accepts a pointer to its owning graph. This constructor is called in graph.addVertex(), which is possible because Vertex is a friend of Graph. (But note that Graph is not a friend of Vertex: there is no need for Vertex to be able to access Graph's vertex-list, say.)

术语

数据结构的定义本身就像一个类。我建议我们开始使用术语“广义类”来描述将数据从有效状态移动到另一有效状态的任何数据集、不变量和函数。c++类是广义类的一种特殊类型。不言而喻，友类是将封装从c++类扩展到广义类的精确机制。

(事实上，我希望用“广义类”的概念取代“类”，并使用“本机类”来表示编程语言支持的类的特殊情况。然后，在教授类时，您将学习本机类和这些广义类。但这可能会令人困惑。)

c++的创建者说这并没有破坏任何封装原则，我将引用他的话:

“朋友”是否违反封装? 不。但事实并非如此。“好友”是一种授予访问权限的显式机制，就像会员资格一样。你不能(在符合标准的程序中)在不修改类源的情况下授予自己对类的访问权。

很明显…

@roo:这里没有破坏封装，因为类本身规定了谁可以访问它的私有成员。只有当这可能是由类外部引起时，封装才会被破坏，例如，如果你的操作符<<声明“我是类foo的朋友”。

朋友代替了公开的用法，而不是私人的用法!

实际上，c++ FAQ已经回答了这个问题。

在做TDD的时候，我经常使用c++中的'friend'关键字。

朋友能知道我的一切吗?

更新:我从Bjarne Stroustrup网站上找到了这个关于“朋友”关键字的有价值的答案。

“好友”是一种授予访问权限的显式机制，就像会员资格一样。

在构建容器并希望为该类实现迭代器时，Friend可以派上用场。