1:C++中可不可以自动管理内存的释放功能？

2:C++里面的智能指针究竟是如何实现的？

3:以下代码去掉注释与未去掉注释的结果是什么？

#include
#include
#include
using namespace std;
void * operator new(size_t size,int data,char *flags)
{
return ::operator new(size);
}
void operator delete(void *tmp)
{
cout<<"delete"< free(tmp);
}
int main()
{
int *tmp=new (10,NULL)int[10];
//auto_ptr pInt(tmp);
return 0;
}

内存申请后最容易被人遗忘的操作就是内存的回收，一个良好的程序员在C/C++中必定记得的是一个new对应一个delete(其实new与delete未必申请与释放内存，想知道为什么，可以看我的博客中你真的了解NEW操作符吗:)),一个malloc对应一个free,那么C++中有没有自动回收内存的机制呢，答案是有

那就是auto_ptr指针，也许有些人压根就没听说过，也许有些人听说了但是嫌它的功能不够强大，改投了Boost库，作为C++语言的内置特性，还是有必要了解与分析一下，程序员都是比较懒的，释放内存就交给它吧:)

MSDN中关于它的定义如下：

Wraps a smart pointer around a resource that ensures the resource is destroyed automatically when control leaves a block.

翻译过来的的意思就是资源的智能指针，当不再使用该资源时，能够自动释放该资源所占用的内存。

其源代码定义在这个文件中，如下:

template
class auto_ptr {
public:
typedef _Ty element_type;
explicit auto_ptr(_Ty *_P = 0) _THROW0(): _Owns(_P != 0), _Ptr(_P) {}
auto_ptr(const auto_ptr<_Ty>& _Y) _THROW0()
: _Owns(_Y._Owns), _Ptr(_Y.release()) {}
auto_ptr<_Ty>& operator=(const auto_ptr<_Ty>& _Y) _THROW0()
{if (this != &_Y)
{if (_Ptr != _Y.get())
{if (_Owns)
delete _Ptr;
_Owns = _Y._Owns; }
else if (_Y._Owns)
_Owns = true;
_Ptr = _Y.release(); }
return (*this); }
~auto_ptr()
{if (_Owns)
delete _Ptr; }
_Ty& operator*() const _THROW0()
{return (*get()); }
_Ty *operator->() const _THROW0()
{return (get()); }
_Ty *get() const _THROW0()
{return (_Ptr); }
_Ty *release() const _THROW0()
{((auto_ptr<_Ty> *)this)->_Owns = false;
return (_Ptr); }
private:
bool _Owns;
_Ty *_Ptr;
};

以上代码中可以得到的是智能指针是通过模板进行实现的，是的，也只能如此:)，这就是泛型

首先看看它的两个数据成员

bool _Owns;//代表的是该智能指针是否拥有该资源
_Ty *_Ptr;//该指针指向内存中开僻的资源，

其次是构造函数

explicit auto_ptr(_Ty *_P = 0) _THROW0(): _Owns(_P != 0), _Ptr(_P) {}

可以清楚的看到的是当成功开僻了一个资源，则_p!=0,然后将智能指针数据成员里的_Ptr指向资源，并设置为拥有该资源。

再次拷贝构造函数

auto_ptr(const auto_ptr<_Ty>& _Y) _THROW0()
: _Owns(_Y._Owns), _Ptr(_Y.release()) {}

在拷贝构造函数中，可以得出的结论是一个资源只有由一个智能指针所拥有，当拷贝构造函数调用时，先前拥有该智能指针的对像将会释放，即_Y.release()，如果同时被两智能指针有拥有，释放资源时将会产生错误

_Ty *release() const _THROW0()
{((auto_ptr<_Ty> *)this)->_Owns = false;//设置基不再拥有该指资源，并返回该资源的指针
return (_Ptr); }

最为关键的就是其析构函数，析构函数中，可以发现的是谁拥有该资源，谁负责释放

~auto_ptr()
{if (_Owns)
delete _Ptr; }

然后还有一个比较重要的函数就是其赋值函数，如下

auto_ptr<_Ty>& operator=(const auto_ptr<_Ty>& _Y) _THROW0()
{if (this != &_Y)//判断两个对象是否是同一个对象的，是的话直接返回
{if (_Ptr != _Y.get())//如果不是同一个对象，判断是否指向了同一个资源
{if (_Owns)//如果未指向同一个资源的话，将原对像的资源先释放，再指向新资源
delete _Ptr;
_Owns = _Y._Owns; }
else if (_Y._Owns)//如果指向同一个资源，标识其拥有该资源
_Owns = true;
_Ptr = _Y.release(); }//释放掉_Y对资源的拥有，并该回资源的指针

return (*this); }

好了，终于到最后了，最后是三个比较简单的函数，不作解释

_Ty& operator*() const _THROW0()
{return (*get()); }
_Ty *operator->() const _THROW0()
{return (get()); }
_Ty *get() const _THROW0()
{return (_Ptr); }

最后是一个例子，已经注释，例子中使用了printf而没有使用cout,大家可以自已想想

#include
#include
#include
using namespace std;
//重载的new
void * operator new(size_t size,int data,char *flags)
{
return ::operator new(size);
}
//重载的delete
void operator delete(void *tmp)
{
cout<<"delete"< free(tmp);
}
int main()
{
int *tmp=new (10,NULL)int[10];//调用重载的new
*tmp=5;
auto_ptr pInt(tmp);
auto_ptr pTmp(pInt);
printf("%d\n",*pTmp);
//cout<<*pTmp< return 0;//释放时调用重载的delete
}