深入理解C++赋值构造函数的实现原理

一、赋值构造函数是什么

在C++中，如果我们定义一个类，它里面包含有指针成员变量时，需要特别注意这个指针的生命周期和对象的生命周期，确保在对象被销毁前，指针指向的内存已经被释放，否则可能会发生内存泄漏等问题。而赋值构造函数就是用来实现对象的深度复制，解决因为指针成员变量导致的这类问题。

class Test{
public:
    Test():data(nullptr), len(0) {}
    ~Test(){
        if(data != nullptr)
            delete[] data;
    }
    Test(const Test& t){
        if(t.data != nullptr){
            this->data = new int[t.len];
            memcpy(this->data, t.data, sizeof(int)*t.len);
            this->len = t.len;
        }
    }
    Test& operator=(const Test& t){
        if(this == &t) return *this;
        if(this->data != nullptr) delete[] data;
        if(t.data != nullptr){
            this->data = new int[t.len];
            memcpy(this->data, t.data, sizeof(int)*t.len);
            this->len = t.len;
        }
        return *this;
    }
private:
    int* data;
    int len;
};

二、浅拷贝和深拷贝的区别

在实现赋值构造函数之前，我们需要先了解一下浅拷贝和深拷贝的概念。

所谓浅拷贝，是将对象的所有成员变量的值都复制给新对象，包括指针成员变量的地址值，也就是说，新对象和原对象共享指针指向的内存。这样，当其中一个对象释放指针指向的内存时，另一个对象的指针也就变成了野指针，这很容易导致内存管理的问题。

而深拷贝则是将指针指向的内存也进行复制，这样新对象和原对象互不影响，互相独立，即便其中一个对象释放了指针指向的内存，也不会影响另一个对象。

三、实现赋值构造函数

在实现赋值构造函数前，我们需要重载赋值运算符。下面是一个示例代码：

Test& operator=(const Test& t){
    if(this == &t) return *this;
    if(this->data != nullptr) delete[] data;
    if(t.data != nullptr){
        this->data = new int[t.len];
        memcpy(this->data, t.data, sizeof(int)*t.len);
        this->len = t.len;
    }
    return *this;
}

需要注意的是，在重载赋值运算符中，需要进行自我赋值的判断。如果不进行判断的话，当对象自己赋值给自己时，就会导致指针指向的内存多次删除，这会导致程序崩溃。因此，我们需要在赋值前判断是否是自我赋值，如果是，则直接返回对象自身。

然后便可以进行赋值操作了。首先，需要删除原先数据指针指向的内存。然后，需要重新分配内存，并将原始数据拷贝到新分配的内存区域中。最后，返回当前对象的引用。

if(this->data != nullptr) delete[] data;
if(t.data != nullptr){
    this->data = new int[t.len];
    memcpy(this->data, t.data, sizeof(int)*t.len);
    this->len = t.len;
}
return *this;

四、测试赋值构造函数的实现原理

下面是一个用于测试的代码，首先我们定义了一个类Test, 其中包含有一个指针类型成员变量data，用于存储int类型的数组，另一个成员变量len表示数组的长度。然后分别使用构造函数和赋值构造函数进行初始化，并可以通过输出打印数组的值，来验证赋值构造函数的实现原理。

#include <iostream>

using namespace std;

class Test{
public:
    Test():data(nullptr), len(0) {}
    ~Test(){
        if(data != nullptr)
            delete[] data;
    }
    Test(const Test& t){
        if(t.data != nullptr){
            this->data = new int[t.len];
            memcpy(this->data, t.data, sizeof(int)*t.len);
            this->len = t.len;
        }
    }
    Test& operator=(const Test& t){
        if(this == &t) return *this;
        if(this->data != nullptr) delete[] data;
        if(t.data != nullptr){
            this->data = new int[t.len];
            memcpy(this->data, t.data, sizeof(int)*t.len);
            this->len = t.len;
        }
        return *this;
    }
    
    void printData(){
        cout << "==========" << endl;
        for(int i = 0; i < len; ++i){
            cout << data[i] << " ";
        }
        cout << endl << "==========" << endl;
    }

private:
    int* data;
    int len;
};

int main(){
    Test t1;
    t1.len = 3;
    t1.data = new int[t1.len];
    t1.data[0] = 1;
    t1.data[1] = 2;
    t1.data[2] = 3;
    t1.printData();

    Test t2 = t1;
    t2.printData();

    Test t3;
    t3 = t1;
    t3.printData();
    
    return 0;
}

运行结果如下：

========== 
1 2 3 
========== 
========== 
1 2 3 
========== 
========== 
1 2 3 
========== 

我们可以看到，三个Test对象的值均相等，通过输出来证明赋值构造函数的实现原理是正确的。

五、总结

赋值构造函数是用于处理类中存在指针成员变量时进行赋值的构造函数，保证对象间的独立性，以及在释放指针指向的内存时的正确性。需要注意的是，在实现赋值构造函数时，需要判断是否自我赋值。并且，为了保证赋值操作的有效性，需要将原先的指针指向的内存进行删除，并重新分配内存，并将原先的数据拷贝到新分配的内存区域中。