我发现了一个使用好友访问的方便地方:私有函数的Unittest。

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

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

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

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

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

这可能不是一个实际的用例情况，但可能有助于说明类间朋友关系的使用。

会所

class ClubHouse {
public:
    friend class VIPMember; // VIP Members Have Full Access To Class
private:
    unsigned nonMembers_;
    unsigned paidMembers_;
    unsigned vipMembers;

    std::vector<Member> members_;
public:
    ClubHouse() : nonMembers_(0), paidMembers_(0), vipMembers(0) {}

    addMember( const Member& member ) { // ...code }   
    void updateMembership( unsigned memberID, Member::MembershipType type ) { // ...code }
    Amenity getAmenity( unsigned memberID ) { // ...code }

protected:
    void joinVIPEvent( unsigned memberID ) { // ...code }

}; // ClubHouse

会员班的

class Member {
public:
    enum MemberShipType {
        NON_MEMBER_PAID_EVENT,   // Single Event Paid (At Door)
        PAID_MEMBERSHIP,         // Monthly - Yearly Subscription
        VIP_MEMBERSHIP,          // Highest Possible Membership
    }; // MemberShipType

protected:
    MemberShipType type_;
    unsigned id_;
    Amenity amenity_;
public:
    Member( unsigned id, MemberShipType type ) : id_(id), type_(type) {}
    virtual ~Member(){}
    unsigned getId() const { return id_; }
    MemberShipType getType() const { return type_; }
    virtual void getAmenityFromClubHouse() = 0       
};

class NonMember : public Member {
public:
   explicit NonMember( unsigned id ) : Member( id, MemberShipType::NON_MEMBER_PAID_EVENT ) {}   

   void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }
};

class PaidMember : public Member {
public:
    explicit PaidMember( unsigned id ) : Member( id, MemberShipType::PAID_MEMBERSHIP ) {}

    void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }
};

class VIPMember : public Member {
public:
    friend class ClubHouse;
public:
    explicit VIPMember( unsigned id ) : Member( id, MemberShipType::VIP_MEMBERSHIP ) {}

    void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }

    void attendVIPEvent() {
        ClubHouse::joinVIPEvent( this->id );
    }
};

设施

class Amenity{};

如果你看看这些类之间的关系;会所拥有各种不同类型的会员资格和会员资格。成员都派生自超类或基类，因为它们都共享公共的ID和枚举类型，外部类可以通过基类中的访问函数访问它们的ID和类型。

然而，通过这种成员及其派生类的层次结构以及它们与ClubHouse类的关系，派生类中唯一具有“特殊特权”的是VIPMember类。基类和其他2个派生类不能访问ClubHouse的joinVIPEvent()方法，但VIP Member类拥有该特权，就好像它拥有对该事件的完全访问一样。

所以对于vip会员和ClubHouse，这是一个双向通道，而其他会员职业是有限的。

树的例子是一个很好的例子: 在一些不同的类中实现一个对象 具有继承关系。

也许您还需要它具有一个构造函数protected和force 人们用你的“朋友”工厂。

．.． 好吧，坦白地说，没有它你也能生活。

友函数和类提供对类的私有和受保护成员的直接访问，以避免在一般情况下破坏封装。大多数使用是与ostream:我们希望能够键入:

Point p;
cout << p;

但是，这可能需要访问Point的私有数据，因此我们定义了重载操作符

friend ostream& operator<<(ostream& output, const Point& p);

然而，这里有明显的封装含义。首先，现在友类或函数可以完全访问类的所有成员，甚至不属于它的需要。其次，类和友元的实现现在交织在一起，以至于类中的内部更改可以破坏友元。

如果您将好友视为类的扩展，那么从逻辑上讲，这就不是问题。但是，在这种情况下，为什么有必要首先把朋友挖出来呢?

在不破坏封装的情况下，要实现“friends”所宣称的相同目标，可以这样做:

class A
{
public:
    void need_your_data(B & myBuddy)
    {
        myBuddy.take_this_name(name_);
    }
private:
    string name_;
};

class B
{
public:
    void print_buddy_name(A & myBuddy)
    {
        myBuddy.need_your_data(*this);
    }
    void take_this_name(const string & name)
    {
        cout << name;
    }
}; 

封装并没有被破坏，类B不能访问A中的内部实现，但结果与我们将B声明为A的朋友是一样的。 编译器将优化掉函数调用，因此这将导致与直接访问相同的指令。

我认为使用“朋友”是一个简单的捷径，有争议的好处，但一定的成本。