C++_17_友元

友元

> 友元   友元 是单向的  甲和乙   甲说 他是乙朋友  乙有可能不承认 所以 是单向的
> 只要是 友元  就可以访问他私有的东西  所以 友元会破坏 封装性

作用：可以访问友元 的私有成员

特点：

• 单项性
• 不能被传递
• 不能被继承

关键字： friend

可以修饰 全局变量 成员变量 还可以声明 友元类

也就是分类：

友元全局变量     该函数中可以直接使用其友元的类中的私有成员
友元成员变量     该函数中可以直接使用其友元的类中的私有成员
友元类           该类中可以直接使用其友元的类中的私有成员

友元全局函数

class A 
{
    friend 返回值类型 函数名(形参列表)；
}

返回值类型 函数名(形参列表)
{
    函数体
}

#include <iostream>
using namespace std;

// 友元   友元 是单向的  甲和乙   甲说 他是乙朋友  乙有可能不承认 所以 是单向的
//  只要是 友元  就可以访问他私有的东西  所以 友元会破坏 封装性

class A
{
    //声明友元全局函数
    friend void method(A &a);
private:
    int x;
    public:
        A(int x):x(x)
        {
            
        }
};
void method(A &a)
{
    cout << a.x << endl;
}

int main(int argc, char const *argv[])
{
    A a1(10);
    method(a1);

    return 0;
}

友元成员函数

class A
class B
{
    public: 
     	返回值类型 函数名(形参列表);  // 声明和定义分开
};
class A
{
    friend 返回值类型B::函数名(形参列表)；
};

返回值类型 B::函数名(形参列表)
{
    函数体；
}

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

//  友元成员函数   但是需要注意顺序 程序是自上而下的执行

class Mouse; // 声明老鼠类
class Cat
{
private:
    char *name;

public:
    Cat()
    {
        this->name = (char *)calloc(50, 1);
    }
    Cat(char *name)
    {
        this->name = (char *)calloc(50, 1);
        strcpy(this->name, name);
    }
    void work(Mouse &m);
};

class Mouse
{
    // 声明 猫的函数为老鼠的友元类 老鼠就可以访问猫的私有东西
    friend void Cat::work(Mouse &m);

private:
    char *name;

public:
    Mouse()
    {
        this->name = (char *)calloc(50, 1);
    }
    Mouse(char *name)
    {
        this->name = (char *)calloc(50, 1);
        strcpy(this->name, name);
    }
};

// 定义和声明分开
void Cat::work(Mouse &m)
{
    cout << name << "抓" << m.name << endl;
}

int main(int argc, char const *argv[])
{
    Mouse m("二蛋");
    Cat mao("张十一");
    mao.work(m);
    return 0;
}

友元类

class B;
class A
{
    friend class B;
}
class B
{
    
}

#include <iostream>
using namespace std;

//  友元类

class B; // 声明B类
class A
{
    friend class B;

private:
    int x;

public:
    A(int x) : x(x)
    {
    }
};

class B
{
public:
    void method01(A &a)
    {
        cout << a.x << endl;
    }
    void method02(A &a)
    {
        cout << a.x << endl;
    }
    void method03(A &a)
    {
        cout << a.x << endl;
    }
};

int main(int argc, char const *argv[])
{
    A a(1);
    B b;
    b.method03(a);
    return 0;
}