主题
手写三种智能指针
cpp
#include<atomic>
#include<utility>
/////////////////////////////////////////
// unique_ptr
////////////////////////////////////////
template<typename T>
class unique_ptr
{
private:
T* ptr_;
public:
explicit unique_ptr(T* p = nullptr) noexcept : ptr_(p){}
~unique_ptr() noexcept
{
if(ptr_) delete ptr_;
}
// 移动构造/移动赋值/swap 必须标:vector 扩容走 move_if_noexcept,没标 noexcept 又有拷贝构造可用时,会退化成拷贝,白丢性能
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
unique_ptr(unique_ptr&& u) noexcept : ptr_(u.ptr_) {u.ptr_ = nullptr; }
unique_ptr& operator=(unique_ptr&& u) noexcept
{
if(this!=&u) reset(u.release());
return *this;
}
T* release() noexcept
{
T* p = ptr_;
ptr_ = nullptr;
return p;
}
void reset(T* p = nullptr) noexcept
{
T* old = ptr_;
ptr_ = p;
if(old) delete old; // 删的是换下来的旧指针,这个顺序反了就扛不住 p.reset(p.get())
}
T* get() const noexcept{ return ptr_; }
// 可以通过解引用拿到对象
T& operator*() const noexcept {return *ptr_; }
// 交出裸指针,剩下交给编译器
T* operator->() const noexcept {return ptr_; }
// 支持 if(p) / if(!p);explicit 是为了防止它被隐式转成整数参与运算
explicit operator bool() const noexcept { return ptr_ != nullptr; }
};
////////////////////////////////////////////////
// shared_ptr
///////////////////////////////////////////////
struct ControlBlock
{
std::atomic<int>use_count;
std::atomic<int>weak_count;
// weak_count 从 1 开始:这 1 是"强引用侧"的内嵌弱引用(libstdc++ 的做法),
// 保证对象先死、控制块后死;将来实现 weak_ptr 时它才派上用场
ControlBlock():use_count(1),weak_count(1){}
};
template<typename T> class weak_ptr; // 前置声明,下面 shared_ptr 要把它设成友元
template<typename T>
class shared_ptr
{
// weak_ptr 要读 cb_,还要用下面那个"接管"构造,所以必须开友元
friend class weak_ptr<T>;
private:
T* ptr_ = nullptr;
ControlBlock* cb_ = nullptr;
// 供 weak_ptr::lock 用:引用计数已经在 lock 里 CAS 加过了,这里只接管,不再加
shared_ptr(T* p, ControlBlock* cb) noexcept : ptr_(p),cb_(cb){}
public:
shared_ptr() noexcept = default;
// 这里必须 explicit:否则 shared_ptr<Foo> sp = new Foo; 会隐式发生所有权转移
explicit shared_ptr(T* p):ptr_(p),cb_(new ControlBlock()){}
~shared_ptr()
{
if(!cb_) return;
if(cb_->use_count.fetch_sub(1,std::memory_order_acq_rel)==1)
{
delete ptr_;
// 最后一个强引用消失,才归还内嵌的那一份弱引用
if(cb_->weak_count.fetch_sub(1,std::memory_order_acq_rel)==1)
{
delete cb_;
}
}
}
// 拷贝构造标 noexcept 是对的:引用计数只做原子加,不会抛
shared_ptr(const shared_ptr& o) noexcept : ptr_(o.ptr_),cb_(o.cb_)
{
if(cb_) cb_->use_count.fetch_add(1,std::memory_order_relaxed);
}
shared_ptr(shared_ptr&& o) noexcept : ptr_(o.ptr_),cb_(o.cb_)
{
o.ptr_ = nullptr;
o.cb_ = nullptr;
}
// 赋值运算符不能加 explicit(explicit 只能用在构造函数和转换函数上)
shared_ptr& operator=(const shared_ptr& o)
{
if(this!=&o)
{
shared_ptr tmp(o);
swap(tmp);
}
return *this;
}
shared_ptr& operator=(shared_ptr&& o)
{
if(this!=&o)
{
shared_ptr tmp(std::move(o));
swap(tmp);
}
return *this;
}
void swap(shared_ptr& o) noexcept
{
std::swap(ptr_,o.ptr_);
std::swap(cb_,o.cb_);
}
int use_count() const noexcept
{
return cb_?cb_->use_count.load(std::memory_order_relaxed):0;
}
T* get() const noexcept { return ptr_; }
T& operator*() const noexcept {return *ptr_;}
T* operator->() const noexcept {return ptr_;}
// 支持 if(p) / if(!p);explicit 是为了防止它被隐式转成整数参与运算
explicit operator bool() const noexcept { return ptr_ != nullptr; }
};
////////////////////////////////////////////
// weak_ptr
///////////////////////////////////////////
template<typename T>
class weak_ptr
{
private:
T* ptr_ = nullptr;
ControlBlock* cb_ = nullptr;
public:
weak_ptr() noexcept = default;
// 从 shared_ptr 构造,不是 explicit:weak_ptr 本来就是 shared_ptr 的弱引用
weak_ptr(const shared_ptr<T>& o) noexcept:ptr_(o.ptr_),cb_(o.cb_)
{
if(cb_) cb_->weak_count.fetch_add(1,std::memory_order_relaxed);
}
// 拷贝构造必须自己写!否则编译器隐式生成的版本只浅拷贝指针,不会加计数
weak_ptr(const weak_ptr& o) noexcept:ptr_(o.ptr_),cb_(o.cb_)
{
if(cb_) cb_->weak_count.fetch_add(1,std::memory_order_relaxed);
}
weak_ptr(weak_ptr&& o) noexcept:ptr_(o.ptr_),cb_(o.cb_)
{
o.ptr_ = nullptr;
o.cb_ = nullptr;
}
weak_ptr& operator=(const weak_ptr& o) noexcept
{
if(this!=&o)
{
weak_ptr tmp(o); // 先加后减,自赋值也安全
swap(tmp);
}
return *this;
}
weak_ptr& operator=(weak_ptr&& o) noexcept
{
if(this!=&o)
{
weak_ptr tmp(std::move(o));
swap(tmp);
}
return *this;
}
~weak_ptr()
{
// 关键:最后一个 weak_ptr 消失,才真正释放控制块。
// 少了这一步,只要 weak_ptr 比 shared_ptr 活得久,控制块就永久泄漏
if(cb_ && cb_->weak_count.fetch_sub(1,std::memory_order_acq_rel)==1)
{
delete cb_;
}
}
void swap(weak_ptr& o) noexcept
{
std::swap(ptr_,o.ptr_);
std::swap(cb_,o.cb_);
}
bool expired() const noexcept
{
return !cb_||cb_->use_count.load(std::memory_order_relaxed)==0;
}
shared_ptr<T> lock() const noexcept
{
if(!cb_) return shared_ptr<T>(); // 空的 weak_ptr,不能直接解引用 cb_
int n = cb_->use_count.load(std::memory_order_relaxed);
while(n>0)
{
// CAS 失败时 n 会被自动更新成当前值(含伪失败),所以这个循环是安全的
if(cb_->use_count.compare_exchange_weak(n,n+1,
std::memory_order_acq_rel,std::memory_order_relaxed))
{
// 计数已经加过了,用接管构造,不能再走普通构造多加一次
return shared_ptr<T>(ptr_,cb_);
}
}
return shared_ptr<T>();
}
};