Re: What type of smart pointer should a factory method return?

On Sep 12, 2:02 pm, francis_r <francis.ramme...@gmail.com> wrote:
[snip]


I don't understand what you mean here. The factory function could look
like
     #include <memory>
     class A { public: virtual ~A() = 0; };
     A::~A() {}
     class B : public A { /*implementation details*/ };
     A* factory()
     { std::auto_ptr<A> result(new B);
         //code
         return result.release();
     }

User code could look like
     #include <memory>
     class A { public: virtual ~A() = 0; };
     A* factory();
     void foo()
     { std::auto_ptr<A> x(factory());
         //stuff
         //implicitly freeing on error paths
         //success paths assign it a more permanent owner
     }

I don't see the leak possibility that you referenced.

At least in this particular case, there is no possible exception that
may be thrown between the start release() in factory() and the end of
the auto_ptr constructor in foo(), thus there is no possible leak.

If you do use a structure which can throw when you give it a pointer,
then yes, your problem does exist. Don't write such code. For example,
the here is user could badly written
     #include <vector>
     class A { public: virtual ~A() = 0; };
     A* factory();
     void foo()
     { std::vector<A*> vec;
         vec.push_back(factory());
         delete vec[0];
     }
The previous example could leak. You could write it correctly as
     #include <vector>
     class A { public: virtual ~A() = 0; };
     A* factory();
     void foo()
     { std::vector<A*> vec;
         vec.push_back(0);
         vec.back() = factory();
         delete vec[0];
     }
Or you could write it correctly as
     #include <vector>
     #include <memory>
     class A { public: virtual ~A() = 0; };
     A* factory();
     void foo()
     { std::vector<A*> vec;
         std::auto_ptr<A> tmp(factory());
         vec.push_back(tmp.get());
         tmp.release();
         delete vec[0];
     }
etc.

Now, if you're wary of auto_ptr, then use whatever basic auto_ptr
replacement you want.

Note that I'm not commenting on the correct course of action. I'm just
saying that you can use the raw pointer approach sanely. operator new
and operator delete work on raw pointers, and we've managed to deal
with them, though we tend to encapsulate new, delete, and the raw
pointers when possible.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]