C++ day18 使用类（二）友元（类的扩展接口）

我不是女神ヾ 2023-07-15 11:18 14阅读 0赞

### 文章目录 ###

*  友元：另一种形式的访问权限
 *   *  为啥需要友元（为类重载二元运算符时需要）
     *   *  示例1 无法访问私有数据的非成员函数很尴尬
     *  友元函数（可以访问类私有成员的非成员函数，是类接口的组成部分）
     *   *  创建（关键字friend）
         *   *  示例2 把上面那个尴尬的非成员函数变成友元函数
             *  示例3 用友元函数定义重载二元运算符（友元函数作为运算符函数，两个操作数都作为参数传递），以使操作数顺序随意
         *  用友元函数重载插入运算符<<（千万不要试图对ostream类动刀，而要对自己写的类下手）
         *   *  示例4 ostream前一定要用std名称空间前缀，而ostream头文件并不需要include
             *  示例5 让cout可以连用（让友元函数返回一个ostream类的引用）
             *  示例6 输出到fout
     *  友元类
     *  友元成员函数

# 友元：另一种形式的访问权限 #

可以访问类私有数据  
哇塞！！！！  
我刚遇到非成员函数无法访问私有成员的困惑，这就送上解答了，这书的安排简直完美。

之前说了，只有公有接口，即公有成员函数可以访问类的私有数据。但是有时候还是不方便，所以C++又给非成员函数们开了一道小门——友元。真的很友好了。

友元分为三种：友元函数，友元类，友元成员函数

顾名思义，字如其名，友元就是好朋友的意思（所以关键字是friend哇），让函数成为类的友元，类就给这个函数和他自己的成员函数一样的访问权限。  
相当于如果A和B成为好朋友，那B就愿意像对待家人一样，给A也配一把自家的钥匙，让A可以和B的家人有一样的权限访问B的私有财产。

## 为啥需要友元（为类重载二元运算符时需要） ##

### 示例1 无法访问私有数据的非成员函数很尴尬 ###

举个例子，我刚才写的Time类，为了实现两个时间相减，我重载减法运算符。是个二元运算符。  
为了简单，我设计了一个类方法，即成员函数，把Time对象转换为纯秒数，然后相减再转换为Time对象。所以还设计了一个非成员函数把纯秒数转换为时分秒形式的Time对象。

这个非成员函数最终的正确代码，可以看到，里面没有访问Time类的任何私有成员，包括符号常量，只能用数字代替。

Time toTime(ulong secs)
    { 
        Item hour, min, sec;
    
        hour = secs / 3600;
        secs %= 3600;
        min = secs / 60;
        sec = secs % 60;
    
        return Time(hour, min, sec);
    }

可以看到，上面函数的原型在类外部

//mytime.h
    #ifndef MYTIME_H_
    #define MYTIME_H_
    typedef unsigned long ulong;
    typedef unsigned int Item;
    
    class Time{ 
    private:
    	enum { SEC_PER_MIN = 60, MIN_PER_HR = 60};
    	Item hour;
    	Item min;
    	Item sec;
    	ulong toSecs() const;
    public:
    	Time(Item & h, Item & m, Item & s);
    	Time();
    	Time operator+(const Time & t) const;
    	void showTime() const;
    	Time operator-(const Time & t) const;
        Time operator*(double mult) const;
    };
    Time toTime(ulong secs);
    #endif

//main.cpp
    #include <iostream>
    #include "mytime.h"
    
    int main()
    { 
        unsigned int h = 15, m = 14, s = 35;
        unsigned int h1 = 2, m1 = 49, s1 = 55;
        Time t1 = Time(h, m, s);
    	Time t2(h1, m1, s1);
    
    	t1.showTime();
    	t2.showTime();
    	Time t3 = t1 - t2;
    	Time t4 = 2.0 * t1;
    	t1.showTime();
    	t2.showTime();
    	t3.showTime();
    	t4.showTime();
    
        return 0;
    }

下面我们介绍友元函数，然后用友元函数替代这个不能使用符号常量的非成员函数

## 友元函数（可以访问类私有成员的非成员函数，是类接口的组成部分） ##

友元函数虽然作为非成员函数，访问了私有数据，但并没有违反OOP的数据隐藏精神。

因为函数是不是友元是类自己来决定的，用户还是不能随随便便访问私有数据，可以把友元看作是类的接口的扩展，看做是类接口的另一种实现机制，用户多了一个访问私有数据的渠道，但是私有数据的大门并未完全敞开，对非友元函数仍然隐藏。

### 创建（关键字friend） ###

*  1.把原型放在类声明中。在原型前加关键字friend。  
    注意虽然原型放在类声明中，但不是成员函数，所以**不可用成员运算符调用**；  
    该函数的访问权限和成员函数一毛一样。
 *  2.写函数定义。**不要用类别限定符（Time::）。定义中不用friend**

#### 示例2 把上面那个尴尬的非成员函数变成友元函数 ####

Time toTime(ulong secs)
    { 
        Item hour, min, sec;
    
        hour = secs / (Time::MIN_PER_HR * Time::SEC_PER_MIN);
        secs %= (Time::MIN_PER_HR * Time::SEC_PER_MIN);
        min = secs / Time::SEC_PER_MIN;
        sec = secs % Time::SEC_PER_MIN;
    
        return Time(hour, min, sec);
    }

使用这个友元函数的函数是两个运算符函数，注意一定要把上面这个友元函数放在下面俩函数的前面，否则编译器会说没定义toTime函数。

Time Time::operator-(const Time & t) const
    { 
        ulong temp = (*this).toSecs() - t.toSecs();//成员运算符优先级高于解引用！！！
        return toTime(temp);
    }
    
    Time Time::operator*(double mult) const
    { 
        ulong temp = (*this).toSecs();//成员运算符优先级高于解引用！！！
        return toTime(ulong(mult * temp));
    }

头文件中，把友元函数的原型放在了类声明中，由于友元函数是扩展接口，总之是接口，所以要放在公有部分哦。

15:14:35
    2:49:55
    15:14:35
    2:49:55
    12:24:40
    30:29:10

#### 示例3 用友元函数定义重载二元运算符（友元函数作为运算符函数，两个操作数都作为参数传递），以使操作数顺序随意 ####

还是上面的例子，继续修改，这次把运算符函数用友元函数实现，即不是类的成员了，就可以使得操作数顺序随便了，必将刚下的代码，乘以一个实数只能把实数写在后面

之前类成员函数重载版本，一个操作数用this指针隐式传递，一个操作数作为参数传递

//mytime.h
    #ifndef MYTIME_H_
    #define MYTIME_H_
    typedef unsigned long ulong;
    typedef unsigned int Item;
    
    class Time{ 
    private:
    	enum { SEC_PER_MIN = 60, MIN_PER_HR = 60};
    	Item hour;
    	Item min;
    	Item sec;
    	ulong toSecs() const;
    public:
    	Time(Item & h, Item & m, Item & s);
    	Time();
    	Time operator+(const Time & t) const;
    	void showTime() const;
    	Time operator-(const Time & t) const;
        friend Time operator*(const double mult, const Time & t);//用友元函数定义重载二元运算符，以使操作数顺序随意
        friend Time toTime(ulong secs);//友元函数
    };
    
    #endif

#include <iostream>
    #include "mytime.h"
    typedef unsigned long ulong;
    
    Time::Time(Item & h, Item & m, Item & s)
    { 
    	hour = h;
    	min = m;
    	sec = s;
    }
    
    Time::Time()
    { 
    	hour = 0;
    	min = 0;
    	sec = 0;
    }
    
    Time Time::operator+(const Time & t) const
    { 
        Time temp = *this;//存住初始值
    
    	temp.sec = (t.sec + this->sec) % SEC_PER_MIN;
    	temp.min = (t.min + this->min + (t.sec + this->sec) / SEC_PER_MIN) % MIN_PER_HR;
    	temp.hour = t.hour + this->hour + (t.min + this->min + (t.sec + this->sec) / SEC_PER_MIN) / MIN_PER_HR;
    
    	return temp;
    }
    
    Time toTime(ulong secs)
    { 
        Item hour, min, sec;
    
        hour = secs / (Time::MIN_PER_HR * Time::SEC_PER_MIN);
        secs %= (Time::MIN_PER_HR * Time::SEC_PER_MIN);
        min = secs / Time::SEC_PER_MIN;
        sec = secs % Time::SEC_PER_MIN;
    
        return Time(hour, min, sec);
    }
    
    Time Time::operator-(const Time & t) const
    { 
        ulong temp = (*this).toSecs() - t.toSecs();//成员运算符优先级高于解引用！！！
        return toTime(temp);
    }
    
    Time operator*(const double mult, const Time & t)
    { 
        ulong temp = t.toSecs();
        return toTime(ulong(mult * temp));
    }
    
    void Time::showTime() const
    { 
    
    	std::cout << this->hour << ":" << this->min << ":" << this->sec << '\n';
    }
    
    ulong Time::toSecs() const
    { 
        return ((this->hour * MIN_PER_HR + this->min) * SEC_PER_MIN + this->sec);
    }

15:14:35
    2:49:55
    15:14:35
    2:49:55
    12:24:40
    30:29:10

### 用友元函数重载插入运算符<<（千万不要试图对ostream类动刀，而要对自己写的类下手） ###

用了这么久的cout和<<, 今天终于要一探究竟了

其实<<已经被重载过很多次了：  
最初是C和C++的位运算符，即左移运算符，是ostream类把他重载为插入运算符，把他变成一个输出工具的。  
而且在ostream类内部，有不止一个operator<<()定义，即有很多函数重载，参数是不同的类型，比如int, char 等等

如果我写了一个Time类，希望不用showTime类方法显示对象，而用cout和<<来显示,那我们就想办法让Time类知道怎么使用cout,而不要试图修改ostream类文件，毕竟人家是进了库的标准头文件，你去修改标准头文件，就是试图是秀智商下限，很危险。

#### 示例4 ostream前一定要用std名称空间前缀，而ostream头文件并不需要include ####

//main.cpp
    #include <iostream>
    #include "mytime.h"
    
    int main()
    { 
        using std::cout;
        using std::endl;
        unsigned int h = 15, m = 14, s = 35;
        unsigned int h1 = 2, m1 = 49, s1 = 55;
        Time t1 = Time(h, m, s);
    	Time t2(h1, m1, s1);
    
    	cout << t1;
    	cout << endl;
    	cout << t2;
    	cout << endl;
    	Time t3 = t1 - t2;
    	Time t4 = 2.0 * t1;
    	cout << t1;
    	cout << endl;
    	cout << t2;
    	cout << endl;
    	cout << t3;
    	cout << endl;
    	cout << t4;
    	cout << endl;
    
        return 0;
    }

注意不要连用<<,如图，因为cout << t1 << endl;相当于（cout << t1） << endl;，但是（cout << t1）是void, 所以报错,下一个示例解决此问题  
![在这里插入图片描述][20200316200049593.png]

//mytime.h
    #ifndef MYTIME_H_
    #define MYTIME_H_
    typedef unsigned long ulong;
    typedef unsigned int Item;
    
    class Time{ 
    private:
    	enum { SEC_PER_MIN = 60, MIN_PER_HR = 60};
    	Item hour;
    	Item min;
    	Item sec;
    	ulong toSecs() const;
    public:
    	Time(Item & h, Item & m, Item & s);
    	Time();
    	Time operator+(const Time & t) const;
    	void showTime() const;
    	friend void operator<<(std::ostream & os, const Time & t);//有友元函数重载<<
    	Time operator-(const Time & t) const;
        friend Time operator*(const double mult, const Time & t);//用友元函数定义重载二元运算符，以使操作数顺序随意
        friend Time toTime(ulong secs);//友元函数
    };
    
    #endif

注意ostream前一定要用std名称空间前缀，不然报错，不认识这个名称，而ostream头文件并不需要include

认真想想这个示例，会发现我定义的operator<<(std::ostream & os, const Time & t)函数，虽然涉及到了两个类，即ostream类和自己写的Time类，但是它**只是Time类的友元函数**，只访问了Time类对象的私有成员，而并没访问Ostream类对象的私有数据，从头到尾都是把ostream类的**对象当做一个整体**在使用。

15:14:35
    2:49:55
    15:14:35
    2:49:55
    12:24:40
    30:29:10

#### 示例5 让cout可以连用（让友元函数返回一个ostream类的引用） ####

上面的主程序中cout不可连用，但是我们平常用cout都还是经常连着输出的，所以要解决这个问题

首先要知道为啥平常cout可以连用，而我这里不可以。这是因为方法有返回值，返回值就是ostream类的对象。所以对上面程序做一点点小改变（只改返回值）：

friend std::ostream & operator<<(std::ostream & os, const Time & t);

std::ostream & operator<<(std::ostream & os, const Time & t)
    { 
        os << t.hour << ":" << t.min << ":" << t.sec;
        return os;
    }

可以cout << t1 << endl;啦

#### 示例6 输出到fout ####

//main.cpp
    #include <iostream>
    #include <fstream>
    #include "mytime.h"
    
    int main()
    { 
        using std::cout;
        using std::endl;
        unsigned int h = 15, m = 14, s = 35;
        unsigned int h1 = 2, m1 = 49, s1 = 55;
        Time t1 = Time(h, m, s);
    	Time t2(h1, m1, s1);
    
    	std::fstream fout;
    	fout.open("carinfo.txt");
    	fout << t1 << endl;
    	fout << t2 << endl;
    	Time t3 = t1 - t2;
    	Time t4 = 2.0 * t1;
    	fout << t1 << endl;
    	fout << t2 << endl;
    	fout << t3 << endl;
        fout << t4 << endl;
    
        return 0;
    }

![在这里插入图片描述][20200316213307831.png]

对上面的代码做一点点优化：

Time::Time()
    { 
    	hour = 0;
    	min = 0;
    	sec = 0;
    }

改为

Time::Time()
    { 
    	hour = min = sec = 0;
    }

利用多重赋值，简洁优雅

## 友元类 ##

[见这里][Link 1]

## 友元成员函数 ##

[见这里][Link 1]

[20200316200049593.png]: /images/20230528/c1b13e7aebdc4d85ac249d6ea551b0f3.png
[20200316213307831.png]: /images/20230528/7932dcf7b6f94de4a72a115e8d7a2bdb.png
[Link 1]: https://editor.csdn.net/md?articleId=105497463