The friend declaration appears in aclass body and grants a function or another class access to private and protected members of the class where the friend declaration appears.

[edit]Syntax

[edit]Description

class Y{int data;// private member // the non-member function operator<< will have access to Y's private membersfriendstd::ostream& operator<<(std::ostream& out,const Y& o);friendchar* X::foo(int);// members of other classes can be friends toofriend 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-memberstd::ostream& operator<<(std::ostream& out,const Y& y){return out<< y.data;// can access private member Y::data}

class X{int a; friendvoid 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 friendclass 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};

[edit]Template friends

Bothfunction template andclass template declarations may appear with thefriend specifier in any non-local class or class template (although only function templates may be defined within the class or class template that is granting friendship). In this case, every specialization of the template becomes a friend, whether it is implicitly instantiated, partially specialized, or explicitly specialized.

class A{template<typename T>friendclass B;// every B<T> is a friend of A template<typename T>friendvoid f(T){}// every f<T> is a friend of A};

Friend declarations cannot refer to partial specializations, but can refer to full specializations:

template<class T>class A{};// primary template<class T>class A<T*>{};// partial template<>class A<int>{};// full class X{template<class T>friendclass A<T*>;// Error friendclass A<int>;// OK};

When a friend declaration refers to a full specialization of a function template, the keywordinline,constexpr(since C++11),consteval(since C++20) and default arguments cannot be used:

template<class T>void f(int); template<>void f<int>(int); class X{friendvoid f<int>(int x=1);// error: default args not allowed};

A template friend declaration can name a member of a class template A, which can be either a member function or a member type (the type must useelaborated-type-specifier). Such declaration is only well-formed if the last component in its nested-name-specifier (the name to the left of the last::) is a simple-template-id (template name followed by argument list in angle brackets) that names the class template. The template parameters of such template friend declaration must be deducible from the simple-template-id.

In this case, the member of any specialization of either A or partial specializations of A becomes a friend. This does not involve instantiating the primary template A or partial specializations of A: the only requirements are that the deduction of the template parameters of A from that specialization succeeds, and that substitution of the deduced template arguments into the friend declaration produces a declaration that would be a valid redeclaration of the member of the specialization:

// primary templatetemplate<class T>struct A{struct B{}; void f(); struct D{void g();};     T h(); template<T U>    T i();}; // full specializationtemplate<>struct A<int>{struct B{}; int f(); struct D{void g();}; template<int U>int i();}; // another full specializationtemplate<>struct A<float*>{int*h();}; // the non-template class granting friendship to members of class template Aclass X{template<class T>friendstruct A<T>::B;// all A<T>::B are friends, including A<int>::B template<class T>friendvoid A<T>::f();// A<int>::f() is not a friend because its signature// does not match, but e.g. A<char>::f() is a friend //  template<class T>//  friend void A<T>::D::g(); // ill-formed, the last part of the nested-name-specifier,//                            // D in A<T>::D::, is not simple-template-id template<class T>friendint* A<T*>::h();// all A<T*>::h are friends:// A<float*>::h(), A<int*>::h(), etc template<class T>template<T U>// all instantiations of A<T>::i() and A<int>::i() are friends,friend T A<T>::i();// and thereby all specializations of those function templates};

[edit]Template friend operators

A common use case for template friends is declaration of a non-member operator overload that acts on a class template, e.g.operator<<(std::ostream&,const Foo<T>&) for some user-definedFoo<T>.

Such operator can be defined in the class body, which has the effect of generating a separate non-templateoperator<< for eachT and makes that non-templateoperator<< a friend of itsFoo<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 Tfriendstd::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

or the function template has to be declared as a template before the class body, in which case the friend declaration withinFoo<T> can refer to the full specialization ofoperator<< for itsT:

#include <iostream> template<typename T>class Foo;// forward declare to make function declaration possible template<typename T>// declarationstd::ostream& operator<<(std::ostream&,const Foo<T>&); template<typename T>class Foo{public:    Foo(const T& val): data(val){}private:    T data; // refers to a full specialization for this particular Tfriendstd::ostream& operator<<<>(std::ostream&,const Foo&); // note: this relies on template argument deduction in declarations// can also specify the template argument with operator<< <T>"}; // definitiontemplate<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';}

[edit]Linkage

Storage class specifiers are not allowed in friend declarations.

If(until C++20)Otherwise, if(since C++20) a function or function template is declared in a friend declaration, and acorresponding non-friend declaration is reachable, the name has the linkage determined from that prior declaration.

Otherwise, the linkage of the name introduced by a friend declaration is determined as usual.

[edit]Notes

Friendship is not transitive (a friend of your friend is not your friend).

Friendship is not inherited (your friend's children are not your friends, and your friends are not your children's friends).

Access specifiers have no effect on the meaning of friend declarations (they can appear inprivate: or inpublic: sections, with no difference).

A friend class declaration cannot define a new class (friendclass X{}; is an error).

When a local class declares an unqualified function or class as a friend, only functions and classes in the innermost non-class scope arelooked up, not the global functions:

class F{}; int f(); int main(){externint g(); class Local// Local class in the main() function{friendint f();// Error, no such function declared in main()friendint g();// OK, there is a declaration for g in main()friendclass F;// friends a local F (defined later)friendclass::F;// friends the global F}; class F{};// local F}

A name first declared in a friend declaration within a class or class templateX becomes a member of the innermost enclosing namespace ofX, but is not visible for lookup (except argument-dependent lookup that considersX) unless a matching declaration at namespace scope is provided - seenamespaces for details.

[edit]Keywords

friend

[edit]Example

#include <iostream>#include <sstream> class MyClass{int i;// friends have access to non-public, non-staticstaticinlineint id{6};// and static (possibly inline) members friendstd::ostream& operator<<(std::ostream& out,const MyClass&);friendstd::istream& operator>>(std::istream& in, MyClass&);friendvoid 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 memberstd::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 = 7MyClass::id = 6; i = 100MyClass::id = 9; i = 100

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]References

[edit]See also

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文