好友对于回调也很有用。可以将回调函数作为静态方法来实现

class MyFoo
{
private:
    static void callback(void * data, void * clientData);
    void localCallback();
    ...
};

回调在内部调用localCallback, clientData中有你的实例。在我看来，

还是……

class MyFoo
{
    friend void callback(void * data, void * callData);
    void localCallback();
}

这允许友元在cpp中被定义为c风格的函数，而不会使类变得混乱。

类似地，我经常看到的一种模式是将一个类的所有真正的私有成员放到另一个类中，该类在头文件中声明，在cpp中定义，并加为好友。这允许编码器向头文件的用户隐藏类的很多复杂性和内部工作。

在头文件中:

class MyFooPrivate;
class MyFoo
{
    friend class MyFooPrivate;
public:
    MyFoo();
    // Public stuff
private:
    MyFooPrivate _private;
    // Other private members as needed
};

在cpp中，

class MyFooPrivate
{
public:
   MyFoo *owner;
   // Your complexity here
};

MyFoo::MyFoo()
{
    this->_private->owner = this;
}

这样就更容易隐藏下游不需要看到的东西。

看来我迟到了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++类扩展到广义类的精确机制。

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

您可以坚持最严格和最纯粹的OOP原则，并确保任何类的数据成员都没有访问器，这样所有对象都必须是唯一可以知道它们的数据的对象，并且对它们进行操作的唯一方法是通过间接消息(即方法)。

但即使是c#也有一个内部可见性关键字，Java也有默认的包级可访问性。c++实际上更接近于OOP的理想，它通过精确地指定哪些其他类或只有其他类可以看到一个类，从而最大限度地减少了类的可见性。

我不太使用c++，但如果c#有朋友，我会用它来代替我经常使用的汇编全局内部修饰符。它并没有真正打破封装，因为。net中的部署单元是一个程序集。

但是还有InternalsVisibleToAttribute(otherAssembly)，它的作用类似于跨组装的友元机制。微软将此用于可视化设计器程序集。

正如朋友声明的参考资料所说:

友元声明出现在类主体中，并授予函数或另一个类对出现友元声明的类的私有和受保护成员的访问权。

所以提醒一下，有些回答中有技术错误，说朋友只能访问受保护的成员。

在做TDD的时候，我经常使用c++中的'friend'关键字。朋友能知道我的一切吗?

不，这只是一种单向的友谊。

安德鲁例子的另一个常见版本，可怕的密码对联

parent.addChild(child);
child.setParent(parent);

与其担心这两行是否总是一起执行，并且顺序一致，你可以将方法设为私有，并有一个friend函数来强制一致性:

class Parent;

class Object {
private:
    void setParent(Parent&);

    friend void addChild(Parent& parent, Object& child);
};

class Parent : public Object {
private:
     void addChild(Object& child);

     friend void addChild(Parent& parent, Object& child);
};

void addChild(Parent& parent, Object& child) {
    if( &parent == &child ){ 
        wetPants(); 
    }
    parent.addChild(child);
    child.setParent(parent);
}

换句话说，您可以保持公共接口更小，并强制在友元函数中跨越类和对象的不变量。