🚀 go-pugleaf

Hi,

In article <gregorDp23ts.Axt@netcom.com> gregor@netcom.com (Greg Colvin)
writes:

> In Santa Cruz we decided to change the auto_ptr copy semantics to
> allow returns of auto_ptr from functions.  Following is a simple
> implementation.  
>
> [snip]
> 
> template<class X>
>    class auto_ptr {
>       mutable bool owner;
>       X* px;
>       template<class Y> friend class auto_ptr;
>    public:
>       explicit auto_ptr(X* p=0) 
>          : owner(p), px(p) {}
>       template<class Y>
>          auto_ptr(const auto_ptr<Y>& r) 
>             : owner(r.owner), px(r.release()) {}
>       template<class Y>
>          auto_ptr& operator=(const auto_ptr<Y>& r) {
>             if ((void*)&r != (void*)this) {
>                if (owner) 
>                   delete px;
>                owner = r.owner; 
>                px = r.release();
>             }
>             return *this;
>          }
>       ~auto_ptr()           { if (owner) delete px; }
>       X& operator*()  const { return *px; }
>       X* operator->() const { return px; }
>       X* get()        const { return px; }
>       X* release()    const { owner = 0; return px; }
>    };

If I don't misunderstand the above implementation, it does much more
than just allow auto_ptrs to be returned from functions.  It also
allows auto_ptrs to be dereferenced after the ownership of the pointee
has been transferred to another auto_ptr.

Is this intentional?  Did the committee explicitly decide to allow
dereferencing of non-owning auto_ptrs?  If so, what is the rationale behind
this? 

It seems to me that after the ownership has been transferred, the
no-longer-owning auto_ptr points to an object of undetermined ownership
and lifetime. In other words, its behavior is in no way different from
a built-in pointer.

The old (April 95 DWP) definition of auto_ptr at least guaranteed that if an
auto_ptr was pointing at something, it was pointing at a unique and alive
object.  Now, we don't even have a way to query if this is the case. 

This is a terrible state of affairs, especially when we realize
auto_ptr is the *only* smart pointer we have in the standard library.
In my opinion, it should be renamed to zombie_ptr if it is to keep its
new semantics.

- Wil
---
[ comp.std.c++ is moderated.  To submit articles: try just posting with      ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu         ]
[ FAQ:      http://reality.sgi.com/employees/austern_mti/std-c++/faq.html    ]
[ Policy:   http://reality.sgi.com/employees/austern_mti/std-c++/policy.html ]
[ Comments? mailto:std-c++-request@ncar.ucar.edu                             ]