剖析深拷贝与浅拷贝,探究重载返回引用还是对象
导论
今天在研究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
将上述结果对比放在表格中:
(注:可以往右拖)
| construct | construct |
|---|---|
| construct | construct |
| construct | construct |
| = operator | = operator |
| copy construct | = operator |
| = operator | value = abc |
| copy construct | value = abc |
| deconstruct | value = abc |
| deconstruct | deconstruct |
| value = abc | deconstruct |
| value = 123 | deconstruct |
| value = 123 | |
| 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源码设计也是考虑了模仿内置类型的行为，后置的++需要返回增加之前的对象，不需要返回新对象,所以直接不返回对象的引用.
前置的++返回的是增加后的对象，这个对象是需要保留的，不是临时对象，返回引用就不需要拷贝对象，效率高.
相信大家对这句话认识更加深刻!
