剖析深拷贝与浅拷贝,探究重载返回引用还是对象

• 2019 年 10 月 6 日
• 笔记

剖析深拷贝与浅拷贝,探究重载返回引用还是对象

导论

今天在研究STL源码中发现这么一段有意义的代码:

// 重载前置++操作符  ++i  _Self& operator++() _GLIBCXX_NOEXCEPT  {      _M_node = _M_node->_M_next;      return *this;  }    // 重载后置++操作符 i++  _Self operator++(int) _GLIBCXX_NOEXCEPT  {      _Self __tmp = *this;             // 记录原值  *调用的是拷贝构造函数      _M_node = _M_node->_M_next;      // 进行操作      return __tmp;                    // 返回原值  }

上述分别是前置++重载操作符与后置++操作符重载,可以有个疑惑,为何前置返回的是引用而后置返回的是对象呢?

这里先给出解释,后面一步步分析!

总结:不妨尝试一下,连续的前置++不会出问题,但是连续的后置++就报错了~

对于STL源码设计也是考虑了模仿内置类型的行为，后置的++需要返回增加之前的对象，不需要返回新对象,所以直接不返回对象的引用.

前置的++返回的是增加后的对象，这个对象是需要保留的，不是临时对象，返回引用就不需要拷贝对象，效率高.

上面这句话说的真的稀里糊涂的,第一次看到这句话,肯定一脸懵逼,实际上将上述话差分开就是解决两个问题:

(1) 深拷贝和浅拷贝?

(2) c++中有些重载运算符为什么要返回引用?

为了理解第(2)点,我们需要知道什么是深拷贝,什么是浅拷贝,分配内存是在堆上,还是在栈上!

1.深拷贝和浅拷贝

这里先阐述一下C++对象中的两个概念,分别是拷贝操作与赋值操作!

• 拷贝操作

如果对象在申明的同时马上进行的初始化操作，则称之为拷贝运算

String A("hello");  String B=A;

此时其实际调用的是B(A)这样的浅拷贝操作。调用的是String类的拷贝构造函数!

• 赋值操作

如果对象在申明之后，在进行的赋值运算，我们称之为赋值运算

String A("hello");  String B;  B=A;

此时实际调用的类的缺省赋值函数B.operator=(A),调用的是=操作符重载函数.

不管是浅拷贝还是赋值运算，其都有缺省的定义。也就是说，即使我们不overload这两种operation,仍然可以运行。那么，我们到底需不需要overload这两种operation 呢？答案就是：一般，我们我们需要手动编写析构函数的类，都需要overload 拷贝函数和赋值运算符。

现在有如下例子:

using namespace std;  class String  {  private:      char *str;      int len;  public:      String(const char* s);//构造函数声明      void show()      {          cout << "value = " << str << endl;      }        /*copy construct*/      String(const String& other)      {          len = other.len;          str = new char[len + 1];          strcpy(str, other.str);          cout << "copy construct" << endl;      }  };    String::String(const char* s)//构造函数定义  {      len = strlen(s);      str = new char[len + 1];      strcpy(str, s);      cout<<"construct"<<endl;  }

调用:

String str1("abc");  String str2("123");  str1.show();  str2.show();

如果在上述调用后面加一句:

str2=str1

此时的内存分配如下图所示:

因此，对于缺省的赋值运算，如果对象域内没有heap上的空间，其不会产生任何问题。但是，如果对象域内需要申请heap上的空间，那么在析构对象的时候，就会连续两次释放heap上的同一块内存区域，从而导致异常。

因此，对于对象的域在heap上分配内存的情况，我们必须重载赋值运算符。当对象间进行拷贝的时候，我们必须让不同对象的成员域指向其不同的heap地址–如果成员域属于heap的话。

其余代码一致,在上述加上运算符=重载函数:

String& String::operator=(const String &other)//运算符重载  {      cout<<"= operator"<<endl;      if (this == &other)          return *this;  //        return;      delete[] str;      len = other.len;      str = new char[len + 1];      strcpy(str, other.str);      return *this;  //    return;  }

此时内存分配示意图如下:

这样，在对象str1,str2退出相应的作用域，其调用相应的析构函数，然后释放分别属于不同heap空间的内存，程序正常结束。

上述的运算符重载就是深拷贝!我们也可以这样重载赋值运算符 void operator=(A &a);即不返回任何值。如果这样的话，他将不支持客户链式赋值 ，例如a=b=c will be prohibited!

上述另一个写法:

void String::operator=(const String &other)//运算符重载  {      cout << "= operator" << endl;      if (str!=NULL)          delete[] str;      len = other.len;      str = new char[len + 1];      strcpy(str, other.str);  //    return;  }

后面调用如果是str3=str2=str1,就会出现下面错误:

error: no match for ‘operator=’ (operand types are ‘String’ and ‘void’) str3 = str2 = str1;//str3.operator=(str1.operator=(str2))

从上可以看出，赋值运算符和拷贝函数很相似。只不过赋值函数最好有返回值（进行链式赋值），返回也最好是对象的引用， 而拷贝函数不需要返回任何。同时，赋值函数首先要释放掉对象自身的堆空间（如果需要的话），然后进行其他的operation.而拷贝函数不需要如此，因为对象此时还没有分配堆空间。

2.C++中有些重载运算符为什么要返回引用?

假设不返回引用,如下面代码:

class String  {  private:      char *str;      int len;  public:      String(const char* s);//构造函数声明      String operator=(const String& another);//运算符重载，此时返回的是对象      void show()      {          cout << "value = " << str << endl;      }        /*copy construct*/      String(const String& other)      {      }        ~String()      {          delete[] str;          cout << "deconstruct" << endl;      }  };    String::String(const char* s)//构造函数定义  {      len = strlen(s);      str = new char[len + 1];      strcpy(str, s);      cout<<"construct"<<endl;  }    String String::operator=(const String &other)//运算符重载  {      cout<<"= operator"<<endl;      if (this == &other)          return *this;  //        return;      delete[] str;      len = other.len;      str = new char[len + 1];      strcpy(str, other.str);      return *this;  //    return;  }  int main()  {      String str1("abc");      String str2("123");      str2=str1;      str1.show();      str2.show();      return 0;  }

此时运行报错:

free(): invalid size

上述出错是因为,操作符=重载返回的不是引用,对于上述的操作符重载返回的是对象,此时对象是临时对象,并且会多调用一次拷贝构造与析构函数,当调用拷贝构造函数的时候,并没有在堆上分配内存,而此时free调的其实就是临时对象,而在后面str1与str2任务完成后,str1会因为前面释放临时对象被free掉了,所以此时进入str1的析构函数,会出现错误!解决这种问题将返回改为引用即可.

对比一下返回对象与返回引用:

第一种:返回对象

String String::operator=(const String &other)//运算符重载  {      cout<<"= operator"<<endl;      if (this == &other)          return *this;  //        return;      delete[] str;      len = other.len;      str = new char[len + 1];      strcpy(str, other.str);      return *this;  //    return;  }

调用:

String str1("abc");  String str2("123");  String str3("456");    (str3 = str2) = str1;  str1.show();  str2.show();  str3.show();

输出:

construct  construct  construct  = operator  copy construct  = operator  copy construct  deconstruct  deconstruct  value = abc  value = 123  value = 123  deconstruct  deconstruct  deconstruct

第二:返回引用:

construct  construct  construct  = operator  = operator  value = abc  value = abc  value = abc  deconstruct  deconstruct  deconstruct

将上述结果对比放在表格中:

(注:可以往右拖)

• 区别1:会发现使用引用返回后少了四行,原因返回的如果是对象,这个对象是临时对象,返回后会调用一次拷贝构造函数,结束后会调用析构函数,上面使用了两次=,所以第一种情况会多四行.
• 区别2:结果不同,我们期待的结果是将str1也拷贝进str3,可是第一种情况并没有实现这种效果,str3只得到了str2的内容，并没有得到str1的内容，这是因为执行(str3=str2)后，因为返回的是对象（一个临时对象，str3的一个拷贝），不是引用，所以此时str3不在后面的=str1的操作中，而是str1对一个临时对象赋值，所以str3的内容保持不变（等于str2）。

总结

那么什么情况下要返回对象的引用呢？

原因有两个：

• 允许进行连续赋值
• 防止返回对象（返回对象也可以进行连续赋值（常规的情况，如a = b = c，而不是（a = b） = c））的时候调用拷贝构造函数和析构函数导致不必要的开销，降低赋值运算符的效率。

最后,我们回到我们最前面解释:

对于STL源码设计也是考虑了模仿内置类型的行为，后置的++需要返回增加之前的对象，不需要返回新对象,所以直接不返回对象的引用.

前置的++返回的是增加后的对象，这个对象是需要保留的，不是临时对象，返回引用就不需要拷贝对象，效率高.

相信大家对这句话认识更加深刻!

学习资料:

https://www.cnblogs.com/winston/archive/2008/06/03/1212700.html

https://www.cnblogs.com/codingmengmeng/p/5871254.html