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

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

很明显…

您使用私有/受保护/公共权限控制成员和函数的访问权限? 所以假设这3个层面中的每一个都很清楚，那么很明显我们遗漏了一些东西……

例如，将成员/函数声明为protected是非常通用的。你的意思是，这个功能对每个人来说都是遥不可及的(当然，继承的孩子除外)。但是异常呢?每个安全系统都让你有某种类型的“白名单”，对吗?

所以，“朋友”让你拥有坚如磐石的对象隔离的灵活性，但也允许为你认为合理的事情创造一个“漏洞”。

我想人们之所以说不需要它，是因为总有一种设计可以不需要它。我认为这类似于讨论全局变量:你永远不应该使用它们，总有办法不用它们……但在现实中，你会看到在某些情况下，这是(几乎)最优雅的方式……我认为朋友之间也是如此。

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

但这并不是正确的看法。 其理念是控制WHO可以访问什么，是否有设置功能与此关系不大。

在我之前工作过的一家公司里，我们遇到了一个有趣的问题，我们用朋友来产生良好的影响。我在我们的框架部门工作，我们在自定义操作系统上创建了一个基本的引擎级系统。在内部我们有一个类结构:

         Game
        /    \
 TwoPlayer  SinglePlayer

所有这些类都是框架的一部分，由我们的团队维护。该公司所制作的游戏便是基于这一源自games子游戏的框架。问题是Game有各种单人和双人玩家需要访问的东西的接口，但我们不想在框架类之外公开。解决方案是将这些接口设为私有，并允许双人和单人玩家通过友谊访问它们。

事实上，这整个问题本可以通过更好地实施我们的系统来解决，但我们被锁定在我们所拥有的东西上。

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

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

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

friend关键字有很多好的用途。以下是我能立即看到的两种用法:

朋友的定义

友元定义允许在类作用域中定义函数，但该函数不会被定义为成员函数，而是被定义为外围命名空间的自由函数，并且除了依赖参数的查找之外通常不可见。这使得它对于操作符重载特别有用:

namespace utils {
    class f {
    private:
        typedef int int_type;
        int_type value;

    public:
        // let's assume it doesn't only need .value, but some
        // internal stuff.
        friend f operator+(f const& a, f const& b) {
            // name resolution finds names in class-scope. 
            // int_type is visible here.
            return f(a.value + b.value);
        }

        int getValue() const { return value; }
    };
}

int main() {
    utils::f a, b;
    std::cout << (a + b).getValue(); // valid
}

私有CRTP基类

有时候，你会发现策略需要访问派生类:

// possible policy used for flexible-class.
template<typename Derived>
struct Policy {
    void doSomething() {
        // casting this to Derived* requires us to see that we are a 
        // base-class of Derived.
        some_type const& t = static_cast<Derived*>(this)->getSomething();
    }
};

// note, derived privately
template<template<typename> class SomePolicy>
struct FlexibleClass : private SomePolicy<FlexibleClass> {
    // we derive privately, so the base-class wouldn't notice that, 
    // (even though it's the base itself!), so we need a friend declaration
    // to make the base a friend of us.
    friend class SomePolicy<FlexibleClass>;

    void doStuff() {
         // calls doSomething of the policy
         this->doSomething();
    }

    // will return useful information
    some_type getSomething();
};

在这个回答中，你会发现一个不做作的例子。在这个答案中使用了另一个代码。CRTP基类强制转换其this指针，以便能够使用数据成员指针访问派生类的数据字段。