C++友元的用法(友元函数、友元类和友元成员函数)

#include <iostream>
using namespace std;
class B;
class A;

class C   //友元类要在类A前定义
{
    public:
        void print_A(A &a);
        /*{
            a.A_private_data=44;   //友元成员函数一定要在类A后实现
            a.A_print_public();
            a.print_protected();
            a.print_private();
        }*/
};

class A
{
public:
    friend void print_clase_A(A &a);      //友元函数，一定要在类A后实现
    friend class B;                        //友元类
    friend void C::print_A(A &a);        //友元成员函数
public :
    A()
    {
        cout<<"class A::A()"<<endl;
        A_public_data     =     1;
        A_protected_data =    2;
        A_private_data     =    3;
    }
    virtual ~A()
    {
        cout<<"class A::~A()"<<endl;
    }
    void print_public()
    {
        cout<<"class A::print_public A_public_data = "<<A_public_data<<endl;
    }
protected:
    void print_protected()
    {
        cout<<"class A::print_protected A_protected_data = "<<A_protected_data<<endl;
    }
private:
    void print_private()
    {
        cout<<"class A::print_private A_private_data = "<<A_private_data<<endl;
    }
    
public:
    int A_public_data;
protected:
    int A_protected_data;
private:
    int A_private_data;    
};

void print_clase_A(A &a)  //you
{
    a.A_private_data=33;
    a.print_public();
    a.print_protected();
    a.print_private();
}
 
void C::print_A(A &a)
{
    a.A_private_data=44;
    a.print_public();
    a.print_protected();
    a.print_private();
}

class B 
{
public :
    B()
    {
        cout<<"class B::B()"<<endl;
    }
    ~B()
    {
        cout<<"class B::~B()"<<endl;
    }
    void print_public_B(A &a)
    {
        cout<<"class B::print_public_B A_public_data = "<<a.A_public_data<<endl;
    }
    
    void print_protected_B(A &a)
    {
        cout<<"class B::print_protected_B A_protected_data = "<<a.A_protected_data<<endl;
    }
    
    void print_private_B(A &a)
    {
        cout<<"class A::print_private_B A_private_data = "<<a.A_private_data<<endl;
    }
};

int main()
{
    {
        cout<<"******class A *******"<<endl;
        A a;
        a.print_public();
        //B.print_protected(); // 不能调用
        //B.print_private();   // 不能调用

        cout<<endl<<"****** frend print_clase_A ****** "<<endl;
        print_clase_A(a);     //友元函数
        
        cout<<endl<<"****** frend class C ****** "<<endl;
        C c;
        c.print_A(a);          //友元成员函数
        cout<<endl<<"****** frend class B ****** "<<endl;    
        B b;                //友元类
        b.print_public_B(a);
        b.print_protected_B(a);
        b.print_private_B(a);

        
    }
}

 

输出：

******class A *******
class A::A()
class A::print_public A_public_data = 1

****** frend print_clase_A ****** 
class A::print_public A_public_data = 1
class A::print_protected A_protected_data = 2
class A::print_private A_private_data = 33

****** frend class C ****** 
class A::print_public A_public_data = 1
class A::print_protected A_protected_data = 2
class A::print_private A_private_data = 44

****** frend class B ****** 
class B::B()
class B::print_public_B A_public_data = 1
class B::print_protected_B A_protected_data = 2
class A::print_private_B A_private_data = 44
class B::~B()
class A::~A()

友元类注意事项

        友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。

关于友元类的注意事项：

(1) 友元关系不能被继承。
(2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
(3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明。