拷贝赋值运算符重载，简单来说，就是让你能用
=给一个已经存在的C++对象赋值。它和拷贝构造函数不太一样，拷贝构造函数是用来创建一个新的对象，而拷贝赋值是修改一个已有的对象。
拷贝赋值运算符重载
想要搞定拷贝赋值运算符重载，主要得注意这几点：自赋值的处理、释放旧资源、分配新资源、以及返回对象的引用。
为什么要重载拷贝赋值运算符？
默认情况下，C++会提供一个拷贝赋值运算符，它会简单地将源对象的所有成员变量复制到目标对象。但如果你的类里有动态分配的内存，比如用
new分配的，那默认的拷贝赋值运算符就只会复制指针，而不会复制指针指向的内容，这就是浅拷贝。浅拷贝会导致多个对象指向同一块内存，当其中一个对象释放了这块内存，其他的对象就变成了悬挂指针，访问就会出错。所以，当你的类里有动态分配的内存或者其他需要特殊处理的资源时，就需要重载拷贝赋值运算符，实现深拷贝，确保每个对象都有自己独立的资源。
立即学习“C++免费学习笔记（深入）”；
如何编写一个安全的拷贝赋值运算符？
一个安全的拷贝赋值运算符需要考虑以下几个方面：
自赋值检查：首先要检查是不是自己给自己赋值，如果是，直接返回
*this
，避免不必要的资源释放和分配。释放旧资源：在赋值之前，先释放目标对象已经拥有的资源，防止内存泄漏。
分配新资源并复制数据：分配足够的内存，然后将源对象的数据复制到目标对象。
异常安全：确保在分配资源或复制数据时发生异常，对象的状态仍然是有效的，不会出现资源泄漏或数据损坏。一种常见的做法是先创建一个临时对象，将源对象的数据复制到临时对象，然后再将临时对象的数据交换到目标对象。
返回对象的引用：返回
*this
的引用，这样可以支持链式赋值，比如a = b = c;
。
下面是一个示例代码：
#include <iostream>
#include <cstring>
class MyString {
private:
char* data;
size_t length;
public:
// 构造函数
MyString(const char* str = nullptr) : data(nullptr), length(0) {
if (str) {
length = std::strlen(str);
data = new char[length + 1];
std::strcpy(data, str);
}
}
// 拷贝构造函数
MyString(const MyString& other) : data(nullptr), length(0) {
length = other.length;
data = new char[length + 1];
std::strcpy(data, other.data);
}
// 拷贝赋值运算符
MyString& operator=(const MyString& other) {
// 自赋值检查
if (this == &other) {
return *this;
}
// 释放旧资源
delete[] data;
data = nullptr; // 重要：避免悬挂指针
// 分配新资源并复制数据
length = other.length;
data = new char[length + 1];
std::strcpy(data, other.data);
// 返回对象的引用
return *this;
}
// 析构函数
~MyString() {
delete[] data;
}
// 打印字符串
void print() const {
if (data) {
std::cout << data << std::endl;
} else {
std::cout << "(null)" << std::endl;
}
}
};
int main() {
MyString str1("Hello");
MyString str2("World");
str2 = str1; // 使用拷贝赋值运算符
str1.print(); // 输出 "Hello"
str2.print(); // 输出 "Hello"
return 0;
}拷贝赋值运算符和移动赋值运算符有什么区别？
拷贝赋值运算符和移动赋值运算符都是用来给对象赋值的，但它们的应用场景和实现方式有所不同。拷贝赋值运算符用于源对象仍然需要保持有效的情况，它会复制源对象的数据到目标对象。而移动赋值运算符用于源对象不再需要保持有效的情况，它会将源对象的资源“移动”到目标对象，避免了不必要的复制，提高了效率。移动赋值运算符通常用于处理临时对象或者即将销毁的对象。移动赋值运算符的参数是一个右值引用，用
&&表示。
如何处理拷贝赋值运算符中的异常？
在拷贝赋值运算符中，如果分配内存失败或者复制数据时发生异常，可能会导致资源泄漏或者数据损坏。为了保证异常安全，可以使用以下几种方法：
先分配再释放：先分配新的资源，然后再释放旧的资源。如果在分配新资源时发生异常，旧的资源仍然是有效的。
使用
std::unique_ptr
或std::shared_ptr
：这些智能指针可以自动管理资源，即使发生异常，也能保证资源被正确释放。Copy-and-Swap：创建一个临时对象，将源对象的数据复制到临时对象，然后将临时对象的数据和目标对象的数据进行交换。这种方法可以保证即使在复制数据时发生异常，目标对象的状态仍然是有效的。
下面是一个使用Copy-and-Swap的示例代码：
#include <iostream>
#include <cstring>
#include <algorithm>
class MyString {
private:
char* data;
size_t length;
public:
// 构造函数
MyString(const char* str = nullptr) : data(nullptr), length(0) {
if (str) {
length = std::strlen(str);
data = new char[length + 1];
std::strcpy(data, str);
}
}
// 拷贝构造函数
MyString(const MyString& other) : data(nullptr), length(0) {
length = other.length;
data = new char[length + 1];
std::strcpy(data, other.data);
}
// 移动构造函数
MyString(MyString&& other) noexcept : data(other.data), length(other.length) {
other.data = nullptr;
other.length = 0;
}
// 拷贝赋值运算符
MyString& operator=(const MyString& other) {
MyString temp(other); // 创建临时对象
std::swap(data, temp.data); // 交换数据
std::swap(length, temp.length);
return *this;
}
// 移动赋值运算符
MyString& operator=(MyString&& other) noexcept {
if (this != &other) {
delete[] data;
data = other.data;
length = other.length;
other.data = nullptr;
other.length = 0;
}
return *this;
}
// 析构函数
~MyString() {
delete[] data;
}
// 打印字符串
void print() const {
if (data) {
std::cout << data << std::endl;
} else {
std::cout << "(null)" << std::endl;
}
}
};
int main() {
MyString str1("Hello");
MyString str2("World");
str2 = str1; // 使用拷贝赋值运算符
str1.print(); // 输出 "Hello"
str2.print(); // 输出 "Hello"
MyString str3("Move");
str3 = std::move(str1); // 使用移动赋值运算符
str3.print(); // 输出 "Hello"
str1.print(); // 输出 "(null)"
return 0;
} 
