C++面向对象11：友元类

目录

1.回顾友元函数

2.友元类

3.友元成员函数（缩小友元范围为类的函数）

---

1.回顾友元函数

友元函数是在类外定义的。

在函数名之前没有MyTime：：

class MyTime
{
  // ...
  public:
    friend MyTime operator+(int m, const MyTime & t);//友元函数不是成员函数，不是类的成员，是类的朋友
比如说，这个运算符重载，如果用成员函数，只能是当前这个类型（MyTime）和int m相加，如果反过来整数类型和MyTime相加就不行，因为要访问私有成员
};
MyTime operator+(int m, const MyTime & t)
{
    return t + m;
}

2.友元类

一个类是另一个类的朋友。

友元类可以访问所有成员，甚至私人成员。

友元类可以是公共的、受保护的和私有的。

//狙击手
class Sniper
{
private:
    int bullets;//子弹数量
public:
    Sniper(int bullets = 0);
    friend class Supplier;// Supplier可以窥视所以秘密
};
//共用弹药的后勤人员
class Supplier
{
    int storage;//子弹仓
public:
    Supplier(int storage = 1000);
    bool provide(Sniper & sniper)
    {
        // bullets is a private member
        if (sniper.bullets < 20)
        // ...
    }
};

例子

#include <iostream>
using namespace std;

class Sniper
{
private:
    int bullets;
public:
    Sniper(int bullets = 0): bullets(bullets){}
    friend class Supplier;
};

class Supplier
{
    int storage;
public:
    Supplier(int storage = 1000): storage(storage){}
    bool provide(Sniper & sniper)
    {
        // bullets is a private member
        if (sniper.bullets < 20) //no enough bullets
        {
            if (this->storage > 100 )
            {
                sniper.bullets += 100;
                this->storage -= 100;
            }
            else if(this->storage > 0)
            {
                sniper.bullets += this->storage;
                this->storage = 0;
            }
            else
                return false;
        }
        cout << "sniper has " << sniper.bullets << " bullets now." << endl;
        return true;
    }
};

int main()
{
    Sniper sniper(2);
    Supplier supplier(2000);
    supplier.provide(sniper);
    return 0;
}

3.友元成员函数（缩小友元范围为类的函数）

一个类的单个成员函数就是一个友元。

与友元函数不同。

但与普通的友元函数非常相似。

但是申报问题。。。

class Sniper
{
private:
    int bullets;
public:
    Sniper(int bullets = 0): bullets(bullets){}
    friend bool Supplier::provide(Sniper &);//只有这个函数可以访问bullets
};

#include <iostream>
using namespace std;

class Supplier;
class Sniper;

class Supplier
{
    int storage;
public:
    Supplier(int storage = 1000): storage(storage){}
    bool provide(Sniper & sniper);
};

class Sniper
{
private:
    int bullets;
public:
    Sniper(int bullets = 0): bullets(bullets){}
    friend bool Supplier::provide(Sniper &);//需要声明类
};

bool Supplier::provide(Sniper & sniper)
{
    // bullets is a private member
    if (sniper.bullets < 20) //no enough bullets
    {
        if (this->storage > 100 )
        {
            sniper.bullets += 100;
            this->storage -= 100;
        }
        else if(this->storage > 0)
        {
            sniper.bullets += this->storage;
            this->storage = 0;
        }
        else
            return false;
    }
    cout << "sniper has " << sniper.bullets << " bullets now." << endl;
    return true;
}
int main()
{
    Sniper sniper(2);
    Supplier supplier(2000);
    supplier.provide(sniper);
    return 0;
}