A question about smart pointer

[Yong Hu]

Does the smart pointer never lead to memory leak?

Thanks,

[Daniel T.]

In article <11************ **********@75g2 000cwc.googlegr oups.com>,
"Yong Hu" <yh*******@gmai l.com> wrote:

Does the smart pointer never lead to memory leak?

You can still get memory leaks even if you use smart pointers. Much
depends, of course on what the smart pointer does but I think all of
them are pretty susceptible to circular reference problems.

[Phlip]

Yong Hu wrote:

Does the smart pointer never lead to memory leak?

I will explain by comparing other languages. In C++, you must build smart
pointers and manage them carefully so they don't leak. If you use a raw
pointer to a 'new' object, you manage it more carefully or it will leak.
And you can create an object without 'new', and it has much lower odds of
leaking.

The language Java was designed to be sold to your boss. The designers want
to tell your boss, "if your programmers use Java, they will never leak
memory, like that naughty C++ language lets them leak."

So Java has built-in smart pointers. You cannot write the smart pointer
with Java - it's part of the language. And all objects must use smart
pointers. No object can create without a secret call to a kind of 'new'
function, deep inside Java.

And Java also leaks memory, plenty, if you abuse it or make many kinds of
mistakes.

In general, Garbage Collection is a very tough problem, and all languages
have compromises. All languages can leak. C++, even with smart pointers,
is higher risk than most languages because C++ lets you write safe code
that goes very fast.

--
Phlip

[Richard Herring]

In message <11************ **********@75g2 000cwc.googlegr oups.com>, Yong
Hu <yh*******@gmai l.com> writes

Does the smart pointer never lead to memory leak?

It's "smart", not "magic".

The way to avoid memory leaks is to define a rigorous ownership policy,
and then consistently use the correct tools (which might be smart
pointers, or something else) to implement and enforce it.

--
Richard Herring

[mlimber]

Yong Hu wrote:

Does the smart pointer never lead to memory leak?

Of course not -- particularly because they can be misused. Does a seat
belt always prevent fatalities in auto accidents? No, especially if one
uses it improperly (e.g., laying down across the seat to which one is
belted). Nevertheless, smart pointers (and seat belts) can go a long
way toward improving safety, and smart pointers should usually be
preferred over manual memory management.

Cheers! --M

[Axter]

Daniel T. wrote:

In article <11************ **********@75g2 000cwc.googlegr oups.com>,
"Yong Hu" <yh*******@gmai l.com> wrote:

Does the smart pointer never lead to memory leak?

You can still get memory leaks even if you use smart pointers. Much
depends, of course on what the smart pointer does but I think all of
them are pretty susceptible to circular reference problems.

The circular reference problem is mostly associated with smart pointers
that have shared ownership logic.
std::auto_ptr does not have shared ownership logic.
And the following smart pointer uses clone ownership logic, and not
shared logic:
http://axter.com/smartptr/classcopy__ptr.htm

Some smart pointers can use either shared logic or clone ownership
logic, like the following policy based smart pointer:
http://axter.com/smartptr

[mlimber]

Axter wrote:

Daniel T. wrote:

In article <11************ **********@75g2 000cwc.googlegr oups.com>,
"Yong Hu" <yh*******@gmai l.com> wrote:

Does the smart pointer never lead to memory leak?

You can still get memory leaks even if you use smart pointers. Much
depends, of course on what the smart pointer does but I think all of
them are pretty susceptible to circular reference problems.

The circular reference problem is mostly associated with smart pointers
that have shared ownership logic.
std::auto_ptr does not have shared ownership logic.
And the following smart pointer uses clone ownership logic, and not
shared logic:
http://axter.com/smartptr/classcopy__ptr.htm

Some smart pointers can use either shared logic or clone ownership
logic, like the following policy based smart pointer:
http://axter.com/smartptr

Right, and some have sole ownership semantics like std::tr1::scope d_ptr
(aka boost::scoped_p tr) which do not have problems with circular
references.

Cheers! --M

[Chandu]

Please check
http://www.boost.org/libs/smart_ptr/smart_ptr.htm

They are already part of C++0x

[Roland Pibinger]

On Thu, 29 Jun 2006 16:12:41 GMT, Phlip <ph*******@gEEE mail.com>
wrote:

So Java has built-in smart pointers. You cannot write the smart pointer
with Java - it's part of the language. And all objects must use smart
pointers. No object can create without a secret call to a kind of 'new'
function, deep inside Java.

Actually, that metaphor is more misleading than enlightening. Pointers
in C/C++ and refences in Java are ultra-lightweight objects that have
2 well-defined, language supported purposes: referencing and
dereferencing. "Smart" pointers in C++, OTOH, are objects that mimic
pointers but may perform some heavy task (eg. reference counting) in
the background which is something entirely different.

Best wishes,
Roland Pibinger

[Howard Hinnant]

In article <11************ **********@d56g 2000cwd.googleg roups.com>,
"Chandu" <ch************ ******@gmail.co m> wrote:

Please check
http://www.boost.org/libs/smart_ptr/smart_ptr.htm

They are already part of C++0x
Of the six smart pointers in the list you referenced, two of them are in
the C++0X working draft: shared_ptr and weak_ptr.

In article <11************ *********@p79g2 000cwp.googlegr oups.com>,
"mlimber" <ml*****@gmail. com> wrote: Right, and some have sole ownership semantics like std::tr1::scope d_ptr
(aka boost::scoped_p tr) which do not have problems with circular
references.

There is no std::tr1::scope d_ptr. There is only boost::scoped_p tr.

-Howard