由于 auto_ptr 与 scoped_ptr 都有一些弊端,所以 shared_ptr 出现了。它采用了引用计数的方式来处理拷贝构造与赋值运算。
template <typename T>
class SharedPtr {
public:
SharedPtr(T* ptr)
:_ptr(ptr) {
_count = new size_t(0);
++*_count;
}
SharedPtr(SharedPtr& s) {
_ptr = s._ptr;
_count = s._count;
++*_count;
}
SharedPtr& operator=(const SharedPtr& s) {
if (this == &s)
return;
if (_ptr != NULL) {
if (--*_count) {
delete _count;
delete _ptr;
_count = nullptr;
_ptr = nullptr;
}
}
_ptr = s._ptr;
_count = s._count;
++*_count;
}
T* operator->() {
return _ptr;
}
T& operator*() {
return *_ptr;
}
~SharedPtr() {
if (_ptr == nullptr)
return;
if (!--*count) {
delete _count;
delete _ptr;
_count = nullptr;
_ptr = nullptr;
}
}
private:
T* _ptr;
size_t* _count;
};
template <typename T>
class SharedArray {
public:
SharedArray(T* ptr)
:_ptr(ptr) {
_count = new size(0);
++*_count;
}
SharedArray(const SharedArray& s) {
_ptr = s._ptr;
_count = s._count;
++*_count;
}
SharedArray& operator=(const SharedArray& s) {
if (this == &s)
return;
if (_ptr != nullptr) {
if (!--*_count) {
delete _ptr;
delete _count;
_ptr = nullptr;
_count = nullptr;
}
}
_ptr = s._ptr;
_count = s._count;
++*_count;
}
T* operator->() {
return _ptr;
}
T& operator*() {
return *_ptr;
}
T& operator[](size_t pos) {
return _ptr[pos];
}
~SharedArray() {
if (_ptr == nullptr)
return;
if (!--*_count) {
delete _ptr;
delete _count;
_ptr == nullptr;
_count = nullptr;
}
}
private:
T* _ptr;
size_t* _count;
};
这里要提一下,由于 shared_ptr 采用引用计数来处理的赋值运算。在某些情况下会出现一些问题。比如:
struct ListNode {
ListNode() = default;
shared_ptr<ListNode> _prev;
shared_ptr<ListNode> _next;
// weak_ptr<ListNode> _prev;
// weak_ptr<ListNode> _next;
~ListNode() = default;
};
void fun() {
shared_ptr<ListNode> p1(new ListNode());
shared_ptr<ListNode> p2(new ListNode());
p1->_next = p2;
p2->_prev = p1;
}
这种情况下,就出现了 shared_ptr 的重大问题~~循环引用问题。导致了 shared_ptr 所指向的空间无法被销毁, 那么这个时候就要引入 weak_ptr 来处理这个问题。
weak_ptr 的实质就是只指向,而不增加引用计数。
欢迎大家共同讨论,如有错误及时联系作者指出,并改正。谢谢大家!