shared_ptr拷贝赋值
在阅读shared_ptr源码时,看到拷贝赋值函数的实现是下面这样的,说实话当时看了这个实现是一脸懵逼,摸不着头脑
shared_ptr& operator=(const shared_ptr& _Right) noexcept {
shared_ptr(_Right).swap(*this);
return *this;
}
void swap(shared_ptr& _Other) noexcept {
this->_Swap(_Other);
}
void _Swap(_Ptr_base& _Right) noexcept { // swap pointers
_STD swap(_Ptr, _Right._Ptr);
_STD swap(_Rep, _Right._Rep);
}
因为如果让一个正常的地球人来写应该是这样的:
shared_ptr& operator=(const shared_ptr& _Right) noexcept {
if(this != &_Right){
this->_Decref();
_STD swap(_Ptr, _Right._Ptr);
_STD swap(_Rep, _Right._Rep);
this->_Incref()
}
return *this;
}
标准库的实现,至少有两个厉害的细节:
- 利用临时对象来自动更新引用计数,可以仔细分析一下:shared_ptr(_Right)构造了一个临时对象,_Right的引用计数+1,交换临时对象和this(称之为老对象),this指向_Right所指对象,并得到正确的引用计数,析构临时对象,引用计数-1,由于临时对象指向老的对象,相当于老的对象引用计数-1。
- 运用copy and swap技巧实现了简介且异常安全的拷贝赋值函数
copy and swap idiom
本文我们来重点说一下copy and swap,在C++中,copy and swap是一种用于实现拷贝赋值操作符的编程技巧。这个技巧的目标是通过利用拷贝构造函数和交换操作,实现一个安全、高效且自我赋值安全的赋值操作符。
这种方法的基本思想是,首先通过深拷贝源对象(operator = 右边的对象)创建一个临时对象,然后与当前对象进行交换。这样当前对象获得了源对象的资源,临时对象在销毁时会释放当前对象老的资源。
下面是"copy and swap"的一般模式:
- 拷贝构造函数(Copy Constructor): 定义一个拷贝构造函数,用于创建对象的深拷贝。
- 实现交换操作(Swap Operation): 定义一个交换操作,用于交换两个对象的内容。
- 赋值操作符(Assignment Operator): 利用拷贝构造函数和交换操作,实现赋值操作符。
copy and swap示例
下面是一个示例,假设我们有一个简单的类 MyString:
#include <cstring>
class MyString {
private:
char* data;
public:
// Constructor
MyString(const char* s = "") {
data = new char[strlen(s) + 1];
strcpy(data, s);
}
// Destructor
~MyString() {
delete[] data;
}
// Copy Constructor
MyString(const MyString& other) {
data = new char[strlen(other.data) + 1];
strcpy(data, other.data);
}
// Swap Operation
friend void swap(MyString& first, MyString& second) {
using std::swap;
swap(first.data, second.data);
}
// Assignment Operator using Copy and Swap
MyString& operator=(MyString other) {
swap(*this, other); // Swap with a copy of the other object
return *this;
}
};
在这个例子中,operator= 接受一个传值参数(即拷贝构造函数的参数),然后调用了 swap 函数,交换了当前对象和传入对象的内容。这样,传入对象的资源会转移到当前对象,当前对象原有的资源也能正确释放。使用 copy and swap 的方式相对于直接写拷贝赋值的方式有几个优势:
- 异常安全性: 使用copy and swap 可以更好地处理异常。如果发生异常,只可能在拷贝构造函数发生异常,(swap交换操作非常简单,姑且认为其为异常安全的),异常发生时,对象状态不会被破坏。因为首先创建了一个副本,只有在副本成功创建之后才会对当前对象进行交换,这种写法是异常安全的。
- 自我赋值安全性: copy and swap 自动提供了自我赋值的安全性。因为拷贝构造函数总是创建一个新的对象,而不管传递给它的是不是自身,然后再通过交换操作来更新当前对象。
- 简化代码逻辑: copy and swap 模式使赋值操作符的实现相对简单,因为它减少了手动管理资源的复杂性,拷贝构造函数和交换操作负责正确的资源分配和释放,而赋值操作符只需要调用它们。
总的来说,Copy and Swap 提供了更安全和简化的方式来实现赋值操作符,同时避免了一些潜在的错误和繁琐的手动资源管理。这种模式在实践中被广泛使用,特别是对于管理动态分配内存的类。
不使用Copy and Swap
在直接写拷贝赋值的方式中,存在异常问题的主要原因是分配动态内存。考虑一个类,其中有成员变量是指针,而拷贝赋值操作需要分配内存,如果分配失败,将抛出异常,如果在这个过程中抛出异常,可能会导致对象的数据处于损坏的状态。
以下是一个简化的示例,展示了直接写拷贝赋值可能遇到的异常问题:
#include <cstring>
class MyString {
private:
char* data;
public:
// Constructor
MyString(const char* s = "") {
data = new char[strlen(s) + 1];
strcpy(data, s);
}
// Destructor
~MyString() {
delete[] data;
}
// Direct Copy Assignment Operator
MyString& operator=(const MyString& other) {
if (this != &other) {
// Release current resource
delete[] data;
// Allocate new resource
data = new char[strlen(other.data) + 1];
// Copy data
strcpy(data, other.data);
}
return *this;
}
};
在上述代码中,如果在 new 操作中抛出了异常,对象的 data 数据已经被释放,对象遭到破坏,data 指针变成野指针,可能会导致意想不到的问题。而使用copy and swap 的方式通过利用拷贝构造函数的异常安全性来规避这个问题。如果拷贝构造函数中发生了异常,对象就不会被修改,因为当前对象的状态只在交换操作中发生变化,这使得整个赋值操作在异常发生时,对象状态仍然保持一致。