http://blog.csdn.net/rogeryi/article/details/1442700
下面的代码来自于VC++ 8.0里面的源码：
下面的例程来自Exceptional C++，Item 37：
// Example 2: Using an auto_ptr//void g()
{
T* pt1 = new T; // right now, we own the allocated object // pass ownership to an auto_ptr auto_ptr<T> pt2( pt1 ); // use the auto_ptr the same way // we‘d use a simple pointer *pt2 = 12; // same as "*pt1 = 12;" pt2->SomeFunc(); // same as "pt1->SomeFunc();" // use get() to see the pointer value assert( pt1 == pt2.get() ); // use release() to take back ownership T* pt3 = pt2.release(); // delete the object ourselves, since now // no auto_ptr owns it any more delete pt3;
} // pt2 doesn‘t own any pointer, and so won‘t // try to delete it... OK, no double delete // Example 3: Using reset()//void h(){ auto_ptr<T> pt( new T(1) ); pt.reset( new T(2) ); // deletes the first T that was // allocated with "new T(1)"} // finally, pt goes out of scope and // the second T is also deleted
auto_ptr(auto_ptr<_Ty>& _Right) _THROW0() : _Myptr(_Right.release()) { // construct by assuming pointer from _Right auto_ptr } template<class _Other> auto_ptr<_Ty>& operator=(auto_ptr<_Other>& _Right) _THROW0() { // assign compatible _Right (assume pointer) reset(_Right.release()); return (*this); }
// Example 6: Never try to do work through// a non-owning auto_ptr//void f(){ auto_ptr<T> pt1( new T ); auto_ptr<T> pt2; pt2 = pt1; // now pt2 owns the pointer, and // pt1 does not pt1->DoSomething(); // error: following a null pointer}
An important goal of shared_ptr is to provide a standard shared-ownership pointer.
template<class T> class shared_ptr { public: typedef T element_type; shared_ptr(); // never throws template<class Y> explicit shared_ptr(Y * p); template<class Y, class D> shared_ptr(Y * p, D d); ~shared_ptr(); // never throws shared_ptr(shared_ptr const & r); // never throws template<class Y> shared_ptr(shared_ptr<Y> const & r); // never throws template<class Y> explicit shared_ptr(weak_ptr<Y> const & r); template<class Y> explicit shared_ptr(std::auto_ptr<Y> & r); shared_ptr & operator=(shared_ptr const & r); // never throws template<class Y> shared_ptr & operator=(shared_ptr<Y> const & r); // never throws template<class Y> shared_ptr & operator=(std::auto_ptr<Y> & r); void reset(); // never throws template<class Y> void reset(Y * p); template<class Y, class D> void reset(Y * p, D d); T & operator*() const; // never throws T * operator->() const; // never throws T * get() const; // never throws bool unique() const; // never throws long use_count() const; // never throws operator unspecified-bool-type() const; // never throws void swap(shared_ptr & b); // never throws }; Note： Boost文档里面的QA说明了为什么不提供release函数 Q. Why doesn‘t shared_ptr provide a release() function?A. shared_ptr cannot give away ownership unless it‘s unique() because the other copy will still destroyConsider:shared_ptr<int> a(new int);shared_ptr<int> b(a); // a.use_count() == b.use_count() == 2 int * p = a.release(); // Who owns p now? b will still call delete on it in its destructor.Furthermore, the pointer returned by release() would be difficult to deallocate reliably, 另外，还记得Effective C++里面（或者其它的C++书籍），Scott Meyer告诉你的：在一个由多个模块组成的系统里面，一个模块不用试图自己去释放另外一个模块分配的资源，而应该遵循谁分配谁释放的原则。正确的原则但 是有时难免有时让人忽略（过于繁琐），将资源包装在shared_ptr里面传递，而shared_ptr保证了在资源不再被拥有的时候，产生资源的模块 的delete语句会被调用。
class Base{}class Derived : public Base{} shared_ptr<Base> sp_base(new Derived);Derived* pd = new Derived; shared_ptr<Derived> sp_derived(pd);shared_ptr<Base> sp_base2(sp_derived);A* pa = new A;xxx_ptr<A> ptr_a_1(pa);xxx_ptr<A> ptr_a_2(pa);void DoSomething(xxx_ptr<A>){ //do something} class A{ doSomething()
{ xxx_ptr<A> ptr_a(this); DoSomething(ptr_a);
}}; int main(){ A a; a.doSomething(); //continue do something with a, but it was already destory}原文：http://www.cnblogs.com/forcheryl/p/4425756.html