C++ 友元函数三种类型

**全局函数作为友元函数**
#include <iostream>
#include <string>
using namespace std;

/*
    友元函数
    1.全局函数做友元
    2.类做友元
    3.成员函数做友元
    . 和 -> 运算符:前者是用于结构体/变量或者对象访问成员 A.b中的A是代表对象或者结构体
    -> 用于结构体 类指针变量访问成员 A->b是成员提取 A是指向类 结构 联合的指针
*/
class Person
{
    // goodALL全局函数是Person好朋友,可以直接访问Person中的私有成员
    // 函数位置是在Person的最里面的最上面这个位置
    friend void goodALL(Person *person);

public:
    Person()
    {
        common_Room = "keting";
        my_Room = "woshi";
    }

public:
    string common_Room;

private:
    string my_Room;
};

// 类做友元
class GoodGay
{
public:
    void visit(); // 参观函数 访问Person中的属性

    Person *person;
};

// 全局函数作为好朋友
void goodALL(Person *person)
{
    cout << "quanju function is visiting " << person->common_Room << endl;
    // 全局函数作为好朋友可以直接访问类的私有对象
    cout << "quanju function as a friend is visiting private variable " << person->my_Room << endl;
}

void test()
{
    Person person;
    goodALL(&person);
}

int main()
{
    test();
    return 0;
}


**类作为友元函数**
#include <iostream>
#include <string>
using namespace std;

class Building;
class GoodGay
{
public:
    GoodGay(); // 隐式声明
    void visit();

    Building *building;
};

class Building
{
    // GoodGay类是Building的好朋友,可以访问本类中的私有类
    friend class GoodGay;

public:
    Building(); // 构造函数
public:
    string common_room;

private:
    string room;
};

// 在类外写成员函数 Building:: 这个是代表这个作用域是Building下的
Building::Building()
{
    common_room = "connmon_room";
    room = "room";
}

GoodGay::GoodGay()
{
    // 创建建筑物对象 在堆区 这样程序员可以手动删释放该空间
    building = new Building;
}

void GoodGay::visit()
{
    cout << "Your frind is visiting your " << building->common_room << endl;
    cout << "visiting the building private vairable variable" << building->room << endl;
}

void test01()
{
    GoodGay gg;
    gg.visit(); // 过程是 实例化一个gg对象, 然后new了一个building对象, building进行构造函数， 然后visiting进行访问
}
int main()
{
    test01();
    return 0;
}

**成员函数做友元函数*
#include <iostream>
#include <string>
using namespace std;
/*
    成员函数做友元
    注意的是 需要确定作用域
             全局函数不用确定作用域
*/
class Building;

class GoodGay
{
public:
    GoodGay();

    void visit(); // visit访问Building中私有成员

    void visit2(); // visit2不可以访问Building中私有成员

    Building *building;
};

class Building
{
    // 为什么这个成员函数就要友作用域呢? 是因为如果不添加,编译器会认为是全局函数，会发生报错，添加了就不会了。
    // 这样编译器就知道GoodGay类下的visit成员函数作为这个Building的好朋友,可以访问私有成员
    friend void GoodGay::visit();

public:
    Building();

public:
    string commonRoom;

private:
    string Room;
};

// 在类外实现构造函数 类外实现是为了增加代码的可读性
Building::Building()
{
    commonRoom = "commonRoom";
    Room = "Room";
}

GoodGay::GoodGay()
{
    building = new Building;
}

// 可以访问Building的私有成员 是因为visit是Building的友元函数
void GoodGay::visit()
{
    cout << "visit is call" << building->commonRoom << endl;
    cout << "visit is call" << building->Room << endl;
}

// 不可以访问私有
void GoodGay::visit2()
{
    cout << "visit2 is call" << building->commonRoom << endl;
}

void test()
{
    GoodGay gg;
    gg.visit();
    gg.visit2();
}
int main()
{
    test();
    return 0;
}