虽然对于生产解决方案来说这将是一个糟糕的想法,但如果你不尝试像 boost 那样成为交叉编译器、灵活和线程安全的类,那么为一个类推出你自己的解决方案并不会太难:
template <typename contained>
class my_shared_ptr {
public:
my_shared_ptr() : ptr_(NULL), ref_count_(NULL) { }
my_shared_ptr(contained * p)
: ptr_(p), ref_count_(p ? new int : NULL)
{ inc_ref(); }
my_shared_ptr(const my_shared_ptr& rhs)
: ptr_(rhs.p), ref_count_(rhs.ref_count_)
{ inc_ref(); }
~my_shared_ptr() {
if(ref_count_ && 0 == dec_ref()) { delete ptr_; delete ref_count_; }
}
contained * get() { return ptr_; }
const contained * get() const { return ptr_; }
void swap(my_shared_ptr& rhs) // throw()
{
std::swap(p, rhs.p);
std::swap(ref_count_, rhs.ref_count_);
}
my_shared_ptr& operator=(const my_shared_ptr& rhs) {
my_shared_ptr tmp(rhs);
this->swap(tmp);
return *this;
}
// operator->, operator*, operator void*, use_count
private:
void inc_ref() {
if(ref_count_) { ++(*ref_count_); }
}
int dec_ref() {
return --(*ref_count_);
}
contained * ptr_;
int * ref_count_;
};