【C++】运算符重载 ⑦ ( 一元运算符重载 | 后置运算符重载 | 使用全局函数实现后置 ++ 自增运算符重载 | 使用成员函数实现后置 -- 自减运算符重载 )

雨点打透心脏的1/2处 2024-02-25 07:45 15阅读 0赞

#### 文章目录 ####

*  一、后置运算符重载
 *   *  1、使用 全局函数 实现 后置 ++ 自增运算符重载
     *  2、使用 成员函数 实现 后置 -- 自减运算符重载
 *  二、完整代码示例

上一篇博客 [【C++】运算符重载 ⑥ ( 一元运算符重载 | 后置运算符重载 | 前置运算符重载 与 后置运算符重载 的区别 | 后置运算符重载添加 int 占位参数 )][C_ _ _ _ _ _ _ _ _ _ _ _ _ int _] 中 , 讲解了 前置运算符重载 与 后置运算符重载 的区别 ,

*  **前置运算符重载 :** `Student& operator++(Student& s)` , 返回的是对象引用 , 参数正常 ;
 *  **后置运算符重载 :** `Student operator++(Student& s, int)` , 返回的事对象值 , 参数列表最后一位需要添加 int 类型的占位参数 ;

由此可见 , 后置运算符重载的难度高于前置运算符 ;

## 一、后置运算符重载 ##

--------------------

### 1、使用 全局函数 实现 后置 ++ 自增运算符重载 ###

**使用 全局函数 实现 后置 ++ 自增运算符重载 :**

*  **首先 ,** 写出函数名 , 函数名规则为 " operate " 后面跟上要重载的运算符 , 函数名是 `operate++` ;

operate++

*  **然后 ,** 根据操作数 写出函数参数 , 参数一般都是 对象的引用 ; 
    
     *  **此处由于是一元运算符重载 , 只需要对本对象进行操作 , 需要传入对象本身作为参数 , 另外为了与前置运算符作区分 , 添加了 int 类型占位参数 ;**

operator++(Student& s, int)

*  **再后 ,** 根据业务完善返回值 , 返回值可以是 引用 / 指针 / 元素 ; 
    
     *  实现 1 个 Student 对象 自增运算 ;
     *  先使用 参数中的 Student& s 对象 , 再自增 ;
     *  因此 Student& s 对象是需要自增的 , 但是使用的对象 就是 返回的对象, 必须是没有自增的对象 ;
     *  这里使用 ret 保存 s 对象值 , 然后返回该 ret 值 , 这是没有自增的对象 ;
     *  s 对象中的值需要自增 ;

Student operator++(Student& s, int)

*  **最后 ,** 实现函数体 , 编写具体的运算符操作业务逻辑 ;

// 使用 全局函数 实现 后置 ++ 自增运算符重载
    // 重载 后置 ++ 运算符
    // 实现 1 个 Student 对象 自增运算
    // 先使用 参数中的 Student& s 对象 , 再自增
    // 因此 Student& s 对象是需要自增的 
    // 但是使用的对象 就是 返回的对象, 必须是没有自增的对象
    // 这里使用 ret 保存 s 对象值 , 然后返回该 ret 值 
    // s 对象中的值自增
    // 返回的是一个新 Student 对象
    Student operator++(Student& s, int)
    {
        
    	Student ret = s;
    	s.age++;
    	s.height++;
    	return ret;
    };

### 2、使用 成员函数 实现 后置 – 自减运算符重载 ###

**使用 成员函数 实现 后置 – 自减运算符重载 :**

*  **首先 ,** 写出函数名 , 函数名规则为 " operate " 后面跟上要重载的运算符 , 函数名是 `operate--` ;

operate--

*  **然后 ,** 根据操作数 写出函数参数 , 参数一般都是 对象的引用 ; 
    
     *  **此处由于是一元运算符重载 , 只需要对本对象进行操作 , 不需要将对象本身进行传入了 , 直接使用 this 指针操作对象 , 只添加 int 类型占位参数 ;**

operator--(int)

*  **再后 ,** 根据业务完善返回值 , 返回值可以是 引用 / 指针 / 元素 ; 
    
     *  实现 1 个 Student 对象 自减运算
     *  先使用 this 指针指向的对象 , 再自减 ;
     *  因此 this 指针指向的对象 是需要自减的 , 但是使用的对象 就是 返回的对象, 必须是没有自减的对象 ;
     *  这里使用 ret 保存 this 指针指向的对象值 , 然后返回该 ret 值 , 这是没有自减的对象值 ;
     *  this 指针指向的对象值自减 ;

Student operator--(int)

*  **最后 ,** 实现函数体 , 编写具体的运算符操作业务逻辑 ;

public:
    	// 使用 成员函数 实现 后置 -- 自减运算符重载
    	// 重载 后置 -- 运算符
    	// 实现 1 个 Student 对象 自减运算
    	// 先使用 this 指针指向的对象 , 再自减
    	// 因此  this 指针指向的对象 是需要自减的 
    	// 但是使用的对象 就是 返回的对象, 必须是没有自减的对象
    	// 这里使用 ret 保存  this 指针指向的对象值 , 然后返回该 ret 值 
    	// this 指针指向的对象值自减
    	// 返回的是一个新 Student 对象
    	Student operator--(int)
    	{
        
    		Student ret = *this;
    		this->age--;
    		this->height--;
    		return ret;
    	};

## 二、完整代码示例 ##

--------------------

**代码示例 :**

#include "iostream"
    using namespace std;
    
    class Student
    {
        
    public:
    	// 带参构造函数 , 为参数设置默认值
    	Student(int age = 1, int height = 1)
    	{
        
    		this->age = age;
    		this->height = height;
    	};
    
    public:
    	// 打印类数据
    	void print()
    	{
        
    		cout << "age = " << age << " , height = " << height << endl;
    	};
    
    public:
    	// 使用 成员函数 实现 后置 -- 自减运算符重载
    	// 重载 后置 -- 运算符
    	// 实现 1 个 Student 对象 自减运算
    	// 先使用 this 指针指向的对象 , 再自减
    	// 因此  this 指针指向的对象 是需要自减的 
    	// 但是使用的对象 就是 返回的对象, 必须是没有自减的对象
    	// 这里使用 ret 保存  this 指针指向的对象值 , 然后返回该 ret 值 
    	// this 指针指向的对象值自减
    	// 返回的是一个新 Student 对象
    	Student operator--(int)
    	{
        
    		Student ret = *this;
    		this->age--;
    		this->height--;
    		return ret;
    	};
    
    public:
    	int age;		// 年龄
    	int height;		// 身高
    };
    
    // 使用 全局函数 实现 前置 ++ 自增运算符重载
    // 重载 前置 ++ 运算符
    // 实现 1 个 Student 对象 自增运算
    // 由于 参数中的 Student& s 中的属性发生了变化 
    // 返回时仍需要返回 Student& s 参数本身
    Student& operator++(Student& s)
    {
        
    	s.age++;
    	s.height++;
    	return s;
    };
    
    // 使用 全局函数 实现 后置 ++ 自增运算符重载
    // 重载 后置 ++ 运算符
    // 实现 1 个 Student 对象 自增运算
    // 先使用 参数中的 Student& s 对象 , 再自增
    // 因此 Student& s 对象是需要自增的 
    // 但是使用的对象 就是 返回的对象, 必须是没有自增的对象
    // 这里使用 ret 保存 s 对象值 , 然后返回该 ret 值 
    // s 对象中的值自增
    // 返回的是一个新 Student 对象
    Student operator++(Student& s, int)
    {
        
    	Student ret = s;
    	s.age++;
    	s.height++;
    	return ret;
    };
    
    int main() {
        
    	// 自定义类型相加
    	Student s1(10, 120), s2(18, 170);
    	Student s3, s4, s5;
    
    	++s1;
    	s1.print();
    
    	s2++;
    	s2.print();
    
    	s2--;
    	s2.print();
    
        // 控制台暂停 , 按任意键继续向后执行
        system("pause");
    
        return 0;
    };

**执行结果 :**

age = 11 , height = 121
    age = 19 , height = 171
    age = 18 , height = 170
    请按任意键继续. . .

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

[C_ _ _ _ _ _ _ _ _ _ _ _ _ int _]: https://hanshuliang.blog.csdn.net/article/details/133576282
[168ccc7b66b74d5880d4802a33af7f56.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/7737c3e46c344e1589b7378f79e3dc7d.png