C++面向对象编程中的深拷贝和浅拷贝

前言

最近在写代码的过程中，发现一个大家容易忽略的知识点： 深拷贝和浅拷贝 。

可能对于Java程序员来说，很少遇到深浅拷贝问题，但是对于C++程序员来说可谓是又爱又恨。。

浅拷贝：

• 1.将原对象或者原对象的引用直接赋值给新对象，新对象，新数组只是原对象的一个引用。

• 2.C++默认的拷贝构造函数与赋值运算符重载都是浅拷贝，可以节省一定空间，但是可能会引发同一块内存重复释放问题，

  二次释放内存可能导致严重的异常崩溃等情况。

• 浅拷贝模型：

  

深拷贝：

• 1.创建一个新的对象或者数组，将对象或者数组的属性值拷贝过来，注意此时新对象指向的不是原对象的引用而是原对象的值，新对象在堆中有自己的地址空间。

• 2.浪费空间，但是不会引发浅拷贝中的资源重复释放问题。

• 深拷贝模型

  

案例分析

下面使用一个案例来看下一个因为浅拷贝带来的bug。

#include "DeepCopy.h"
#include 
#include 
using namespace std;
class Human {
public:
    Human(int age):_age(age) {


    }
    int _age;;

};
class String {
public:
    String(Human* pHuman){
        this->pHuman = pHuman;
    }
    ~String() {
        delete pHuman;
    }
    Human* pHuman;
};

void DeepCopy::main() 
{    
    Human* p = new Human(100);
    String s1(p);
    String s2(s1);

}

这个程序从表面看是不会有啥问题的，运行后，出现如下错误：

先说下原因 ：

这个错误就是由于代码 String s2(s1) 会调用String的默认拷贝构造函数，而 默认的拷贝构造函数使用的是浅拷贝，即仅仅只是对新的指针对象pHuman指向原指针对象pHuman指向的地址 。

在退出main函数作用域后，会回调s1和s2的析构函数，当回调s2析构函数后，s2中的pHuman内存资源被释放，此时再回调s1，也会回调s1中的pHuman析构函数，可是此时的pHuman指向的地址

已经在s2中被释放了，造成了二次释放内存，出现了崩溃的情况 。

所以为了防止出现二次释放内存的情况，需要使用深拷贝 。

深拷贝需要重写拷贝构造函数以及赋值运算符重载，且在拷贝构造内部重新去new一个对象资源.

代码如下：

#include "DeepCopy.h"
#include 
#include 
using namespace std;
class Human {
public:
    Human(int age):_age(age) {

}

int _age;;

};
class String {
public:
    String(Human* pHuman){
        this->pHuman = pHuman;
    }
    //重写拷贝构造，实现深拷贝，防止二次释放内存引发崩溃
    String(const String& str) {
        pHuman = new Human(str.pHuman->_age);
    }
    ~String() {
        delete pHuman;
    }
    Human* pHuman;
};

void DeepCopy::main() 
{    
    Human* p = new Human(100);
    String s1(p);
    String s2(s1);

}

默认情况下使用：

String s2(s1)或者String s2 = s1 这两种方式去赋值，就会调用String的拷贝构造方法，如果没有实现，则会执行默认的拷贝构造，即浅拷贝。

可以在拷贝构造函数中使用new重新对指针进行资源分配，达到深拷贝的要求、

说了这么多只要记住一点： 如果类中有成员变量是指针的情况下，就需要自己去实现深拷贝 。

虽然深拷贝可以帮助我们防止出现二次内存是否的问题，但是其会浪费一定空间，如果对象中资源较大，拿每个对象都包含一个大对象，这不是一个很好的设计，而浅拷贝就没这个问题。

那么有什么方法可以兼容他们的优点么？ 即不浪费空间也不会引起二次内存释放 ？

兼容优化方案：

• 1.引用计数方式
• 2.使用move语义转移

引用计数

我们对资源增加一个引用计数，在构造函数以及拷贝构造函数中让计数+1，在析构中让计数-1.当计数为0时，才会去释放资源，这是一个不错的注意。

如图所示：

对应代码如下：

#include "DeepCopy.h"
#include 
#include 
using namespace std;
class Human {
public:
    Human(int age):_age(age) {

    }
    int _age;;
};
class String {
public:
    String() {
        addRefCount();
    }
    String(Human* pHuman){
        this->pHuman = pHuman;
        addRefCount();
    }
    //重写拷贝构造，实现深拷贝，防止二次释放内存引发崩溃
    String(const String& str) {
        ////深拷贝
        //pHuman = new Human(str.pHuman->_age);
        //浅拷贝
        pHuman = str.pHuman;
        addRefCount();
    }
    ~String() {
        subRefCount();
        if (getRefCount() <= 0) {
            delete pHuman;
        }   
    }
    Human* pHuman;
private:
    void addRefCount() {
        refCount++;
    }
    void subRefCount() {
        refCount--;
    }
    int getRefCount() {
        return refCount;
    }
    static int refCount;
};
int String::refCount = 0;
void DeepCopy::main() 
{    
    Human* p = new Human(100);
    String s1(p);
    String s2 = s1;

}

此时的拷贝构造函数使用了浅拷贝对成员对象进行赋值，且 只有在引用计数为0的情况下才会进行资源释放 。

但是引用计数的方式会出现循环引用的情况，导致内存无法释放，发生 内存泄露 。

循环引用模型如下：

我们知道在C++的 智能指针shared_ptr中就使用了引用计数 ：

类似java中对象垃圾的定位方法，如果有一个指针引用某块内存，则引用计数+1，释放计数-1.如果引用计数为0，则说明这块内存可以释放了。

下面我们写个shared_ptr循环引用的情况：

class A {
  public:
    shared_ptr pa;

**
~A() {

cout << "~A" << endl;

}

};
class B {
public:
    shared_ptr pb;

~B() {
cout << "~B" << endl;
}

};
void sharedPtr() {
    shared_ptr a(new A());
    shared_ptr b(new B());
    cout << "第一次引用:" << endl;
    cout <<"计数a:" << a.use_count() << endl;
    cout << "计数b:" << b.use_count() << endl;
    a->pa = b;
    b->pb = a;
    cout << "第二次引用:" << endl;
    cout << "计数a:" << a.use_count() << endl;
    cout << "计数b:" << b.use_count() << endl;
}
运行结果：
第一次引用:
计数a:1
计数b:1
第二次引用:
计数a:2
计数b:2

[**
可以看到运行结果并没有打印出对应的析构函数，也就是没被释放。

指针a和指针b是栈上的，当退出他们的作用域后，引用计数会-1，但是其计数器数是2，所以还不为0，也就是不能被释放。你不释放我，我也不释放你，咱两耗着呗。

这就是标志性的由于循环引用计数导致的内存泄露.。所以 我们在设计深浅拷贝代码的时候千万别写出循环引用的情况 。

move语义转移

在C++11之前，如果要将源对象的状态转移到目标对象只能通过复制。

而现在在某些情况下，我们没有必要复制对象，只需要移动它们。

C++11引入移动语义 ：

源对象资源的控制权全部交给目标对象。注意这里说的是控制权，即使用一个新的指针对象去指向这个对象，然后将原对象的指针置为nullptr

模型如下：

要实现move语义，需要实现移动构造函数

代码如下：

//移动语义move
class Human {
public:
    Human(int age) :_age(age) {

}

int _age;;

};
class String {
public:

String(Human* pHuman) {

this->pHuman = pHuman;

}

//重写拷贝构造，实现深拷贝，防止二次释放内存引发崩溃

String(const String& str) {

////深拷贝

//pHuman = new Human(str.pHuman->_age);

//浅拷贝

pHuman = str.pHuman;

}

//移动构造函数

String(String&& str) {

pHuman = str.pHuman;

str.pHuman = NULL;

}

~String() {

if (pHuman != NULL) {

delete pHuman;

}

}

Human* pHuman;

};
void DeepCopy::main()
{
    Human* p = new Human(100);
    String s1(p);

String s2(std::move(s1));

String s3(std::move(s2));

}

该案例中， 指针p的权限会由s1让渡给s2，s2再让渡给s3 .

使用move语义转移在C++中使用还是比较频繁的，因为其可以大大缩小因为对象对象的创建导致内存吃紧的情况。比较推荐应用中使用这种方式来优化内存方面问题.

总结

本篇文章主要讲解了C++面向对象编程中的深拷贝和浅拷贝的问题，以及使用引用计数和move语义转移的方式来优化深浅拷贝的问题。

C++不像Java那样，JVM都给我们处理好了资源释放的问题，没有二次释放导致的崩溃情况， C++要懂的东西远非Java可比，这也是为什么C++程序员那么少的原因之一吧 。

]()