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베이스는이 포인터를 캐스트하여 데이터 멤버 포인터를 사용하여 파생 클래스의 데이터 필드에 액세스 할 수 있습니다.

답변

class c1 {
public:
  int x;
};

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

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

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

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

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