剖析深拷贝与浅拷贝,探究重载返回引用还是对象
今天在研究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)点,我们需要知道什么是深拷贝,什么是浅拷贝,分配内存是在堆上,还是在栈上!
这里先阐述一下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.而拷贝函数不需要如此,因为对象此时还没有分配堆空间。
假设不返回引用,如下面代码:
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 |
总结
那么什么情况下要返回对象的引用呢?
原因有两个:
最后,我们回到我们最前面解释:
对于STL源码设计也是考虑了模仿内置类型的行为,后置的++需要返回增加之前的对象,不需要返回新对象,所以直接不返回对象的引用.
前置的++返回的是增加后的对象,这个对象是需要保留的,不是临时对象,返回引用就不需要拷贝对象,效率高.
相信大家对这句话认识更加深刻!
学习资料:
https://www.cnblogs.com/winston/archive/2008/06/03/1212700.html
https://www.cnblogs.com/codingmengmeng/p/5871254.html