🚀 go-pugleaf

In article <47sm8h$4eh@gabi.gabi-soft.fr>,
kanze@gabi-soft.fr (J. Kanze) wrote:

|> Just curious: in what way is this any safer than using a const_cast in
|> the implementation of auto_ptr<T>::operator=()?

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=. The committee have not
decided exactly what to do about fixing auto_ptr yet but they intend to do
_something_ in Scotts Valley...probably just make the parameter of the copy
constructor const and force the implementation to work around it with a
cast (ugh!).

Sean A. Corfield
Object Consultancy Services -- voting member of X3J16
C++ - Beyond the ARM http://uptown.turnpike.net/~scorf/cplusext.html
---
[ 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. ]