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

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

导论

今天在研究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源码设计也是考虑了模仿内置类型的行为,后置的++需要返回增加之前的对象,不需要返回新对象,所以直接不返回对象的引用.

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

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

学习资料:

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

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

原文发布于微信公众号 - 光城(guangcity)

原文发表时间:2019-09-12

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券