这是输出：
new A(string 1)
1
2
new A(string 2)
1
1
2
1
2
new A(string 3)
1
1
0
delete A(string 2)
2
1
string 1
string 3
0
delete A(string 3)
0
delete A(string 1)
请按任意键继续. . .

这样测试就出镨了,
    ref_ptr<A> pa;
    ref_ptr<A> pb;
    pb =pa;

说明在赋值时的计数,考虑还不是很周全.

的确~~ 光注意实现功能了 - -。。
感谢楼上提示

临时补丁 = = v1.1：

template<typename T> ref_ptr<T> &ref_ptr<T>::operator = (const ref_ptr<T> &rp)
{
    if (m_pobj)   m_pobj->dec_ref();
    m_pobj = rp.m_pobj;
    if (m_pobj)   m_pobj->inc_ref();   // <-- 这里
    return  *this;
}

呃，去看More Effective C++，上面有一个现成的，去比较一下，会对你很有提高的。

谢谢楼上~~ 但是MEC++的那个auto_ptr是基于移交所有权的智能指针（大家都知道它的使用价值实在不高）
这个是基于引用计数的 昨天测试循环引用的时候写的
我知道boost里有share_ptr，个人还不太清楚share_ptr的工作机制。。。

template<typename T> ref_ptr<T> &ref_ptr<T>::operator = (const ref_ptr<T> &rp)
{
    if (m_pobj)   m_pobj->dec_ref();
    m_pobj = rp.m_pobj; //如果m_pobj 指向的对象引用计数为1，这样赋值m_pobj 指向的对象就泄漏了吧
    if (m_pobj)   m_pobj->inc_ref();   // <-- 这里
    return  *this;
}

楼上的什么意思？？
那一句的前一句不就是给m_pobj减计数么，如果此前引用是1一减就成0了，会被ref_obj自动回收

学习，呵呵，楼主的代码是实现什么功能的

会被ref_obj自动回收？ 怎么回收

#ifndef SHARED_PTR_H_
#define SHARED_PTR_H_

#ifndef NULL
#define NULL 0
#endif

namespace util
{
    template <class T>
    class shared_ptr;

    template <class T>
    class shared_data
    {
      private:
        friend class shared_ptr<T>;

        explicit shared_data(T *pT): _M_ptr(pT)
        {
            _M_nCount = 1;
        }

        ~shared_data()
        {
            delete _M_ptr;
        }

        void operator++()
        {
            ++_M_nCount;
        }

        void operator--()
        {
            --_M_nCount;
            if (_M_nCount == 0)
            {
                delete this;
            }
        }

        T &operator *()const
        {
            return  *_M_ptr;
        }

        T *operator->()const
        {
            return _M_ptr;
        }

        bool operator == (T *pT)const
        {
            return _M_ptr == pT;
        }

        T *get()
        {
            return _M_ptr;
        }

        int use_count()
        {
            return _M_nCount;
        }

      private:
        T *_M_ptr;
        unsigned int _M_nCount;
    };

    template <class T>
    class shared_ptr
    {
        typedef shared_data<T> element;
      public:
        explicit shared_ptr(T *pT): _M_pD(NULL)
        {
            _M_pD = new element(pT);
        }
        explicit shared_ptr(): _M_pD(NULL)
{
        }
        // copy constructor
        shared_ptr(const shared_ptr < T >  &rT)
        {
            _M_pD = rT.get_element();
            if (_M_pD != NULL)
            {
                ++(*_M_pD);
            }
        }

        ~shared_ptr()
        {
            if (_M_pD != NULL)
            {
                --(*_M_pD);
            }
        }

        // assignment operator
        shared_ptr < T >  &operator = (const shared_ptr < T >  &rT)
        {
            if (_M_pD != NULL)
            {
                --(*_M_pD);
            }
            _M_pD = rT.get_element();

            if (_M_pD != NULL)
            {
                ++(*_M_pD);
            }
            return  *this;
        }


        // assignment operator
        shared_ptr < T >  &operator = (shared_ptr < T >  &rT)
        {
            if (_M_pD != NULL)
            {
                --(*_M_pD);
            }
            _M_pD = rT.get_element();

            if (_M_pD != NULL)
            {
                ++(*_M_pD);
            }
            return  *this;
        }

        T &operator *()const
        {
            return _M_pD->operator *();
        }

        T *operator->()const
        {
            return _M_pD->operator->();
        }

bool operator == (shared_ptr < T >  &rT)const
        {
            return rT.get_element() == _M_pD;
        }

        bool operator == (T *pT)const
        {
            if (_M_pD == NULL)
            {
                return pT == NULL;
            }
            return  *_M_pD == pT;
        }

        T *get()
        {
            if (_M_pD == NULL)
            {
                return NULL;
            }
            else
            {
                return _M_pD->get();
            }
        }

        void release()
        {
            if (_M_pD != NULL)
            {
                --(*_M_pD);
                _M_pD = NULL;
            }
        }

        void reset(T *pT)
        {
            if (_M_pD != NULL)
            {
                --(*_M_pD);
                _M_pD = NULL;
            }
            _M_pD = new element(pT);
        }

      private:
        element *get_element()const
        {
            return _M_pD;
        }

        element *_M_pD;
    };
}

#endif

上面这个实现就很完整了，　Boost 和　loki 的实现也很棒．
楼主看看吧，也许对你有帮助．

aflyinghorse() ( ) 信誉：99    Blog  2006-12-14 09:48:11  得分: 0  
 
 
   会被ref_obj自动回收？ 怎么回收
  
=========================================================================

virtual ~ref_obj() { delete m_pdata; }  <- 这里
void dec_ref() const
{ 
  if (m_cref) m_cref--;
  std::cout << m_cref << std::endl;
  if (!m_cref) delete this;             <- 和这里
}

-------------------------------------------------------------------------

 pottichu(拉拉是头猪) ( ) 信誉：100    Blog  2006-12-14 09:50:44  得分: 0  
 
 
   上面这个实现就很完整了，　Boost 和　loki 的实现也很棒．
楼主看看吧，也许对你有帮助．
  
=========================================================================

借鉴中。。。。

哦，没问题。
没仔细看你的代码，只是觉得没在operator = 进行delete有点违反直觉

还有下面的代码并不是异常安全的
template<typename T> ref_ptr<T> &ref_ptr<T>::operator = (T *pdata)
{
    if (m_pobj)m_pobj->dec_ref();
    m_pobj = new ref_obj<T>(pdata);
    m_pobj->inc_ref();
    return*this;
}

我没完全明白楼上的意思，能否说详细一些

PS.这个类处理空指针还是有些问题，昨夜失眠今天状态不佳 改日再改 - -

boost里的shared_ptr实在太复杂了，太狠了，以至于成为Scott Meyers的My Most Important C++ Aha! Moments...Ever中的5惊叹之一 。

boost的shared_ptr是否可以解决循环引用的问题？？ 换句话说它是否基于引用计数？？
我还不是很清楚。。。

template<typename T> ref_ptr<T> &ref_ptr<T>::operator = (T *pdata)
{
   //前两句换下顺序
    m_pobj = new ref_obj<T>(pdata);
    m_pobj->dec_ref();
    m_pobj->inc_ref();
    return*this;
}

更正以下
template<typename T> ref_ptr<T> &ref_ptr<T>::operator = (T *pdata)
{

    ref_obj<T>* tmp = new ref_obj<T>(pdata);
    
    m_pobj->dec_ref();
    m_pobj = tmp；
    m_pobj->inc_ref();
    return*this;
}

boost的shared_ptr是否基于引用计数的
有时间我也学习一下

是基于引用计数，　楼主可以看看代码．
不过　boost里搞得确实比较复杂．呵呵。
detail::shared_count pn;    // reference counter

aflyinghorse() ( ) 信誉：99    Blog  2006-12-14 10:30:44  得分: 0  
 
 
   更正以下
template<typename T> ref_ptr<T> &ref_ptr<T>::operator = (T *pdata)
{

    ref_obj<T>* tmp = new ref_obj<T>(pdata);
    
    m_pobj->dec_ref();
    m_pobj = tmp；
    m_pobj->inc_ref();
    return*this;
}

===========================================================

了解~~~ 多谢提示

  
 

转自：
http://www.stlchina.org/twiki/bin/view.pl/Main/BoostProgrammSmartPoint


shared_ptr 
这里有一个你在标准库中找不到的—引用数智能指针。大部分人都应当有过使用智能指针的经历，并且已经有很多关于引用数的文章。最重要的一个细节是引用数是如何被执行的—插入，意思是说你将引用计数的功能添加给类，或者是非插入，意思是说你不这样做。Boost shared_ptr是非插入类型的，这个实现使用一个从堆中分配来的引用计数器。关于提供参数化策略使得对任何情况都极为适合的讨论很多了，但是最终讨论的结果是决定反对聚焦于可用性。可是不要指望讨论的结果能够结束。 
shared_ptr完成了你所希望的工作：他负责在不使用实例时删除由它指向的对象（pointee），并且它可以自由的共享它指向的对象（pointee）。 

void PrintIfString?(const any& Any) { 

if (const shared_ptr* s = 

any_cast >(&Any)) { 

cout << **s << endl; 

} 

} 

int main(int argc, char* argv[]) 

{ 

std::vector Stuff; 

shared_ptr SharedString1? 

(new string("Share me. By the way, 

Boost.any is another useful Boost 

library")); 

shared_ptr SharedString2? 

(SharedString1?); 

shared_ptr SharedInt1? 

(new int(42)); 

shared_ptr SharedInt2? 

(SharedInt1?); 

Stuff.push_back(SharedString1?); 

Stuff.push_back(SharedString2?); 

Stuff.push_back(SharedInt1?); 

Stuff.push_back(SharedInt2?); 

// Print the strings 

for_each(Stuff.begin(), Stuff.end(), 

PrintIfString?); 

Stuff.clear(); 

// The pointees of the shared_ptr's 

// will be released on leaving scope 

// shared_ptr的pointee离开这个范围后将被释放 

return 0; 

} 


any库提供了存储所有东西的方法[2]HYPERLINK "file:///C:Documents%20and%20SettingsAdministrator桌面 My%20Documents新建 CUJhtml20.04karlsson%22%20l"[4]。在包含类型中需要的是它们是可拷贝构造的（CopyConstructible），析构函数这里绝对不能引发，他们应当是可赋值的。我们如何存储和传递“所有事物”？无区别类型（读作void*）可以涉及到所有的事物，但这将意味着将类型安全（与知识）抛之脑后。any库提供类型安全。所有满足any需求的类型都能够被赋值，但是解开的时候需要知道解开类型。any_cast是解开由any保存着的值的钥匙，any_cast与dynamic_cast的工作机制是类似的—指针类型的类型转换通过返回一个空指针成功或者失败，因此赋值类型的类型转换抛出一个异常(bad_any_cast)而失败。 


shared_array 
shared_array与shared_ptr作用是相同的，只是它是用于处理数组的。 
shared_array MyStrings?( new Base[20] ); 



深入shared_ptr实现 
创建一个简单的智能指针是非常容易的。但是创建一个能够在大多数编译器下通过的智能指针就有些难度了。而创建同时又考虑异常安全就更为困难了。Boost::shared_ptr这些全都做到了，下面便是它如何做到这一切的。（请注意：所有的include，断开编译器处理，以及这个实现的部分内容被省略掉了，但你可以在Boost.smart_ptr当中找到它们）。 

首先，类的定义：很显然，智能指针是（几乎总是）模板。 

template class shared_ptr { 


公共接口是： 

explicit shared_ptr(T* p =0) : px(p) { 

// fix: prevent leak if new throws 

try { pn = new long(1); } 

catch (...) { checked_delete(p); throw; } 

} 


现在看来，在构造函数当中两件事情是容易被忽略的。构造函数是explicit的，就像大多数的构造函数一样可以带有一个参数。另外一个值得注意的是引用数的堆分配是由一个try-catch块保护的。如果没有这个，你得到的将是一个有缺陷的智能指针，如果引用数没有能够成功分配，它将不能正常完成它自己的工作。 

~shared_ptr() { dispose(); } 


析构函数执行另外一个重要任务：如果引用数下降到零，它应当能够安全的删除指向的对象（pointee）。析构函数将这个重要任务委托给了另外一个方法：dispose。 

void dispose() { if (—*pn == 0) 

{ checked_delete(px); delete pn; } } 


正如你所看到的，引用数（pn）在减少。如果它减少到零，checked_delete在所指对象 (px)上被调用，而后引用数(pn)也被删除了。 

那么，checked_delete执行什么功能呢？这个便捷的函数（你可以在Boost.utility中找到）确保指针代表的是一个完整的类型。在你的智能指针类当中有这个么？ 

这是第一个赋值运算符： 

template shared_ptr& operator= 

(const shared_ptr& r) { 

share(r.px,r.pn); 

return *this; 

} 


这是成员模版,如果不是这样，有两种情况： 

1. 如果没有参数化复制构造函数，类型赋值Base = Derived无效。 

2. 如果有参数化复制构造函数，类型赋值将生效，但同时创建了一个不必要的临时smart_ptr。 

这再一次的展示给你为什么不应当加入你自己的智能指针的一个非常好的原因—这些都不是很明显的问题。 

赋值运算符的实际工作是由share函数完成的： 

void share(T* rpx, long* rpn) { 

if (pn = rpn) { // Q: why not px = rpx? 

// A: fails when both == 0 

++*rpn; // done before dispose() in case 

// rpn transitively dependent on 

// *this (bug reported by Ken Johnson) 

dispose(); 

px = rpx; 

pn = rpn; 

} 

} 


需要注意的是自我赋值（更准确地说是自我共享）是通过比较引用数完成的，而不是通过指针。为什么这样呢？因为它们两者都可以是零，但不一定是一样的。 

template shared_ptr 

(const shared_ptr& r) : px(r.px) { // never throws 

++*(pn = r.pn); 

} 


这个版本是一个模版化的拷贝构造和函数。可以看看上面的讨论来了解为什么要这样做。 

赋值运算符以及赋值构造函数在这里同样也有一个非模版化的版本： 

shared_ptr(const shared_ptr& r) : 

// never throws 

px(r.px) { ++*(pn = r.pn); } 

shared_ptr& operator= 

(const shared_ptr& r) { 

share(r.px,r.pn); 

return *this; 

} 


reset函数就像他的名字那样，重新设置所指对象（pointee）。在将要离开作用域的时候，如果你需要销毁所指对象（pointee）它将非常方便的帮你完成，或者简单的使缓存中的值失效。 

void reset(T* p=0) { 

// fix: self-assignment safe 

if ( px == p ) return; 

if (—*pn == 0) 

{ checked_delete(px); } 

else { // allocate new reference 

// counter 

// fix: prevent leak if new throws 

try { pn = new long; } 

catch (...) { 

// undo effect of —*pn above to 

// meet effects guarantee 

++*pn; 

checked_delete(p); 

throw; 

} // catch 

} // allocate new reference counter 

*pn = 1; 

px = p; 

} // reset 


这里仍然请注意避免潜在的内存泄漏问题和保持异常安全的处理手段。 

这样你就有了使得智能指针发挥其“智能”的运算符： 

// never throws 

T& operator*() const { return *px; } 

// never throws 

T* operator->() const { return px; } 

// never throws 

T* get() const { return px; } 


这仅仅是一个注释：有的智能指针实现从类型转换运算符到T*的转换。这不是一个好主意，这样做常会使你因此受到伤害。虽然get在这里看上去很不舒服，但它阻止了编译器同你玩游戏。 

我记得是Andrei Alexandrescu说的：“如果你的智能指针工作起来和哑指针没什么两样，那它就是哑指针。”简直是太对了。 

这里有一些非常好的函数，我们就拿它们来作为本文的结束吧。 

long use_count() const 

{ return *pn; } // never throws 

bool unique() const 

{ return *pn == 1; } // never throws 


函数的名字已经说明了它的功能了，对么？ 

果然复杂= =

循环引用死锁的测试（环形链表）：

class ring
{
public:
ring(int i) : m(i) { cout << "create node {" << m << "}" << endl; }
~ring() { cout << "release node {" << m << "}" << endl; }
ref_ptr<ring> next;
private:
int m;
};

int main()
{
ref_ptr<ring> head(new ring(0)), r = head;
for (int i = 1; i < 5; i++)
{
r->next = new ring(i);
r = r->next;
}
r->next = head;
return 0;
}

输出：
create node {0}
1
2
create node {1}
1
1
2
create node {2}
1
1
2
create node {3}
1
1
2
create node {4}
1
1
2
2
1
1
请按任意键继续. . .

内存都泄漏光了。。。。。

boost::shared_ptr解决循环引用的办法是加入weaked_ptr。
可去bolog.csdn.net/alai04看《Byond the C++ Standard Library: An Introduction to Boost》中文版。

taodm大 那个网址咋就打不开涅~~

http://blog.csdn.net/alai04/archive/2006/01/07/572961.aspx

google里居然搜出来了~~ = =

收藏，研究中

就是代码的格式有点...

eplanet(小汽车) ( ) 信誉：100    Blog  2006-12-14 15:29:32  得分: 0  
  
   收藏，研究中

就是代码的格式有点...
  
================================================================

为了贴在论坛里少占几行~~ 别见怪

v1.5..... 功能没太多改进~~ 改了下代码结构
不过那个==运算符重载是不是不太合适？？

template<typename T> class ref_ptr
{
private:
    class ref_obj
    {
    public:
        explicit ref_obj(T *pdata) : m_pdata(pdata) { m_cref = 0L; }
        ~ref_obj() { delete m_pdata; }
        T *get_data() const { return m_pdata; }
        void inc_ref() const { if (m_pdata) m_cref++; }
        void dec_ref() const { if (m_cref) m_cref--; if (!m_cref) delete this; }
    private:
        T *m_pdata;
        mutable long m_cref;
    } *m_pobj;
    ref_ptr &evaluate(ref_obj *pobj)
    {
        m_pobj->dec_ref();
        m_pobj = pobj;
        m_pobj->inc_ref();
        return  *this;
    }
public:
    ref_ptr(T *pdata = NULL) : m_pobj(new ref_obj(pdata)) { m_pobj->inc_ref(); }
    ref_ptr(const ref_ptr<T> &rp) : m_pobj(new ref_obj(NULL)) { operator = (rp); }
    ~ref_ptr() { m_pobj->dec_ref(); }
    T &operator * () const { return *m_pobj->get_data(); }
    T *operator -> () const { return m_pobj->get_data(); }
    ref_ptr &operator = (const ref_ptr<T> &rp) { return evaluate(rp.m_pobj); }
    ref_ptr &operator = (T *pdata) { return evaluate(new ref_obj(pdata)); }
    bool is_null(void) const { return NULL == m_pobj->get_data(); }
    bool operator == (const ref_ptr<T>& rp) const
    { return m_pobj->get_data() == rp.m_pobj->get_data(); }
};

老习惯 代码写的比较紧凑。。。

说实在的,不喜欢楼主的代码风格,呵呵。 
看你的代码是件头疼的事情.

ref_ptr(T *pdata = NULL)构造函数加上explicit?

pottichu(拉拉是头猪) ( ) 信誉：100    Blog  2006-12-15 11:03:27  得分: 0  
 
 
   说实在的,不喜欢楼主的代码风格,呵呵。 
看你的代码是件头疼的事情.
  
 
===========================================================================

工程代码自然不敢这么写
不过这是贴在论坛上，个人觉得行数越少越好，省得拖鼠标。。。

---------------------------------------------------------------------------

 aflyinghorse() ( ) 信誉：99    Blog  2006-12-15 11:36:07  得分: 0  
 
 
   ref_ptr(T *pdata = NULL)构造函数加上explicit?
  
 
===========================================================================

加了的话这样的初始化：

ref_ptr<T> p = new T;

就不行了吧。。。 我觉得这种写法更常用写，就没屏蔽

而且这个类既然重载了=，不explicit也应该是安全的。

我也贴个:
template<typename T> class HasPtr
{
private:
    template<typename T>  class UPtr
    {   
public:
    T* m_obj;//因为只供本类访问,数据成员公有是可控的
    mutable unsigned int m_count;
    
    UPtr(T* p):m_obj(p),m_count(1)//
    {}
    ~UPtr(){delete m_obj;}
    };
    
    UPtr<T>   *m_pu;
public:
    HasPtr(T *pdata=NULL):m_pu(new UPtr<T>(pdata))
    {}
    ~HasPtr()
    {
        --m_pu->m_count;
        if (m_pu->m_count==0)
            delete m_pu;
    }
    /////////////////////////
    HasPtr(const HasPtr<T> &rp):m_pu(rp.m_pu)
    {//复制构造不重新创建m_pu指向的数据对象,而是让它一起指向源对象中的数据对象
        ++m_pu->m_count;
        
        assert(m_pu->m_count==rp.m_pu->m_count);//仅测试用
    }
    
    HasPtr &operator = (const HasPtr<T> &rp)
    {
        ++rp.m_pu->m_count;
        --m_pu->m_count ;//当前的m_pu要改变指向,因些要将先的计数-1
        //如果是自赋值,前两句的效果是计数不变.

        if(m_pu->m_count==0)
            delete m_pu;
        
        m_pu=rp.m_pu;
        
        //assert(m_pu->m_count==rp.m_pu->m_count);仅测试用
        return *this;
    }
    HasPtr &operator = (T *pdata)
    {       
        --m_pu->m_count ;
        if(m_pu->m_count==0)
            delete m_pu;
        
        m_pu=new UPtr<T>(pdata);
        m_pu->m_count=1;
        return *this;
    }
    T &operator * () const
    {
        return *(m_pu->m_obj);
    }
    T *const operator -> () const
    {
        return m_pu->m_obj;
    }
};

a_b_c_abc10(无论如何，我一定要去试一试，就算我不能证明我可以，) ( ) 信誉：100    Blog 


    template<typename T>  class UPtr

===============================================================

这句语法错误，没有template<typename T>,
同样问题的还有UPtr<T>   *m_pu; m_pu(new UPtr<T>(pdata))等。
阁下用的VC？？

---------------------------------------------------------------


public:
    T* m_obj;//因为只供本类访问,数据成员公有是可控的

===============================================================

good, 我写1.5也考虑过这个问题
当时认为编译器自动内联get_data()并不会影响效率，不过仔细想想既然代码可以做就不要交给编译器了。
不过对于计数值仍然不太赞同做成公有


不管是阁下的HasPtr还是我写的ref_ptr都有个问题就是空指针实际上都建立了一个UPtr或ref_obj对象，如下的代码：

ref_ptr<T> p = new T;
p = NULL;  // 放弃对T的引用

这个简单的动作却要new一个ref_obj来存放NULL，然后又立即释放掉
本来的v1是可以用m_pobj=NULL表示空指针，但是它却要在引用对象时多做两个判断：

if (m_pobj) m_pobj->dec_ref();
...
if (m_pobj) m_pobj->inc_ref();

要么牺牲时间，要么牺牲空间，1.5选择了后者，不知道有没有更好的方法？？
比如静态null指针对象？？

另外阁下初始化UPtr计数为1似乎是个好主意。
改代码中。。。

标准库的构造函数的写法:
explicit auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }

学好C＋＋，是不得有很好的英语基础啊？？

aflyinghorse() ( ) 信誉：99    Blog  2006-12-15 13:09:50  得分: 0  
 
 
   标准库的构造函数的写法:
explicit auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
  
 
=======================================================================

所以auto_ptr只能这么用：
auto_ptr<T> p(new T);
而不能
auto_ptr<T> p = new T;

我觉得在不影响安全的前提下
ref_ptr<T> p = new T;
的写法更和善一些。不过如果这种方法真的不安全的话就不会采用了
目前还没发现有什么不安全的。。。

bool OnlyTest(cosnt ref_ptr<T> & ptr)
{

}

T t;
OnlyTest(&t);

楼上什么意思？？
既然t已经被堆栈管理了，还怎么能再让智能指针去管理呢？？

我不知道怎么检测一块内存是否在堆里，所以上面的问题不知道怎么解决

这种用法和写
int a;
delete &a;一样，属于不正当用法。。。

＞　所以auto_ptr只能这么用：
＞　auto_ptr<T> p(new T);
＞　而不能
＞　auto_ptr<T> p = new T;
＞
＞　我觉得在不影响安全的前提下
＞　ref_ptr<T> p = new T;
＞　的写法更和善一些。不过如果这种方法真的不安全的话就不会采用了
＞　目前还没发现有什么不安全的。。。

并不是这种写法有什么不安全，这种写法是禁止了从T*到auto_ptr<T>的隐式转换导致的，而允许这一隐式转换会在其它某些时候导致不安全：

void f(ref_ptr<string> const &);
...
string * pstr = new string;
...
f(pstr);//隐式转换将由pstr构造一个ref_ptr<string>临时对象，函数返回后表达式结束，临时对象析构，导致pstr被释放。
*pstr = "abc";//错误！访问被释放的内存块。

而禁止了隐式转换的话：

f(pstr);//编译错误：无法从pstr转换到ref_ptr<string> const &
只能写
f(ref_ptr<string>(pstr));
这样就会提醒程序员，这里会用pstr构造了一个ref_ptr<string>的临时对象，会导致pstr被释放。而正确的写法可能应该是：
f(ref_ptr<string>(new string(*pstr)));

事实上，从指针到智能指针的显式转换也不应该存在，它的存在只是为了构造智能指针用。如，如果可能，智能指针根本不应该允许从普通指针的构造。而应该：

ref_ptr<string> pstr;
pstr.create("abc");

由create去调用new和string::string，这样就可以彻底避免它管理了不该管理的内存（如已经由其它代码管理，或者是栈内存等）。不过这个“create”不太好实现，很难让它无论T的构造函数如何声明都完全和直接调用T的构造函数效果完全相同，主要是由于模板函数展开时对引用类型的处理方式的问题。如果限制构造函数只能使用值拷贝和常引用类型的参数的话，问题就简单了。

plainsong(短歌)()：

对explicit的讲解很精辟~~
让我注意到了没有注意到的问题，感谢。

========================

事实上，从指针到智能指针的显式转换也不应该存在，它的存在只是为了构造智能指针用。如，如果可能，智能指针根本不应该允许从普通指针的构造。而应该：

ref_ptr<string> pstr;
pstr.create("abc");

由create去调用new和string::string，这样就可以彻底避免它管理了不该管理的内存（如已经由其它代码管理，或者是栈内存等）。不过这个“create”不太好实现，很难让它无论T的构造函数如何声明都完全和直接调用T的构造函数效果完全相同，主要是由于模板函数展开时对引用类型的处理方式的问题。如果限制构造函数只能使用值拷贝和常引用类型的参数的话，问题就简单了。

-------------------------

这个也是我正在考虑的问题，写一个替代new的东西
不过一个不能范型的智能指针是无法忍受的，也许正因为如此各种智能指针的实现都没有解决这个问题

继续思考。。。

楼主的功力比较强,所以就在这里搭车问一下:
句柄类和智能指针是一回事吗?这个C++Primer上的句柄类跟智能指针好象是一回事啊.用测试智能指针相同的代码测试这个句柄类输出都一样.

template <class T>  class Handle
{
    T*  ptr;   //
    size_t* use;//


    void rem_ref()
    {
        if(--*use==0)
        {
        delete ptr;
        delete use;
        }
    }
public:
    Handle(T* p=0):ptr(p),use(new size_t(1)){}
    Handle(const Handle& h):ptr(h.ptr),use(h.use)
    {
        ++*use;
    }
    ~Handle(){rem_ref();}

    Handle& operator=(const Handle& rhs)
    {
        ++(*rhs.use);
        //rem_ref();
        if(--*use==0)
        {
        delete ptr;
        delete use;
        }

        ptr=rhs.ptr;
        use=rhs.use;
        return *this;
    }
    T&operator*()
    {
        if(ptr)
            return *ptr;
        throw std::runtime_error("dereference of unbound Handle");
    }
    T* operator->()
    {
        if(ptr)
            return ptr;
        throw std::runtime_error("access through unbound Handle");
    }
    const T& operator*()const;
    const T* operator->() const;
};

从代码上来看是基本一样的。
一样没写explicit = =，更糟糕的是它通过Handle(T* p=0)构造函数而不是重载=(T *p)来实现引用“生指针”:

Handle<T> h;

h = new T;
=>
h = Handle(new T);

....

智能指针还有一个很难实现的内容，就是->*操作符。我使用普通对象指针时，可以通过->*操作符访问类成员，但使用智能指针后，就只能使用(*p).*ptr的方法了。

感觉new和->*对编译器的依赖都很强，应该很难被C++语言本身自举。

一般情况下，我在实现智能指针时通常会实现一个无异常的swap方法，然后在拷贝赋值操作符中：
void swap( this_type & swap_to ) throw()
{
...
}

this_type & operator = ( this_type const & source )
{
  this_type temp(source);
  swap(temp);
}

这样就不用把拷贝构造函数和析构函数中的内容重写一遍了，改变实现时也比较容易。而且通常情况下，这个swap可以用memcpy来实现：
void swap(this_type & swap_to)
{
  char temp[sizeof(this_type)];
  memcpy (temp, &swap_to, sizeof(this_type));
  memcpy (&swap_to, this, sizeof(this_type));
  memcpy (this, temp, sizeof(this_type));
}

this_type & operator = ( this_type const & source )
{
  this_type temp(source);
  swap(temp);
  return *this; //刚才少写了这一句
}