智能指针

一、智能指针的发展历史

智能指针的发展要RALL说起RALL要求，资源的有效期与持有资源的对象的生命期严格绑定，即由对象的构造函数完成资源的分配，同时由析构函数完成资源的释放。在这种要求下，只要对象能正确 的析构就不会出现资源泄露的问题。

1、C++98提出auto_Ptr,auto_Ptr的设计是让两个指针指向同一块空间，但是这样会存在释放不当，出现程序崩溃的问题。

2、在Boost库中设计了Scoped_Ptr,Shared_Ptr,Weak_Ptr这三种智能指针。

3、c++jing经过进一步改进设计出Unique_Ptr,shanred_Ptr,weak_Ptr这三种智能指针，Unique_Ptr与相类似。

二、智能指针的实现

1、auto_ptr即是一种常见的智能指针，通常用类模板实现。

#include<iostream>
using namespace std;
template <class T>
class AutoPtr
{
public:
AutoPtr(const T*p)
:_p(p)
{}
~AutoPtr()
{
if(_p)
{
delete _p;
_p = NULL;
}
}
AutoPtr(const AutoPtr<T> &s)
:_p(s.p)
{
s.p = NULL;
}
AutoPtr<T>& operator=(AutoPtr<T>& s)
{
if(_p != s._p)
{
if(_p)
{
delete _p;
}
_P = s._p;
s._p = NULL;
}
return *this;
}
T& operator*()
{
return *_p;
}
T* operator->()
{
return _p;
}
private:
T *_p;
};
void Text()
{
int *p = new int;
AutoPtr<int> ap(p);
*ap = 1;
}

scoped_ptr:守卫指针

#include<iostream>
using namespace std;
template <class T>
class ScopedPtr
{
public:
ScopedPtr (const T*p)
:_p(p)
{}
~ScopedPtr ()
{
if(_p)
{
delete _p;
_p = NULL;
}
}
T& operator*()
{
return *_p;
}
T* operator->()
{
return _p;
}
private:
ScopedPtr (const ScopedPtr <T> &s);
ScopedPtr<T>& operator=(ScopedPtr<T>& s);
private:
T *p;
};
void Text()
{
int *p = new int;
ScopedPtr<int> ap(p);
}
int main()
{
Text();
//system();
}

shared_ptr:共享指针

#include<iostream>
using namespace std;
template<class T>
class SharedPtr
{
public:
SharedPtr(T* s)
:_p(s)
,_count(new int(1))
{}
~SharedPtr()
{
if(--(*_count)==0)
{
delete _p;
_p = NULL;
delete _count;
_count = NULL;
}
}
SharedPtr(SharedPtr<T>& s)
:_p(s._p)
,_count(s._count)
{
(*_count)++;
}
SharedPtr<T>& operator=(SharedPtr<T>& s)
{
if(_p != s._p)
{
if(--(*_count) == 0)
{
delete _p;
_p = NULL;
delete _count;
_count = NULL;
}
_p(s._p);
_count(s._count);
(*_count)++;
}
return *this;
}
T& operator*()
{
return *_p;
}
T* operator->()
{
return _p;
}
int GetCount()
{
return *_count;
}
int GetPtr() const
{
return _P;
}
protected:
T* _p;
int* _count;
};

share_arry:共享数组

#include<iostream>
using namespace std;
template<class T>
class SharedArray
{
public:
SharedArray(T*s)
:_p(s)
,_count(new int(1))
{}
~SharedArray(T* s)
{
if(--(*_count) == 0)
{
delete[] _p;
_p = NULL;
delete _count;
_count = NULL:
}
}
SharedArray(SharedArray<T>& s)
:_P(s._p)
,_count(s._count)
{
(*_count)++;
}
SharedArray<T>& operator= (SharedArray<T>& s)
{
if(_p != s._p)
{
if(--(*_count) == 0)
{
delete[] -p;
_p = NULL;
delete _count;
_count = NULL;
}
_p(s._p);
_count(s._count);
(*_count)++;
}
return *this;
}
T& operator*()
{
return *_p;
}
T* operator->()
{
return _p;
}
int GetCount()
{
return *_count;
}
int GetPtr() const
{
return p;
}
protected:
T* p;
int* _count;
};

weak_pte:弱智针

template<class T>
class WeakPtr
{
public:
WeakPtr()
_p = NULL;
{}
WeakPtr(const SharedPtr<T>& s)
_p(s.p)
{}
~WeakPtr()
{
if()_p
{
delete _p;
_p = NULL;
}
}
T& operator*()
{
return *_p;
}
T* operator->()
{
return _p;
}
private:
T* _p;
};