【C++】运算符重载案例 - 字符串类 ② ( 重载 等号 = 运算符 | 重载 数组下标 [] 操作符 | 完整代码示例 )

电玩女神 2024-02-23 01:49 142阅读 0赞

文章目录

  • 一、重载 等号 = 运算符
    • 1、等号 = 运算符 与 拷贝构造函数
    • 2、重载 等号 = 运算符 - 右操作数为 String 对象
    • 3、不同的右操作数对应的 重载运算符函数
  • 二、重载 下标 [] 运算符
  • 三、完整代码示例
    • 1、String.h 类头文件
    • 2、String.cpp 类实现
    • 3、Test.cpp 测试类
    • 4、执行结果

一、重载 等号 = 运算符

1、等号 = 运算符 与 拷贝构造函数

等号 = 操作符 的 作用是 使用一个现有对象 为 另外一个现有对象赋值 ;

  • 注意与 拷贝构造函数 区分 , 拷贝构造函数是 使用一个先有对象 为 一个新的对象进行初始化 ;

  • 下面的代码中 , 分别调用 等号操作符 和 拷贝构造函数 ;

    String s1, s2;
    s1 = s2; // 这是使用 等号操作符 进行运算
    String s3 = s2; // 这是使用 拷贝构造函数

2、重载 等号 = 运算符 - 右操作数为 String 对象

使用 成员函数 实现 重载 等号 = 运算符 :

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

    • 2 2 2 个对象 Student s1, s2 之间进行 等号运算 , 使用一个现有对象 为 另外一个现有对象赋值 ;
    • 使用时用法为 s1 = s2 ;
    • 函数名是 operator= ;

    operator=

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

    • 等号运算符 使用时用法为 s1 = s2 ;
    • 左操作数 : 其中 左操作数 是 s1 , 这里通过 this 指针调用 , 不需要声明在参数中 ;
    • 右操作数 - 情况 ① : 右操作数 也是 String 对象 ; 该操作数需要声明在参数中 , 注意 普通数据类型 直接声明 , 对象数据类型 需要声明 为 引用类型 ;
    • 上述两个是对象类型 , 对象一般传入 指针 或 引用 , 由于是基础数据类型 , 这里传入基础数据类型 ; 如果是 对象类型 , 则传入引用 ;
    • 右操作数 - 情况 ② : 还有一种情况是 s1 = "Tom" 的用法 , 这样 右操作数 是 char* 类型的字符串 ;

    operator=(const String& s) // 传入 String 对象 , 使用 const 修饰参数 , 防止传入的对象被修改
    operator=(const char* p) // 传入字符串值

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

    • 此处返回值返回 String& 对象引用 , 可用于其它链式调用 ;
    • 如果返回 String 对象 , 则是一次性的匿名对象 ;

    String& operator=(const String& s) // 传入 String 对象 , 使用 const 修饰参数 , 防止传入的对象被修改
    String& operator=(const char* p) // 传入字符串值

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

    • 先把本对象已分配的内存释放掉 ;
    • 再进行赋值操作 ;

3、不同的右操作数对应的 重载运算符函数

不同的右操作数对应的 重载运算符函数 :

  • 右操作数是 String 对象的情况 :

    // 重载等号 = 操作符 , 右操作数是 String 对象的情况
    String& String::operator=(const String& s)
    {

    1. // 先处理本对象已分配的内存
    2. if (this->m_p != NULL)
    3. {
    5.     // 之前使用 new 分配的内存
    6.     // 释放内存就需要使用 delete 
    7.     // 使用 malloc 分配的内存需要使用 free 释放
    8.     delete[] this->m_p;
    10.     // 设置指针指为空 , 避免出现野指针
    11.     this->m_p = NULL;
    13.     // 设置字符串长度为 0
    14.     this->m_len = 0;
    15. }
    17. // 拷贝字符串长度
    18. // 注意 : 字符串指针 指向的内存空间大小需要 +1 , 内容是 '\0'
    19. this->m_len = s.m_len;
    21. // 使用 new 关键字为 char* m_p; 指针分配内存
    22. // 对于基础数据类型 new 等同于 malloc
    23. this->m_p = new char[this->m_len + 1];
    25. // 拷贝字符串到 m_p 指向的内存中
    26. strcpy(this->m_p, s.m_p);
    28. cout << "调用重载等号 = 操作符函数 String& String::operator=(const String& s)" << endl;
    30. return *this;

    }

  • 右操作数为 字符串指针 的情况 :

    // 重载等号 = 操作符 , 右操作数是 字符串常量值 的情况
    String& String::operator=(const char* p)
    {

    1. // 先处理本对象已分配的内存
    2. if (this->m_p != NULL)
    3. {
    5.     // 之前使用 new 分配的内存
    6.     // 释放内存就需要使用 delete 
    7.     // 使用 malloc 分配的内存需要使用 free 释放
    8.     delete[] this->m_p;
    10.     // 设置指针指为空 , 避免出现野指针
    11.     this->m_p = NULL;
    13.     // 设置字符串长度为 0
    14.     this->m_len = 0;
    15. }
    17. // 拷贝字符串长度
    18. // 注意 : 字符串指针 指向的内存空间大小需要 +1 , 内容是 '\0'
    19. this->m_len = strlen(p);
    21. // 使用 new 关键字为 char* m_p; 指针分配内存
    22. // 对于基础数据类型 new 等同于 malloc
    23. this->m_p = new char[this->m_len + 1];
    25. // 拷贝字符串到 m_p 指向的内存中
    26. strcpy(this->m_p, p);
    28. cout << "调用重载等号 = 操作符函数 String& String::operator=(const char* p)" << endl;
    30. return *this;

    }

二、重载 下标 [] 运算符

使用 成员函数 实现 重载 下标 [] 运算符 :

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

    • 下标 [] 运算符 , 使用时用法为 s[10] ;
    • 重载 下标 [] 运算符 函数名是 operator[] ;

    operator[]

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

    • 下标 运算符 使用时用法为 s[10] ;
    • 左操作数 : 其中 左操作数 是 s 对象 , 这里通过 this 指针调用 , 不需要声明在参数中 ;
    • 右操作数 : 右操作数 是 int 类型 索引值 ;

    operator

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

    • 此处返回值 是 char 类型的 , 返回具体字符串指定索引的 char 类型字符 ;
    • char 字符是内存中的一个地址中的值 , 这里返回引用类型 ;

    char& operator

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

    // 重载 数组下标 [] 操作符
    char& String::operator
    {

    1. // 直接返回对应 i 索引字符
    2. return this->m_p[i];

    }

三、完整代码示例

1、String.h 类头文件

  1. #pragma once
  3. #include "iostream"
  4. using namespace std;
  6. class String
  7. {
  9. public:
  10.     // 默认的无参构造函数
  11.     String();
  13.     // 有参构造函数 , 接收一个 char* 类型字符串指针
  14.     String(const char* p);
  16.     // 拷贝构造函数 , 使用 String 对象初始化 对象值
  17.     String(const String& s);
  19.     // 析构函数
  20.     ~String();
  22. public:
  23.     // 重载等号 = 操作符 , 右操作数是 String 对象的情况
  24.     String& operator=(const String& s);
  26.     // 重载等号 = 操作符 , 右操作数是 字符串常量值 的情况
  27.     String& operator=(const char* p);
  29.     // 重载 数组下标 [] 操作符
  30.     char& operator[](int i);
  32. private:
  33.     // 字符串长度 , 不包括 '\0'
  34.     // 内存占用空间大小 = 字符串长度 + 1
  35.     int m_len;
  37.     // 字符串指针, 指向堆内存中的字符串
  38.     char* m_p;
  39. };

2、String.cpp 类实现

  1. // 使用 strcpy 函数报错
  2. // error C4996: 'strcpy': This function or variable may be unsafe. 
  3. // Consider using strcpy_s instead. 
  4. // To disable deprecation, use _CRT_SECURE_NO_WARNINGS. 
  5. // See online help for details.
  6. #define _CRT_SECURE_NO_WARNINGS
  8. #include "String.h"
  10. // 默认的无参构造函数
  11. String::String()
  12. {
  14.     // 默认构造一个空字符串 , 字符串长度为 0 
  15.     // 但是 , 字符串指针 指向的内存空间大小是 1 , 内容是 '\0'
  16.     m_len = 0;
  18.     // 使用 new 关键字为 char* m_p; 指针分配内存
  19.     // 对于基础数据类型 new 等同于 malloc
  20.     m_p = new char[m_len + 1];
  22.     // 拷贝空字符串到 m_p 指向的内存中
  23.     strcpy(m_p, "");
  25.     cout << "调用无参构造函数" << endl;
  26. }
  28. // 有参构造函数 , 接收一个 char* 类型字符串指针
  29. String::String(const char* p)
  30. {
  32.     if (p == NULL)
  33.     {
  35.         // 默认构造一个空字符串 , 字符串长度为 0 
  36.         // 但是 , 字符串指针 指向的内存空间大小是 1 , 内容是 '\0'
  37.         this->m_len = 0;
  39.         // 使用 new 关键字为 char* m_p; 指针分配内存
  40.         // 对于基础数据类型 new 等同于 malloc
  41.         this->m_p = new char[this->m_len + 1];
  43.         // 拷贝空字符串到 m_p 指向的内存中
  44.         strcpy(m_p, "");
  45.     }
  46.     else
  47.     {
  49.         // 获取传入字符串的长度
  50.         // 但是 , 字符串指针 指向的内存空间大小需要 +1 , 内容是 '\0'
  51.         this->m_len = strlen(p);
  53.         // 使用 new 关键字为 char* m_p; 指针分配内存
  54.         // 对于基础数据类型 new 等同于 malloc
  55.         this->m_p = new char[this->m_len + 1];
  57.         // 拷贝字符串到 m_p 指向的内存中
  58.         strcpy(m_p, p);
  59.     }
  60.     cout << "调用有参构造函数" << endl;
  61. };
  63. // 拷贝构造函数 , 使用 String 对象初始化 对象值
  64. String::String(const String& s)
  65. {
  67.     // 拷贝字符串长度
  68.     // 注意 : 字符串指针 指向的内存空间大小需要 +1 , 内容是 '\0'
  69.     this->m_len = s.m_len;
  71.     // 使用 new 关键字为 char* m_p; 指针分配内存
  72.     // 对于基础数据类型 new 等同于 malloc
  73.     this->m_p = new char[this->m_len + 1];
  75.     // 拷贝字符串到 m_p 指向的内存中
  76.     strcpy(this->m_p, s.m_p);
  78.     cout << "调用拷贝构造函数" << endl;
  79. }
  81. // 析构函数
  82. String::~String()
  83. {
  85.     if (this->m_p != NULL)
  86.     {
  88.         // 之前使用 new 分配的内存
  89.         // 释放内存就需要使用 delete 
  90.         // 使用 malloc 分配的内存需要使用 free 释放
  91.         delete[] this->m_p;
  93.         // 设置指针指为空 , 避免出现野指针
  94.         this->m_p = NULL;
  96.         // 设置字符串长度为 0
  97.         this->m_len = 0;
  98.     }
  99. }
  101. // 重载等号 = 操作符 , 右操作数是 String 对象的情况
  102. String& String::operator=(const String& s)
  103. {
  105.     // 先处理本对象已分配的内存
  106.     if (this->m_p != NULL)
  107.     {
  109.         // 之前使用 new 分配的内存
  110.         // 释放内存就需要使用 delete 
  111.         // 使用 malloc 分配的内存需要使用 free 释放
  112.         delete[] this->m_p;
  114.         // 设置指针指为空 , 避免出现野指针
  115.         this->m_p = NULL;
  117.         // 设置字符串长度为 0
  118.         this->m_len = 0;
  119.     }
  121.     // 拷贝字符串长度
  122.     // 注意 : 字符串指针 指向的内存空间大小需要 +1 , 内容是 '\0'
  123.     this->m_len = s.m_len;
  125.     // 使用 new 关键字为 char* m_p; 指针分配内存
  126.     // 对于基础数据类型 new 等同于 malloc
  127.     this->m_p = new char[this->m_len + 1];
  129.     // 拷贝字符串到 m_p 指向的内存中
  130.     strcpy(this->m_p, s.m_p);
  132.     cout << "调用重载 等号 = 操作符函数 String& String::operator=(const String& s)" << endl;
  134.     return *this;
  135. }
  137. // 重载等号 = 操作符 , 右操作数是 字符串常量值 的情况
  138. String& String::operator=(const char* p)
  139. {
  141.     // 先处理本对象已分配的内存
  142.     if (this->m_p != NULL)
  143.     {
  145.         // 之前使用 new 分配的内存
  146.         // 释放内存就需要使用 delete 
  147.         // 使用 malloc 分配的内存需要使用 free 释放
  148.         delete[] this->m_p;
  150.         // 设置指针指为空 , 避免出现野指针
  151.         this->m_p = NULL;
  153.         // 设置字符串长度为 0
  154.         this->m_len = 0;
  155.     }
  157.     // 拷贝字符串长度
  158.     // 注意 : 字符串指针 指向的内存空间大小需要 +1 , 内容是 '\0'
  159.     this->m_len = strlen(p);
  161.     // 使用 new 关键字为 char* m_p; 指针分配内存
  162.     // 对于基础数据类型 new 等同于 malloc
  163.     this->m_p = new char[this->m_len + 1];
  165.     // 拷贝字符串到 m_p 指向的内存中
  166.     strcpy(this->m_p, p);
  168.     cout << "调用重载 等号 = 操作符函数 String& String::operator=(const char* p)" << endl;
  170.     return *this;
  171. }
  173. // 重载 数组下标 [] 操作符
  174. char& String::operator[](int i)
  175. {
  177.     cout << "调用重载 下标 [] 操作符函数 char& String::operator[](int i)" << endl;
  179.     // 直接返回对应 i 索引字符
  180.     return this->m_p[i];
  181. }

3、Test.cpp 测试类

  1. #include "iostream"
  2. using namespace std;
  4. // 导入自定义的 String 类
  5. #include "String.h"
  7. int main() {
  10.     // 调用无参构造函数
  11.     String s1;
  13.     // 调用有参构造函数
  14.     String s2("Tom");
  16.     // 调用拷贝构造函数
  17.     String s3 = s2;
  19.     // 调用重载的等号运算符函数, 右操作数是 String 对象
  20.     s1 = s2;
  22.     // 调用重载的等号运算符函数, 右操作数是 字符串常量值 , char* 指针类型
  23.     s3 = "Jerry";
  25.     // 调用重载的下标运算符函数
  26.     char c = s3[3];
  29.     // 控制台暂停 , 按任意键继续向后执行
  30.     system("pause");
  32.     return 0;
  33. }

4、执行结果

执行结果 :

  1. 调用无参构造函数
  2. 调用有参构造函数
  3. 调用拷贝构造函数
  4. 调用重载 等号 = 操作符函数 String& String::operator=(const String& s)
  5. 调用重载 等号 = 操作符函数 String& String::operator=(const char* p)
  6. 调用重载 下标 [] 操作符函数 char& String::operator[](int i)

在这里插入图片描述

发表评论

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

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

相关阅读