🚀 go-pugleaf

In <47l6im$qu1@watnews2.watson.ibm.com>, jjb@watson.ibm.com (John Barton) write
s:
>  Nicely put.  Strict ownership is fundamentally incompatible with
>auto_ptr<T> as function return type.  The latter implies ownership
>by the returned temporary: lifetime control by a temporary is craziness.
>(I have tried to beat this game myself several times).
>
>   The way to use auto_ptr<T> successfully is to limit it to client
>code.  Service providers write:
>   // Callers own the lifetime of returned object; pick it up in an auto_ptr.
>   Foo* doWorkAndCreateAFoo();
>Clients pick up the result in auto del pointers:
>   auto_ptr<Foo> my_foo(doWorkAndCreateFoo());
>Anyone who fails to read and heed the comment loses.
>
>--
>John.

I'm confused, John.  You say "nicely put" but he said that objects
should be put into an auto_ptr<> immediately after creation.  Your code
certainly doesn't do that.

Your code is also a prescription for undeleted objects (despite the
comment).  What's crazy about returning an auto_ptr. aside from the
unnecessary restriction that it can't be used to assign to or construct
another auto_ptr directly?  And why is lifetime control by a "temporary"
fundamentally different than lifetime control by some named object?
The semantics of the two objects is the same, isn't it?  They just have
different lifetimes.

Bill Law
---
[ 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. ]