**C++智能指针部分指针的实现**

C++智能指针部分指针的实现

  由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。

用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: intrusive_ptr。你可能会想，如此多的智能指针就为了解决new、delete匹配问题

从而言之：
对于编译器来说，智能指针实际上是一个栈对象，并非指针类型，在栈对象生命期即将结束时，智能指针通过析构函数释放有它管理的堆内存。所有智能指针都重载了“operator->”操作符，直接返回对象的引用，用以操作对象。访问智能指针原来的方法则使用“.”操作符。

举个例子：void fun()
{
int *p=new int(1);
if(1)
{
return;
}
delete p;//会存在内存泄漏的问题，返回后才释放
}
void fun()
{//….代码
if(1)
{
throw 1;
}
//….
}
void test2()
{
int *p=new int (10);
fun();//fun函数内部存在抛出异常,
//抛出异常后直接进入mian函数，内存泄漏
//处理
try
{
fun();
}
catch(…)
{
delete p;
throw;
}

}
int main()
{
try
{

}catch(...){    cout<<"未知异常"<<endl;}return 0;

}

如果在1f判断中我们忘记delete p1 ，直接return，那么这块内存就没有释放，很容易造成内存泄露。

所以我们需要使用智能指针来管理动态对象。

所谓智能指针就是智能/自动化的管理指针所指向的动态资源的释放。

STL–auto_ptr

Boost库的智能指针（ps:新的C++11标准中已经引入了
unique_ptr/shared_ptr/weak_ptr）

下面我们分别来看一下这几个智能指针：

1) scoped_ptr:

这是比较简单的一种智能指针，正如其名字所述，

scoped_ptr所指向的对象在作用域之外会自动得到析构，scoped_ptr是non-copyable的，也就是说你不能去尝试复制一个scoped_ptr的内容到另外一个scoped_ptr中，这也是为了防止错误的多次析构同一个指针所指向的对象。顾名思义，守卫的指针，思想就是防拷贝，在大多时候用不到拷贝构造和赋值运算符重载，那么我们做的就是写出构造函数和析构函数，拷贝构造和赋值运算符重载只声明不定义。这里写代码片
template
class ScopePtr//不允许拷贝构造、赋值
{
public:
ScopedPtr*(T*)
:_ptr(ptr)
{}
~ScopedPtr()
{
if(_ptr != NULL)
{
delete _ptr;
_ptr = =NULL;
}
}
T& operator*()
{
return *_ptr;
}
T*GetPtr()
{
return _ptr;
}
protected:
ScopedPtr(const ScopedPtr& p);
ScopedPtr& operator = (const ScopedPtr& p);

private:
T*_ptr;
};
void TestScopedPtr()
{
boost::ScopedPtr sp1(new int(1));
boost::scopedPtr sp2(sp1);
ScopedPtr p3(new int(3));
p3 = p1;

}

2) shared_ptr:

shared_ptr是一个最像指针的”智能指针”.
shared_ptr与scoped_ptr一样包装了new操作符在堆上分配的动态对象，但它实现的是引用计数型的智能指针，可以被自由的拷贝和赋值，在任意的地方共享它，当没有代码使用(引用计数为0)它时才能删除被包装的动态分配的对象。shared_ptr也可以安全地放到标准容器中，并弥补了auto_ptr因为转移语义而不能把指针做为STL容器元素的缺陷。

下面我们来实现以下这个智能指针。
`template
class SharedPtr
{
public:
SharedPtr(T*ptr)
:_ptr(ptr)
,_pcount(new int(1))
{}
~SharedPtr()
{
if(_ptr)
{
if(–*pconut==0)
{
delete _ptr;
delete _pconut;
_ptr=NULL;
_pcount=NULL;
}
_ptr=NULL;
}
}
SharedPtr(const SharedPtr&sp)
{
_ptr=sp._ptr;
_pconut=sp._pconut;
++(*_pconut);
}
SharedPtr&operator=(const SharedPtr&sp)
{
if(_ptr!=sp._ptr)
{
if(–*_pconut==0)
{
delete _ptr;
delete _pcount;
}
_ptr=sp._ptr;
_pcount=sp._pcount;
++(*_pcount);
}
return *this;
}
private:
T*_ptr;
int *_pcount;
};
void TesSharedPtr()
{
SharedPtr sp1(new int(1) );
SharedPtr sp2(sp1);
sp1=sp1;
sp2=sp1;
SharedPtr sp3(new int (3));
sp3=sp1;
}这里写代码片

2) auto_ptr:

auto_ptr 是C++标准库提供的类模板，auto_ptr对象通过初始化指向由new创建的动态内存，它是这块内存的拥有者，一块内存不能同时被分给两个拥有者。当auto_ptr对象生命周期结束时，其析构函数会将auto_ptr对象拥有的动态内存自动释放。即使发生异常，通过异常的栈展开过程也能将动态内存释放。auto_ptr不支持new 数组。

但是它有缺陷，STL容器在分配内存的时候，必须要能够拷贝构造容器的元素。而且拷贝构造的时候，不能修改原来元素的值。而auto_ptr在拷贝构造的时候，一定会修改元素的值。所以STL元素不能使用auto_ptr。

所以最好不要使用。`
class AutoPtr
{public:
AutoPtr(T*ptr)
:_ptr(ptr)
{
cout<<”creat”<<_ptr<