🚀 go-pugleaf

Sean A Corfield <sean@corf.demon.co.uk> wrote:

>In Tokyo last week, Bill Gibbons suggested using a proxy nested class to
>alleviate this problem. It works by having auto_ptr constructable from the
>proxy object and assignable from the proxy object then having auto_ptr
>convert to the proxy. Something like this:
>
>  template<typename T> class auto_ptr {
>    struct proxy {
>      auto_ptr* p;
>      proxy(auto_ptr* ap) : p(ap) { }
>    };
>  public:
>    auto_ptr(const proxy& prox) : p(prox.p->p) { prox.p->p = 0; }
>    // etc
>    operator proxy() { return proxy(this); }
>    // etc
>  private:
>    T* p;
>  };
>
>
>  auto_ptr<X> f();
>  auto_ptr<X> p(f());
>  // equivalent to:
>  auto_ptr<X> p(f().operator proxy());
>
>Similar code changes could be done for operator=. 

Wouldn't it be more efficient to code the so-called "copy constructor"
using pass by value to avoid the extra unnamed temporary:

  auto_ptr(proxy prox) : p(prox.p->p) { prox.p->p = 0; }

This way, the generated code should be exactly as efficient as passing a
non-const auto_ptr by reference. My concern with both approaches is that
the WP does not actually consider the above to be true copy constructors
(although the ARM did). Thus, the compiler may generate its own copy
constructor for auto_ptr<T>, thus defeating the whole thing.

Just for completeness, I'll mention another solution, ugly as it is:

  template<typename T> class auto_ptr {
  public:
    auto_ptr() : pp(new T*(0)) { }  // pp = Pointer to null pointer
    auto_ptr(const auto_ptr<T>& rhs) : pp(new T*(*rhs.pp)) 
      { *rhs.pp = 0; }
    ~auto_ptr() { delete *pp; delete pp; } // double delete
    T* release() { T* p = *pp; *pp = 0; return p; }

    auto_ptr<T>& operator=(const auto_ptr<T>& rhs)
    {
      if (this == &rhs) return *this;
      delete *pp;
      *pp = *rhs.pp;
      *rhs.pp = 0;  // pp is const pointer to non-const pointer to T
      return *this;
    }
    
  private:
    T** pp;  // double indirection
  };

Of course, this is much less efficient, with all of the heap
manipulations and double-indirections, but I think it would work.
-------------------------------------------------------------
Pablo Halpern                   phalpern@truffle.ultranet.com



---
[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]