Re: naked pointer vs boost::shared_ptr<T>
On 1 Mar., 11:10, "James Kanze" <james.ka...@gmail.com> wrote:
On Feb 28, 12:48 pm, "peter koch larsen" <peter.koch.lar...@gmail.com>
wrote:
On Feb 28, 10:24 am, "Sushrut Sardeshmukh" <bestbr...@gmail.com>
wrote:
Should we stop using naked pointer and replace all of them with
boost:shared_ptr or ( shared_array<T> or scoped_ptr) ?
The problem is not so much pointers. My recommendation is that you
should avoid any "delete" or "delete []" in your code.
So how do you delete an object with dynamic lifetime? I agree
with regards to delete[], and I don't think I've used it once in
over 15 years of C++. But delete?
Maybe you meant that all delete should be "delete this"?
No. I've rarely had a need for "delete this". I wonder where you find
this idiom useful? About thte only places I've found use for it is in
"free-floating" threads and some rare GUI application.
delete should be used only in classes whos only purpose is to
maintain the memory resource.
If the only problem is the memory resource, the Boehm collector
does the job a lot better. Some classes have explicit
lifetimes, and the idiomatic way to terminate the lifetime of
such an object is delete.
The Boehm collector might not be available, and if it is it might not
be appropriate if it has non-memory resources.
I am trying to come up with C to C++ conversion guidelines for a large
transformation project. Your inputs will be very valuable.
RAII (of which the above is an example) is THE paradigm to follow.
I'm not sure I follow. RAII obeys scope; if the object lifetime
obeys scope, what are you doing allocating it dynamically to
begin with? There are exceptions, of course, but a lot of the
time, rather than replacing a raw pointer with a smart pointer,
it would be better to do away with the pointer completely.
If you can get rid of the pointer, you should. But there are lots of
cases where you can't. One such case is when a factory function
returns a polymorphic object or an object that can't be copied. Such
objects would have to be dynamically allocated and returned via a
pointer, and it is in cases such as this that I advocate the pointer
to be intelligent.
In my own applications, I find that most pointers are to objects
with explicit lifetimes, and I've yet to find a smart pointer
which is applicable to them (although I've tried). About the
only other cases are polymorphic agents (which are best
collected), and singletons (where dynamical allocation is used
expressedly so that they will never be deleted). In the case of
polymorphic agents, if I can't use the Boehm collector, I will
use either auto_ptr or a shared_ptr of some type.
There are also cases where the underlying representation is in a
pointer - COM is an obvious example for Windows guys. I do not share
your experience with being unable to find a reasonable pointer-type.
boost::scoped_ptr or std::auto_ptr is often a fine choice, and if not
you should be able to simply use boost::shared_ptr.
/Peter
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]