C++98到C++11：智能指针分为auto_ptr, unique_ptr, shared_ptr，weak_ptr,这几种智能都是为了解决指针拷贝构造和赋值的问题
auto_ptr：允许拷贝，但只保留一个指向空间的指针。
管理权转移，把拷贝对象的资源管理权转移给拷贝对象，导致被拷贝对象悬空，不能访问出问题 ap1置空
auto_ptr<Test> ap1(new Test());
auto_ptr<Test> ap3 = ap1;
// ap1=nullptr如果不置空就会导致对象调用析构函数时，空间会被释放两次。但会导致ap1无法再使用。
模拟auto_ptr
template<class T>
class AutoPtr
{
public:
AutoPtr(T* ptr)
:_ptr(ptr)
{}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
~AutoPtr()
{
cout << "delete pointer" << _ptr << endl;
delete _ptr;
}
AutoPtr(AutoPtr<T>& ap)
:_ptr(ap._ptr)
{
ap._ptr = nullptr;
}
private:
T* _ptr;
};unique_ptr: 禁止拷贝
unique_ptr<A> up1(new A());
unique_ptr<A> up3=up1// 报错模拟实现unique_ptr
template<class T>
class UniquePtr
{
public:
UniquePtr(T* ptr)
:_ptr(ptr)
{}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
~UniquePtr()
{
cout << "delete pointer" << _ptr << endl;
delete _ptr;
}
UniquePtr(const UniquePtr<T>& up) = delete; // 禁止拷贝构造
UniquePtr<T>& operator=(const UniquePtr<T>& up) = delete; //禁止默认生成赋值重载函数
private:
T* _ptr;
};shared_ptr：支持拷贝，无法解决循环引用
shared_ptr通过引用计数来防止被多次析构
引用计数
用一个变量来记录指向空间的指针数，当一个智能指针释放时，变量数值减一，当数值为0时才释放空间。
模拟share_ptr的实现
template<class T>
class SharedPtr
{
public:
SharedPtr(T* ptr)
:_ptr(ptr)
,_pcount(new int(1))
{}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
~SharedPtr()
{
if (--(*_pcount) == 0)
{
cout << "delete pointer" << _ptr << endl;
delete _ptr;
delete _pcount;
}
}
private:
T* _ptr;
int* _pcount;
};shared_ptr的拷贝构造
SharedPtr(const SharedPtr<T>& sp)
:_ptr(sp._ptr)
,_pcount(sp._pcount)
{
(*_pcount)++;
}
shared_ptr的赋值重载
SharedPtr<T>& operator=(const SharedPtr<T>& sp)
{
if (_ptr==sp._ptr)
{
return *this;
}
if (*_pcount == 1)
{
~SharedPtr();
}
else
{
(*_pcount)--;
}
*(sp._pcount)++;
_pcount = sp._count;
_ptr = sp._ptr;
return *this;
}循环引用问题
class Test
{
public:
Test()
{
cout << "构造函数"<<" "<<this << endl;
}
Test* fun()
{
return this;
}
~Test()
{
cout << "析构" << endl;
}
};
struct Node
{
Test test;
shared_ptr<Node> _next;
shared_ptr<Node> _prev;
};
int main()
{
shared_ptr<Node> sp1(new Node);
shared_ptr<Node> sp2(new Node);
sp1->_next = sp2;
sp2->_prev=sp1
return 0;
}
当sp1 和sp2析构时，引用计数减为1
当要释放左边空间->释放右边空间的_prev->释放左边的_next->释放左边的空间。
释放左边空间->释放左边空间
形成死循环无法解决。
weak_ptr：解决shared_ptr循环引用问题，不属于RAII智能指针
struct Node
{
Test test;
weak_ptr<Node> _next;
weak_ptr<Node> _prev;
};weak_ptr:解决原理不增加引用计数
template<class T>
class WeakPtr
{
public:
WeakPtr()
:_ptr(nullptr)
{}
WeakPtr(const SharedPtr<T>& sp)
:_ptr(sp._ptr)
{}
WeakPtr<T>& operator= (SharedPtr<T>& sp)
{
_ptr = sp.get();
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
