【C++】运算符重载案例 - 字符串类 ④ ( 重载 双等号 == 运算符 | 重载 不等号 != 运算符 | 代码示例 )

刺骨的言语ヽ痛彻心扉 2024-03-01 08:33 99阅读 0赞

文章目录

  • 一、重载 双等号 / 不等号 运算符
    • 1、等于判断 == 运算符重载
    • 2、重载 不等号 != 运算符
  • 三、完整代码示例
    • 1、String.h 类头文件
    • 2、String.cpp 类实现
    • 3、Test.cpp 测试类

一、重载 双等号 / 不等号 运算符

1、等于判断 == 运算符重载

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

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

    • 要对 String a , b 对象对比操作 , 使用 == 运算符 , 使用时用法为 a == b ;
    • 函数名是 operate== ;

    operate==

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

    • 要对 String a , b 对象对比操作 , 使用 == 运算符 , 使用时用法为 a == b ;
    • 左操作数 : 其中 左操作数 是 String a , 这里通过 this 指针调用 , 不需要声明在参数中 ;
    • 右操作数 : 右操作数 是 String b ; 该操作数需要声明在参数中 , 注意需要声明 引用类型 ;
    • 上述两个是对象类型 , 对象一般传入 指针 或 引用 , 这里传入引用类型 ;

    operator==(String & s)

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

    • 此处返回值是 bool 类型 , 返回 true 或者 false 布尔值即可 ;

    bool operator==(String& s)

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

    • 先对比数组的长度是否相等 ;
    • 然后对比数组中每个元素是否相等 ;

    // 重载 双等号 == 运算符
    bool String::operator==(String& s)
    {

    1. // 首先判断数组长度是否相等
    2. if (this->m_len != s.m_len)
    3. {
    5.     return false;
    6. }
    8. for (size_t i = 0; i < this->m_len; i++)
    9. {
    11.     // 只要有一个元素不相等, 整个数组就不相等
    12.     if (this->m_p[i] != s.m_p[i])
    13.     {
    15.         return false;
    16.     }
    17. }
    18. return true;

    }

2、重载 不等号 != 运算符

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

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

    • 要对 String a , b 对象对比操作 , 使用 != 运算符 , 使用时用法为 a != b ;
    • 函数名是 operate!= ;

    operate!=

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

    • 要对 String a , b 对象对比操作 , 使用 != 运算符 , 使用时用法为 a != b ;
    • 左操作数 : 其中 左操作数 是 String a , 这里通过 this 指针调用 , 不需要声明在参数中 ;
    • 右操作数 : 右操作数 是 String b ; 该操作数需要声明在参数中 , 注意需要声明 引用类型 ;
    • 上述两个是对象类型 , 对象一般传入 指针 或 引用 , 这里传入引用类型 ;

    operator!=(String& a)

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

    • 此处返回值是 bool 类型 , 返回 true 或者 false 布尔值即可 ;

    bool operator!=(String& s)

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

    • 先对比数组的长度是否不相等 ;
    • 然后对比数组中每个元素是否不相等 ;

    // 重载 不等号 != 运算符
    bool String::operator!=(String& s)
    {

    1. // 首先判断数组长度是否相等
    2. if (this->m_len != s.m_len)
    3. {
    5.     return false;
    6. }
    8. for (size_t i = 0; i < this->m_len; i++)
    9. {
    11.     // 只要有一个元素不相等, 整个数组就不相等
    12.     if (this->m_p[i] != s.m_p[i])
    13.     {
    15.         return false;
    16.     }
    17. }
    18. return true;

    }

三、完整代码示例

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.     // 有参构造函数 , 接收 int 类型值 , 表示字符串大小
  17.     String(int len);
  19.     // 拷贝构造函数 , 使用 String 对象初始化 对象值
  20.     String(const String& s);
  22.     // 析构函数
  23.     ~String();
  25. public:
  26.     // 重载等号 = 操作符 , 右操作数是 String 对象的情况
  27.     String& operator=(const String& s);
  29.     // 重载等号 = 操作符 , 右操作数是 字符串常量值 的情况
  30.     String& operator=(const char* p);
  32.     // 重载 数组下标 [] 操作符
  33.     char& operator[](int i);
  35.     // 重载 双等号 == 运算符
  36.     bool operator==(String& s);
  38.     // 重载 不等号 != 运算符
  39.     bool operator!=(String& s);
  41.     // 使用 全局函数 实现 左移运算符 << 重载
  42.     // 将全局函数 声明为 String 的友元函数
  43.     friend ostream& operator<<(ostream& out, String& s);
  45. public:
  46.     // 获取私有成员 char* m_p
  47.     char* str();
  49.     // 获取私有成员 int m_len
  50.     int len();
  52. private:
  53.     // 字符串长度 , 不包括 '\0'
  54.     // 内存占用空间大小 = 字符串长度 + 1
  55.     int m_len;
  57.     // 字符串指针, 指向堆内存中的字符串
  58.     char* m_p;
  59. };

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(this->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(this->m_p, p);
  59.     }
  60.     cout << "调用有参构造函数" << endl;
  61. }
  63. // 有参构造函数 , 接收 int 类型值 , 表示字符串大小
  64. String::String(int len)
  65. {
  67.     if (len == 0)
  68.     {
  70.         // 默认构造一个空字符串 , 字符串长度为 0 
  71.         // 但是 , 字符串指针 指向的内存空间大小是 1 , 内容是 '\0'
  72.         this->m_len = 0;
  74.         // 使用 new 关键字为 char* m_p; 指针分配内存
  75.         // 对于基础数据类型 new 等同于 malloc
  76.         this->m_p = new char[this->m_len + 1];
  78.         // 拷贝空字符串到 m_p 指向的内存中
  79.         strcpy(this->m_p, "");
  80.     }
  81.     else
  82.     {
  84.         // 获取传入字符串的长度
  85.         // 但是 , 字符串指针 指向的内存空间大小需要 +1 , 内容是 '\0'
  86.         this->m_len = len;
  88.         // 使用 new 关键字为 char* m_p; 指针分配内存
  89.         // 对于基础数据类型 new 等同于 malloc
  90.         this->m_p = new char[this->m_len + 1];
  92.         // 将内存空间设置为 0 内容
  93.         memset(this->m_p, 0, this->m_len);
  94.     }
  95. };
  97. // 拷贝构造函数 , 使用 String 对象初始化 对象值
  98. String::String(const String& s)
  99. {
  101.     // 拷贝字符串长度
  102.     // 注意 : 字符串指针 指向的内存空间大小需要 +1 , 内容是 '\0'
  103.     this->m_len = s.m_len;
  105.     // 使用 new 关键字为 char* m_p; 指针分配内存
  106.     // 对于基础数据类型 new 等同于 malloc
  107.     this->m_p = new char[this->m_len + 1];
  109.     // 拷贝字符串到 m_p 指向的内存中
  110.     strcpy(this->m_p, s.m_p);
  112.     cout << "调用拷贝构造函数" << endl;
  113. }
  115. // 析构函数
  116. String::~String()
  117. {
  119.     if (this->m_p != NULL)
  120.     {
  122.         // 之前使用 new 分配的内存
  123.         // 释放内存就需要使用 delete 
  124.         // 使用 malloc 分配的内存需要使用 free 释放
  125.         delete[] this->m_p;
  127.         // 设置指针指为空 , 避免出现野指针
  128.         this->m_p = NULL;
  130.         // 设置字符串长度为 0
  131.         this->m_len = 0;
  132.     }
  133. }
  135. // 重载等号 = 操作符 , 右操作数是 String 对象的情况
  136. String& String::operator=(const String& s)
  137. {
  139.     // 先处理本对象已分配的内存
  140.     if (this->m_p != NULL)
  141.     {
  143.         // 之前使用 new 分配的内存
  144.         // 释放内存就需要使用 delete 
  145.         // 使用 malloc 分配的内存需要使用 free 释放
  146.         delete[] this->m_p;
  148.         // 设置指针指为空 , 避免出现野指针
  149.         this->m_p = NULL;
  151.         // 设置字符串长度为 0
  152.         this->m_len = 0;
  153.     }
  155.     // 拷贝字符串长度
  156.     // 注意 : 字符串指针 指向的内存空间大小需要 +1 , 内容是 '\0'
  157.     this->m_len = s.m_len;
  159.     // 使用 new 关键字为 char* m_p; 指针分配内存
  160.     // 对于基础数据类型 new 等同于 malloc
  161.     this->m_p = new char[this->m_len + 1];
  163.     // 拷贝字符串到 m_p 指向的内存中
  164.     strcpy(this->m_p, s.m_p);
  166.     cout << "调用重载 等号 = 操作符函数 String& String::operator=(const String& s)" << endl;
  168.     return *this;
  169. }
  171. // 重载等号 = 操作符 , 右操作数是 字符串常量值 的情况
  172. String& String::operator=(const char* p)
  173. {
  175.     // 先处理本对象已分配的内存
  176.     if (this->m_p != NULL)
  177.     {
  179.         // 之前使用 new 分配的内存
  180.         // 释放内存就需要使用 delete 
  181.         // 使用 malloc 分配的内存需要使用 free 释放
  182.         delete[] this->m_p;
  184.         // 设置指针指为空 , 避免出现野指针
  185.         this->m_p = NULL;
  187.         // 设置字符串长度为 0
  188.         this->m_len = 0;
  189.     }
  191.     // 拷贝字符串长度
  192.     // 注意 : 字符串指针 指向的内存空间大小需要 +1 , 内容是 '\0'
  193.     this->m_len = strlen(p);
  195.     // 使用 new 关键字为 char* m_p; 指针分配内存
  196.     // 对于基础数据类型 new 等同于 malloc
  197.     this->m_p = new char[this->m_len + 1];
  199.     // 拷贝字符串到 m_p 指向的内存中
  200.     strcpy(this->m_p, p);
  202.     cout << "调用重载 等号 = 操作符函数 String& String::operator=(const char* p)" << endl;
  204.     return *this;
  205. }
  207. // 重载 数组下标 [] 操作符
  208. char& String::operator[](int i)
  209. {
  211.     cout << "调用重载 下标 [] 操作符函数 char& String::operator[](int i)" << endl;
  213.     // 直接返回对应 i 索引字符
  214.     return this->m_p[i];
  215. }
  217. // 重载 双等号 == 运算符
  218. bool String::operator==(String& s)
  219. {
  221.     // 首先判断数组长度是否相等
  222.     if (this->m_len != s.m_len)
  223.     {
  225.         return false;
  226.     }
  228.     for (size_t i = 0; i < this->m_len; i++)
  229.     {
  231.         // 只要有一个元素不相等, 整个数组就不相等
  232.         if (this->m_p[i] != s.m_p[i])
  233.         {
  235.             return false;
  236.         }
  237.     }
  238.     return true;
  239. }
  241. // 重载 不等号 != 运算符
  242. bool String::operator!=(String& s)
  243. {
  245.     // 首先判断数组长度是否相等
  246.     if (this->m_len != s.m_len)
  247.     {
  249.         return false;
  250.     }
  252.     for (size_t i = 0; i < this->m_len; i++)
  253.     {
  255.         // 只要有一个元素不相等, 整个数组就不相等
  256.         if (this->m_p[i] != s.m_p[i])
  257.         {
  259.             return false;
  260.         }
  261.     }
  262.     return true;
  263. }
  265. // 获取私有成员 char* m_p
  266. char* String::str()
  267. {
  269.     return this->m_p;
  270. }
  272. // 获取私有成员 int m_len
  273. int String::len()
  274. {
  276.     return this->m_len;
  277. }
  279. // 全局函数 中实现 String 左移运算符重载
  280. // 返回 ostream& 引用类型 , 是为了支持链式调用 cout << s1 << endl;
  281. ostream& operator<<(ostream& out, String& s)
  282. {
  284.     cout << "调用重载 左移 << 操作符函数 ostream& operator<<(ostream& out, String& s)" << endl;
  286.     // 在函数体中将 String 对象的 m_p 指针指向的数据输出到 out 输出流中
  287.     out << s.m_p  << endl;
  289.     // 该返回值还需要当左值使用
  290.     return out;
  291. }

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];
  28.     // 调用 重载的 左移运算符 函数
  29.     cout << s3 << endl;
  31.     // 控制台暂停 , 按任意键继续向后执行
  32.     system("pause");
  34.     return 0;
  35. }

发表评论

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

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

相关阅读