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

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

文章目录

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

上一篇博客 【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)
    {

    1. Student ret = s;
    2. s.age++;
    3. s.height++;
    4. return ret;

    };

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

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

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

    operate—

  • 然后 , 根据操作数 写出函数参数 , 参数一般都是 对象的引用 ;

    • 此处由于是一元运算符重载 , 只需要对本对象进行操作 , 不需要将对象本身进行传入了 , 直接使用 this 指针操作对象 , 只添加 int 类型占位参数 ;

    operator—(int)

  • 再后 , 根据业务完善返回值 , 返回值可以是 引用 / 指针 / 元素 ;

    • 实现 1 个 Student 对象 自减运算
    • 先使用 this 指针指向的对象 , 再自减 ;
    • 因此 this 指针指向的对象 是需要自减的 , 但是使用的对象 就是 返回的对象, 必须是没有自减的对象 ;
    • 这里使用 ret 保存 this 指针指向的对象值 , 然后返回该 ret 值 , 这是没有自减的对象值 ;
    • this 指针指向的对象值自减 ;

    Student operator—(int)

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

    public:

    1. // 使用 成员函数 实现 后置 -- 自减运算符重载
    2. // 重载 后置 -- 运算符
    3. // 实现 1 个 Student 对象 自减运算
    4. // 先使用 this 指针指向的对象 , 再自减
    5. // 因此  this 指针指向的对象 是需要自减的 
    6. // 但是使用的对象 就是 返回的对象, 必须是没有自减的对象
    7. // 这里使用 ret 保存  this 指针指向的对象值 , 然后返回该 ret 值 
    8. // this 指针指向的对象值自减
    9. // 返回的是一个新 Student 对象
    10. Student operator--(int)
    11. {
    13.     Student ret = *this;
    14.     this->age--;
    15.     this->height--;
    16.     return ret;
    17. };

二、完整代码示例

代码示例 :

  1. #include "iostream"
  2. using namespace std;
  4. class Student
  5. {
  7. public:
  8.     // 带参构造函数 , 为参数设置默认值
  9.     Student(int age = 1, int height = 1)
  10.     {
  12.         this->age = age;
  13.         this->height = height;
  14.     };
  16. public:
  17.     // 打印类数据
  18.     void print()
  19.     {
  21.         cout << "age = " << age << " , height = " << height << endl;
  22.     };
  24. public:
  25.     // 使用 成员函数 实现 后置 -- 自减运算符重载
  26.     // 重载 后置 -- 运算符
  27.     // 实现 1 个 Student 对象 自减运算
  28.     // 先使用 this 指针指向的对象 , 再自减
  29.     // 因此  this 指针指向的对象 是需要自减的 
  30.     // 但是使用的对象 就是 返回的对象, 必须是没有自减的对象
  31.     // 这里使用 ret 保存  this 指针指向的对象值 , 然后返回该 ret 值 
  32.     // this 指针指向的对象值自减
  33.     // 返回的是一个新 Student 对象
  34.     Student operator--(int)
  35.     {
  37.         Student ret = *this;
  38.         this->age--;
  39.         this->height--;
  40.         return ret;
  41.     };
  43. public:
  44.     int age;        // 年龄
  45.     int height;        // 身高
  46. };
  48. // 使用 全局函数 实现 前置 ++ 自增运算符重载
  49. // 重载 前置 ++ 运算符
  50. // 实现 1 个 Student 对象 自增运算
  51. // 由于 参数中的 Student& s 中的属性发生了变化 
  52. // 返回时仍需要返回 Student& s 参数本身
  53. Student& operator++(Student& s)
  54. {
  56.     s.age++;
  57.     s.height++;
  58.     return s;
  59. };
  61. // 使用 全局函数 实现 后置 ++ 自增运算符重载
  62. // 重载 后置 ++ 运算符
  63. // 实现 1 个 Student 对象 自增运算
  64. // 先使用 参数中的 Student& s 对象 , 再自增
  65. // 因此 Student& s 对象是需要自增的 
  66. // 但是使用的对象 就是 返回的对象, 必须是没有自增的对象
  67. // 这里使用 ret 保存 s 对象值 , 然后返回该 ret 值 
  68. // s 对象中的值自增
  69. // 返回的是一个新 Student 对象
  70. Student operator++(Student& s, int)
  71. {
  73.     Student ret = s;
  74.     s.age++;
  75.     s.height++;
  76.     return ret;
  77. };
  79. int main() {
  81.     // 自定义类型相加
  82.     Student s1(10, 120), s2(18, 170);
  83.     Student s3, s4, s5;
  85.     ++s1;
  86.     s1.print();
  88.     s2++;
  89.     s2.print();
  91.     s2--;
  92.     s2.print();
  94.     // 控制台暂停 , 按任意键继续向后执行
  95.     system("pause");
  97.     return 0;
  98. };

执行结果 :

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

在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，94人围观）

还没有评论，来说两句吧...

相关阅读