你必须非常小心何时何地使用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这个词，但偶尔它正是你所需要的。希望这能有所帮助!

在为类实现树算法时，教授给我们的框架代码将树类作为节点类的朋友。

它实际上没有任何好处，除了让你在不使用设置函数的情况下访问成员变量。

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

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

很明显…

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

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;
}

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

编辑:阅读faq有点长，我喜欢<< >>操作符重载和添加作为这些类的朋友的想法，但我不确定这如何不打破封装

它将如何破坏封装?

当允许对数据成员进行不受限制的访问时，就打破了封装。考虑以下类:

class c1 {
public:
  int x;
};

class c2 {
public:
  int foo();
private:
  int x;
};

class c3 {
  friend int foo();
private:
  int x;
};

C1显然没有封装。任何人都可以读取和修改其中的x。我们没有办法实施任何形式的访问控制。

C2明显被封装了。没有对x的公共访问。你所能做的就是调用foo函数，它对类执行一些有意义的操作。

c3吗?它的封装程度低吗?它是否允许无限制地访问x?它是否允许未知函数访问?

不。它只允许一个函数访问类的私有成员。就像c2一样。就像c2一样，有访问权的函数不是“某个随机的未知函数”，而是“类定义中列出的函数”。就像c2一样，通过查看类定义，我们可以看到拥有访问权限的完整列表。

那么，这到底是如何减少封装的呢?同样数量的代码可以访问类的私有成员。类定义中列出了所有具有访问权限的人。

Friend不会破坏封装。这让一些Java程序员感到不舒服，因为当他们说“面向对象”时，他们实际上指的是“Java”。当他们说“封装”时，他们并不是说“必须保护私有成员不受任意访问”，而是说“在Java类中，唯一能够访问私有成员的函数是类成员”，尽管出于几个原因，这完全是无稽之谈。

首先，如上所述，它限制太大。没有理由不允许朋友方法做同样的事情。

第二，限制不够。考虑第四个类:

class c4 {
public:
  int getx();
  void setx(int x);
private:
  int x;
};

根据上述Java思想，这是完美封装的。 但是，它允许任何人读取和修改x，这有什么意义呢?(提示:事实并非如此)

底线: 封装是关于能够控制哪些函数可以访问私有成员。这与这些函数的定义具体位于何处无关。

对于操作符<<和操作符>>，没有很好的理由让这些操作符成为朋友。它们确实不应该是成员函数，但它们也不需要是朋友函数。

最好的方法是创建公共打印(ostream&)和读取(istream&)函数。然后，根据这些函数写出操作符<<和操作符>>。这提供了额外的好处，允许您将这些函数设置为虚拟函数，从而提供虚拟序列化。