c/c++语言开发共享C++ 赋值运算符'='的重载(浅拷贝、深拷贝)

01 赋值运算符重载的需求 有时候希望赋值运算符两边的类型可以不匹配,比如:把一个 int 类型变量赋值给一个Complex(复数)对象,或把一个 char 类型的字符串赋值给一个字符串对象,此时就需要重载赋值运算符‘=’。 需要注意的是:赋值运算符 只能重载为成员函数。 02 赋值运算符重载的例子 …


01 赋值运算符重载的需求

有时候希望赋值运算符两边的类型可以不匹配,比如:把一个 int 类型变量赋值给一个complex(复数)对象,或把一个 char* 类型的字符串赋值给一个字符串对象,此时就需要重载赋值运算符‘=’。

需要注意的是:赋值运算符 = 只能重载为成员函数。


02 赋值运算符重载的例子

下面我们以自定义一个自己的字符串类代码的例子,讲解赋值运算符的重载函数。

class mystring // 字符串类 { public:     // 构造函数,默认初始化1个字节的字符     mystring ():m_str(new char[1])     {         m_str[0] = 0;     }          // 析构函数,释放资源     ~mystring()     {         delete [] m_str;     }          const char* c_str()     {         return m_str;     }          // 赋值运算符重载函数     // 重载=号使得 obj = "hello" 能够成立     mystring & operator= (const char *s)     {         // 释放旧字符串资源         delete [] m_str;                  // 生成新字符串的空间大小,长度多+1的目的是存放         m_str = new char[strlen(s) +1 ];                  // 拷贝新字符串的内容         strcpy(m_str, s);                  // 返回该对象         return *this;     }      private:     char * m_str; // 字符串指针 };  int main() {          mystring s;          s = "hello~"; // 等价于s.operator=("hello~");     std::cout << s.c_str()  << std::endl;          // mystring s2 = "hello!"; // 这条语句要是不注释就会编译报错          s = "hi~"; // 等价于s.operator=("hi~");     std::cout << s.c_str()  << std::endl;      return 0; }

输出结果:

hello~ hi~

重载=号运算符函数后,s = "hello~"; 语句就等价于 s.operator=("hello~");

需要注意的一点是:上面的mystring s2 = "hello!";语句实际上是初始化语句,而不是赋值语句,因为是初始化语句,所以需要调用构造函数进行初始化,那么这时就需要有char*参数的构造函数,由于我们没有定义此构造函数,所以就会编译出错。


03 浅拷贝和深拷贝

还是依据上面的例子,假设我们要实现最后一个语句的方式:

mystring s1,s2; s1 = "this"; // 调用重载的赋值语句 s2 = "that"; // 调用重载的赋值语句 s1 = s2; // 如何实现这个??

s1 = s2;语句目的希望是s1对象放的字符串和s2对象放的字符串象要一样,由于 = 号两边的类似都是对象,编译器会用原生的赋值运算符函数,但是这个原生的赋值运算符函数对于有指针成员变量的对象来说,是非常危险的!

浅拷贝

如果用原生的赋值运算符函数去赋值有指针成员变量的对象,就会使得两个对象的指针地址也是一样的,也就是两个对象的指针成员变量指向的地址是同一个地方,这种方式就是浅拷贝。

这时当一个对象释放了指针成员变量时,那么另外一个对象的指针成员变量指向的地址就是空的了,再次使用这个对象时,程序就会奔溃了,因为该对象的指针成员函数已经是个不合法的指针了!

C++ 赋值运算符&#39;=&#39;的重载(浅拷贝、深拷贝)

深拷贝

如果对象里面有指针成员变量,则我们需要对原生的赋值运算符函数,防止出现程序出错现象的发生。

因此要在 class mystring 类里加上如下成员函数:

mystring & operator=(const mystring & s) {     // 释放旧字符串资源     delete [] m_str;          // 生成新字符串的空间大小,长度多+1的目的是存放     m_str = new char[strlen(s.m_str) +1 ];          // 拷贝新字符串的内容     strcpy(m_str, s.m_str);          // 返回该对象     return *this; }

这么做就够了吗?还有什么需要改进的地方吗?

我们在考虑下面的语句:

mystring s; s = "hello"; s = s; // 是否会有问题?

最后一个语句是否会有问题?

s = s;等价于s.operator=(s),由于s和s是相同的对象,那么就没必要完全执行重载的赋值 = 的函数了,我们再加个判断,当左右两边是相同对象时,就直接返回该对象就好:

mystring & operator=(const mystring & s) {     // 当左右两边是相同对象时,就直接返回该对象就     if(this == &s)         return *this;      delete [] m_str;     m_str = new char[strlen(s.m_str) +1 ];     strcpy(m_str, s.m_str);     return *this; }

对operator=返回值类型的讨论

  • void 好不好?
  • mystring 好不好?
  • 为什么是mystring &?

当我们重载一个运算符的时候,好的风格应该是尽量保留运算符原本的特性

考虑:

  • a = b = c; 这个赋值语句的顺序是先b = c,然后在a = (b = c)。如果返回的void类型,那么a = (void)显然是不成立的;
  • (a = b) = c; 这个赋值语句会修改a的值,如果返回的类型是mystring对象,那么就无法修改a的值了。

分别等价于:

  • a.operator=(b.operator=(c));
  • (a.operator=(b)).operator=(c);

所以综上考虑,operator=返回值类型是mystring &是比较好的。

04 复制(拷贝)构造函数

上面的mystring类是否就没有问题了?

mystring s; s = "hello"; mystring s1(s); // 要考虑这种情况,那就要重载复制(拷贝)构造函数

如果使用默认的复制(拷贝)构造函数,那就对有指针成员变量的对象会有问题,因为会默认的复制(拷贝)构造函数会导致两个对象的指针成员变量指向同一个的空间。

所以需要对复制(拷贝)构造函数重载,并实现深拷贝的方式:

mystring (const mystring &s) {     m_str = new char[strlen(s.m_str) + 1];     strcpy(m_str, s.m_str); }

05 小结

最后的所有代码,如下:

class mystring // 字符串类 { public:     // 构造函数,默认初始化1个字节的字符     mystring ():m_str(new char[1])     {         m_str[0] = 0;     }          // 复制(拷贝)构造函数     mystring (const mystring &s)     {         m_str = new char[strlen(s.m_str) + 1];         strcpy(m_str, s.m_str);     }          // 析构函数,释放资源     ~mystring()     {         delete [] m_str;     }          const char* c_str()     {         return m_str;     }          // 赋值运算符重载函数     // 重载=号使得 obj = "hello" 能够成立     mystring & operator= (const char *s)     {         // 释放旧字符串资源         delete [] m_str;                  // 生成新字符串的空间大小,长度多+1的目的是存放         m_str = new char[strlen(s) +1 ];                  // 拷贝新字符串的内容         strcpy(m_str, s);                  // 返回该对象         return *this;     }          // 赋值运算符重载函数     // 重载=号使得 obj1 = obj2 能够成立     mystring & operator=(const mystring & s)     {         // 当左右两边是相同对象时,就直接返回该对象就         if(this == &s)             return *this;              delete [] m_str;         m_str = new char[strlen(s.m_str) +1 ];         strcpy(m_str, s.m_str);         return *this;     }      private:     char * m_str; // 字符串指针 };  int main()  {          mystring s1,s2;          s1 = "hello~"; // 等价于s1.operator=("hello~");     std::cout << s1.c_str()  << std::endl;               s2 = "hi~"; // 等价于s2.operator=("hi~");     std::cout << s2.c_str()  << std::endl;          s1 = s2;   // 等价于s1.operator=(s2);     std::cout << s1.c_str()  << std::endl;          mystring s3(s1);  // 复制构造函数     std::cout << s3.c_str()  << std::endl;      return 0; }

输出如下:

hello~ hi~ hi~ hi~

本文来自网络收集,不代表计算机技术网立场,如涉及侵权请点击右边联系管理员删除。

如若转载,请注明出处:https://www.ctvol.com/c-cdevelopment/600790.html

(0)
上一篇 2021年5月9日
下一篇 2021年5月9日

精彩推荐