Friend declaration

Объявление друга появляется в теле класса и предоставляет функции или другому классу доступ к приватным и защищенным членам класса, в котором появляется объявление друга.

Синтаксис

Описание

class Y
{
    int data; // private member
    // the non-member function operator<< will have access to Y's private members
    friend std::ostream& operator<<(std::ostream& out, const Y& o);
    friend char* X::foo(int); // members of other classes can be friends too
    friend X::X(char), X::~X(); // constructors and destructors can be friends
};
// friend declaration does not declare a member function
// this operator<< still needs to be defined, as a non-member
std::ostream& operator<<(std::ostream& out, const Y& y)
{
    return out << y.data; // can access private member Y::data
}

class X
{
    int a;
    friend void friend_set(X& p, int i)
    {
        p.a = i; // this is a non-member function
    }
public:
    void member_set(int i)
    {
        a = i; // this is a member function
    }
};

class Y {};
class A
{
    int data; // private data member
    class B {}; // private nested type
    enum { a = 100 }; // private enumerator
    friend class X; // friend class forward declaration (elaborated class specifier)
    friend Y; // friend class declaration (simple type specifier) (since C++11)
    // the two friend declarations above can be merged since C++26:
    // friend class X, Y;
};
class X : A::B // OK: A::B accessible to friend
{
    A::B mx; // OK: A::B accessible to member of friend
    class Y
    {
        A::B my; // OK: A::B accessible to nested member of friend
    };
    int v[A::a]; // OK: A::a accessible to member of friend
};

Шаблонные друзья

Как шаблоны функций , так и шаблоны классов могут быть объявлены со спецификатором friend в любом нелокальном классе или шаблоне класса (хотя только шаблоны функций могут быть определены внутри класса или шаблона класса, который предоставляет дружественный доступ). В этом случае каждая специализация шаблона становится дружественной, независимо от того, является ли она неявно инстанцированной, частично специализированной или явно специализированной.

class A
{
    template<typename T>
    friend class B; // каждый B<T> является другом A
    template<typename T>
    friend void f(T) {} // каждая f<T> является другом A
};

Объявления дружественных функций не могут ссылаться на частичные специализации, но могут ссылаться на полные специализации:

template<class T>
class A {};      // первичный
template<class T>
class A<T*> {};  // частичный
template<>
class A<int> {}; // полный
class X
{
    template<class T>
    friend class A<T*>;  // Ошибка
    friend class A<int>; // OK
};

Когда объявление друга ссылается на полную специализацию шаблона функции, ключевые слова inline , constexpr (since C++11) , consteval (since C++20) и аргументы по умолчанию не могут быть использованы:

template<class T>
void f(int);
template<>
void f<int>(int);
class X
{
    friend void f<int>(int x = 1); // ошибка: аргументы по умолчанию не разрешены
};

Объявление шаблонного друга может указывать на член шаблона класса A, который может быть либо функцией-членом, либо типом-членом (тип должен использовать уточненный-спецификатор-типа ). Такое объявление является корректным только если последний компонент в его вложенном-спецификаторе-имени (имя слева от последнего :: ) является simple-template-id (имя шаблона, за которым следует список аргументов в угловых скобках), которое именует шаблон класса. Параметры шаблона такого объявления шаблонного друга должны быть выводимы из simple-template-id.

В данном случае член любой специализации A или частичной специализации A становится другом. Это не требует инстанцирования основного шаблона A или частичных специализаций A: единственные требования заключаются в том, чтобы успешно завершилась дедукция параметров шаблона A из этой специализации, и чтобы подстановка выведенных аргументов шаблона в объявление друга давала объявление, которое было бы допустимым повторным объявлением члена специализации:

// основной шаблон
template<class T>
struct A
{ 
    struct B {};
    void f();
    struct D { void g(); };
    T h();
    template<T U>
    T i();
};
// полная специализация
template<>
struct A<int>
{
    struct B {};
    int f();
    struct D { void g(); };
    template<int U>
    int i();
};
// другая полная специализация
template<>
struct A<float*>
{
    int *h();
};
// нетемплейтный класс, предоставляющий дружественный доступ членам шаблона класса A
class X
{
    template<class T>
    friend struct A<T>::B; // все A<T>::B являются друзьями, включая A<int>::B
    template<class T>
    friend void A<T>::f(); // A<int>::f() не является другом, потому что её сигнатура
                           // не совпадает, но например A<char>::f() является другом
//  template<class T>
//  friend void A<T>::D::g(); // некорректно, последняя часть nested-name-specifier,
//                            // D в A<T>::D::, не является simple-template-id
    template<class T>
    friend int* A<T*>::h(); // все A<T*>::h являются друзьями:
                            // A<float*>::h(), A<int*>::h(), и т.д.
    template<class T> 
    template<T U>       // все инстанциации A<T>::i() и A<int>::i() являются друзьями,
    friend T A<T>::i(); // и тем самым все специализации этих шаблонов функций
};

Шаблонные дружественные операторы

Распространённый случай использования дружественных шаблонов — объявление перегруженного оператора, не являющегося членом класса, который работает с шаблоном класса, например operator << ( std:: ostream & , const Foo < T > & ) для некоторого пользовательского Foo < T > .

Такой оператор может быть определен в теле класса, что приводит к генерации отдельного нешаблонного operator << для каждого T и делает этот нешаблонный operator << другом своего Foo < T > :

#include <iostream>
template<typename T>
class Foo
{
public:
    Foo(const T& val) : data(val) {}
private:
    T data;
    // generates a non-template operator<< for this T
    friend std::ostream& operator<<(std::ostream& os, const Foo& obj)
    {
        return os << obj.data;
    }
};
int main()
{
    Foo<double> obj(1.23);
    std::cout << obj << '\n';
}

1.23

или шаблон функции должен быть объявлен как шаблон до тела класса, в этом случае объявление друга внутри Foo < T > может ссылаться на полную специализацию operator << для его T :

#include <iostream>
template<typename T>
class Foo; // предварительное объявление для возможности объявления функции
template<typename T> // объявление
std::ostream& operator<<(std::ostream&, const Foo<T>&);
template<typename T>
class Foo
{
public:
    Foo(const T& val) : data(val) {}
private:
    T data;
    // ссылается на полную специализацию для данного конкретного T
    friend std::ostream& operator<< <> (std::ostream&, const Foo&);
    // примечание: это основано на выводе аргументов шаблона в объявлениях
    // также можно указать аргумент шаблона с помощью operator<< <T>
};
// определение
template<typename T>
std::ostream& operator<<(std::ostream& os, const Foo<T>& obj)
{
    return os << obj.data;
}
int main()
{
    Foo<double> obj(1.23);
    std::cout << obj << '\n';
}

Связывание

Спецификаторы класса хранения не допускаются в объявлениях друзей.

Если (до C++20) Иначе, если (начиная с C++20) функция или шаблон функции объявлены в friend-декларации, и соответствующее не-friend объявление достижимо, имя имеет линковку, определённую из этого предыдущего объявления.

В противном случае, связывание имени, введённого объявлением friend, определяется обычным образом.

Примечания

Дружба не транзитивна (друг вашего друга не является вашим другом).

Дружба не наследуется (дети ваших друзей не являются вашими друзьями, а ваши друзья не являются друзьями ваших детей).

Спецификаторы доступа не влияют на смысл объявлений дружественных функций (они могут появляться в private : или в public : секциях, без какой-либо разницы).

Объявление класса-друга не может определять новый класс ( friend class X { } ; является ошибкой).

Когда локальный класс объявляет неквалифицированную функцию или класс как друга, только функции и классы из самой внутренней не-классовой области видимости подвергаются поиску , а не глобальные функции:

class F {};
int f();
int main()
{
    extern int g();
    class Local // Локальный класс в функции main()
    {
        friend int f(); // Ошибка, нет объявления такой функции в main()
        friend int g(); // OK, есть объявление для g в main()
        friend class F; // дружит с локальным F (определенным позже)
        friend class ::F; // дружит с глобальным F
    };
    class F {}; // локальный F
}

Имя, впервые объявленное в объявлении friend внутри класса или шаблона класса X , становится членом ближайшего охватывающего пространства имён X , но не видимо для поиска (за исключением поиска, зависимого от аргументов, который учитывает X ), пока не предоставлено соответствующее объявление в области пространства имён - подробности смотрите в разделе namespaces .

Ключевые слова

friend

Пример

#include <iostream>
#include <sstream>
class MyClass
{
    int i;                   // friends have access to non-public, non-static
    static inline int id{6}; // and static (possibly inline) members
    friend std::ostream& operator<<(std::ostream& out, const MyClass&);
    friend std::istream& operator>>(std::istream& in, MyClass&);
    friend void change_id(int);
public:
    MyClass(int i = 0) : i(i) {}
};
std::ostream& operator<<(std::ostream& out, const MyClass& mc)
{
    return out << "MyClass::id = " << MyClass::id << "; i = " << mc.i;
}
std::istream& operator>>(std::istream& in, MyClass& mc)
{
    return in >> mc.i;
}
void change_id(int id) { MyClass::id = id; }
int main()
{
    MyClass mc(7);
    std::cout << mc << '\n';
//  mc.i = 333*2;  // error: i is a private member
    std::istringstream("100") >> mc;
    std::cout << mc << '\n';
//  MyClass::id = 222*3;  // error: id is a private member
    change_id(9);
    std::cout << mc << '\n';
}

MyClass::id = 6; i = 7
MyClass::id = 6; i = 100
MyClass::id = 9; i = 100

Отчеты о дефектах

Следующие отчеты о дефектах, изменяющих поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

Ссылки

Смотрите также