SMART POINTER（智能指针）

智能指针(smart pointer):智能指针是其实是一个对象A，它带有一个模针成员变量m_p.用该A管理m_p，通过这种管理机制，可以防止由于new而导致的内存泄漏.智能指针对象在使用时像指针一样.同时也具有一般对象的所有特征.如果要注意以下几点:1，对象之间的赋值:若有A=B，则在赋值时，首先要松查是否为自身赋值.如果不是，则释放A对象成员指针的内存空间，然后要将B中的成员指针赋值于A的成员指针，接着将B中的成员指针置为空，这样可以避免多个指针同时指向一个内存空间而产生多次析构此内存空间的错误.所以，重载的赋值函数一般如下:operator =(Test source_object); 此处不能为const 对象的引用，这是因为要修改source_object 的成员指针为空.2，对于copy constroctor也有与operator=类似的情况.只不过不要释放A成员指针的内存空间，.3，关于member template的问题，它往往用于兼容模板对象之间的相互赋值，copy constroctor.我们可以将它看成是个模板类(一个类).譬如:auto_ptrB，这就是一个类名称 另:VC7.0中，成员模板的定义和实现必须放在类的定义中.注:member template不能为static 或virtual4，智能指针中必须重载的几个运算符: - *这样做的目的就是将对象模仿成指针的行为.如下:T* operator -() {return m_p;}

特别注意:object-m_p;== (object.operator-())-m_p;

T operator *(){return *m_p;}

下面的程序演示smart pointer的基本使用:#include"iostream"using namespace std;templateclass Tclass auto_ptr{public:auto_ptr( T *p=0){m_p=p;}

//由auto_ptrT 来复制构造该auto_ptrT对象.auto_ptr(auto_ptrT source_object){ m_p=(T*)( source_object.get());

source_object.m_p=0; //

}//由auto_ptrM来构造该auto_ptrT对象.templateclass Mauto_ptr(auto_ptrM source_object) //此处的对象为非const 对象的引用.{ m_p=(T*)( source_object.get());source_object.m_p=0; //}

//析构....~auto_ptr(){if (m_p!=0)Release();}

//由auto_ptrT赋值于auto_ptrT对象. auto_ptrT operator=(auto_ptrT source_object){Release(); m_p=(T*)(source_object.get());return *this;}

//由auto_ptrM赋值于auto_ptrT对象.templateclass Mauto_ptrT operator=(auto_ptrM source_object){Release(); m_p=(T*)(source_object.get());return *this;} //delete m_p;void Release(){if (m_p!=0)delete m_p;m_p=0;}

T* get(){return m_p;}// from auto_ptrT convert to auto_ptrM

//声明:1 由于上面提供从auto_ptrM构造auto_ptrT的构造函数.所以，在实际上，不必给出下面的隐式类型转换函数.// 2 VC不支持这个隐式转换特性.templateclass M operator auto_ptrM()//如果M和T类型不一致时，将无法进行自动的类型转换.如:auto_ptrint 与auto_ptrfloat{ return auto_ptrM(m_p);

//此处困惑::: // return auto_ptrM(m_p); 这是more effective C++中的写法，当执行此语句时，会构造出一个新auto_ptrM的对象，而this对象的m_p并未释放.这样两个对象的m_p指向共一个变量，??? //应该这样: //temp auto_ptrM(get());//Release();//return temp;}

T* operator -(){return m_p; }

const T* operator-() const{return m_p;}//此处注意为T，这样可以实现左值.T operator *(){return *m_p;}

const T operator *() const{return *m_p;}public:T *m_p;};

class test{public:test(int data){m_data=data;}int operator-(){return m_data;}

operator int(){return m_data;}

public:

int m_data;};

class A{public:A(int data){m_data=data;}private:int m_data;

};

class B:public A{public:B(int data):A(data*2)，m_data(data){;}private:int m_data;

};

class C:public A{public:C(int data):A(data*3)，m_data(data){;}private:int m_data;

};void test_member_template(const auto_ptrA source_object) //此处一定要加const，因为对象隐式转换后生成的对象为临时对象.临时对象的生存周期将不由程序员决定，其值不能被修改.{//source_object.get();}

void test_member_template2(const auto_ptrint source_object)//此处一定要加const，因为对象隐式转换后生成的对象为临时对象.临时对象的生存周期将不由程序员决定，其值不能被修改.{;}

void(){auto_ptrC object2(new C(3));test_member_template(object2); //将调用member template constructor 构造出auto_ptrA 对象.注意，函数执行后，将导致object2变为为空壳对象.要避免这种隐式的模板对象构造.

auto_ptrtest object(new test(15));int data=object.operator-()-m_data;//等价于: data=object.operator-()-operator-();coutdata;

auto_ptrint object_int(new int(999));

auto_ptrint object_int_2(new int(333));

object_int_2=object_int; //operator =

object_float=object_int; //operator = by member template

test_member_template2(object_int); //copy constructor

test_member_template2(object_float);//call constructor by member template. //注意，函数执行后，将导致object2变为为空壳对象.要避免这种隐式的模板对象构造.cout*object_floatendl;;auto_ptrfloat object_2=object_float; //此处调用 copy constructorcout*object_2endl;

}