about the safety of auto_ptr<class T>

[guru.slt]

Hi,

see this code:

auto_ptr<int> int_auto_p(new int(3));
auto_ptr<int> int_auto_p2(int _auto_p.get());

Then, both auto_pointer will own the same object. That will violate the
single ownership expectation on auto_pointer.

Also, if i use this:

int * p = int_auot_p.get( );
delete p;

Then, the object owned by auto_pointer will be removed from outside.
It's also not safe.

So, auto_pointer is not so safe.

any comments?

[Howard]

<gu******@gmail .com> wrote in message
news:11******** *************@g 47g2000cwa.goog legroups.com...

Hi,

see this code:

auto_ptr<int> int_auto_p(new int(3));
auto_ptr<int> int_auto_p2(int _auto_p.get());

Then, both auto_pointer will own the same object. That will violate the
single ownership expectation on auto_pointer.

Also, if i use this:

int * p = int_auot_p.get( );
delete p;

Then, the object owned by auto_pointer will be removed from outside.
It's also not safe.

So, auto_pointer is not so safe.

any comments?

What safety are you expecting? The following isn't "safe", either:

int* p1 = new int(3);
int* p2 = p1;
delete p1;
// now, p2 points to deleted memory.

What you do externally with the internal pointer of an auto_ptr is not under
the control of the auto_ptr. How could it be? The only option would be to
prevent the use of get(), but that would hardly be a good solution, would
it?

Basically, if you do things you shouldn't do, you only have yourself to
blame. Don't blame the hammer because you hit your thumb!

-Howard

[Pete Becker]

gu******@gmail. com wrote:

So, auto_pointer is not so safe.

any comments?

Patient: "Doctor, it hurts when I do this."

Doctor: "So don't do that."

--

Pete Becker
Dinkumware, Ltd. (http://www.dinkumware.com)

[Victor Bazarov]

gu******@gmail. com wrote:
^^^^
What's the "slt" stand for?

see this code:

auto_ptr<int> int_auto_p(new int(3));
auto_ptr<int> int_auto_p2(int _auto_p.get());

Then, both auto_pointer will own the same object. That will violate the
single ownership expectation on auto_pointer.

Also, if i use this:

int * p = int_auot_p.get( );
delete p;

Then, the object owned by auto_pointer will be removed from outside.
It's also not safe.

So, auto_pointer is not so safe.

any comments?

If I climb on a chair and then jump on the cement floor head-first, I will
most likely injure myself, either permanently or fatally. So, neither the
chair nor the cement floor are safe. Hell, sitting and walking aren't
safe then since they involve the chair or the floor. Did you know that
living your life leads to your death with 100% certainty?

These are my comments.

V

[Andre Kostur]

"gu******@gmail .com" <gu******@gmail .com> wrote in
news:11******** *************@g 47g2000cwa.goog legroups.com:

Hi,

see this code:

auto_ptr<int> int_auto_p(new int(3));
auto_ptr<int> int_auto_p2(int _auto_p.get());
_You_ are breaking the constraints on the class. The pointer retrieved
by .get() is still owned by the first auto_ptr. It's _your_
responsibility to not delete it (even indirectly by feeding it to another
auto_ptr). After all, you have _specifically_ requested a pointer that
you _know_ is will still be controlled by the auto_ptr.
Then, both auto_pointer will own the same object. That will violate the
single ownership expectation on auto_pointer.
Yep, you intentionally did it. I don't see a problem here (OK, except in
the person who wrote the code...).
Also, if i use this:

int * p = int_auot_p.get( );
delete p;
Breaking the constraint again. The pointer retrieved by .get() is still
owned by the auto_ptr. It's your responsibility to not delete it. If
you really wanted to, use .release().
Then, the object owned by auto_pointer will be removed from outside.
It's also not safe.

So, auto_pointer is not so safe.

Skydiving isn't safe either when you cut your own parachute strings.
Neither is scuba diving if you block your air lines.

[Howard]

"Howard" <al*****@hotmai l.com> wrote in message
news:lp******** *************@b gtnsc05-news.ops.worldn et.att.net...

<gu******@gmail .com> wrote in message
news:11******** *************@g 47g2000cwa.goog legroups.com...

Hi,

see this code:

auto_ptr<int> int_auto_p(new int(3));
auto_ptr<int> int_auto_p2(int _auto_p.get());

By the way, if you want to accomplish the above, try something like this:

auto_ptr<int> int_auto_p(new int(3));
auto_ptr<int> int_auto_p2(new int(*int_auto_p .get()));

I *think* I got the syntax right. The idea is to initialize a new int
pointer with the contents of the other guy's int pointer, instead of using
the other guy's int pointer directly.

-Howard

[Victor Bazarov]

Howard wrote:

"Howard" <al*****@hotmai l.com> wrote in message
news:lp******** *************@b gtnsc05-news.ops.worldn et.att.net...

<gu******@gma il.com> wrote in message
news:11****** *************** @g47g2000cwa.go oglegroups.com. ..

Hi,

see this code:

auto_ptr<int > int_auto_p(new int(3));
auto_ptr<int > int_auto_p2(int _auto_p.get());

By the way, if you want to accomplish the above, try something like this:

auto_ptr<int> int_auto_p(new int(3));
auto_ptr<int> int_auto_p2(new int(*int_auto_p .get()));

I *think* I got the syntax right. The idea is to initialize a new int
pointer with the contents of the other guy's int pointer, instead of using
the other guy's int pointer directly.

I am not sure what the 'guru' wanted to accomplish there. Are you? Why
not simply do

auto_ptr<int> int_auto_p2(int _auto_p1);

which will transfer the ownership?...

V

[Howard]

"Victor Bazarov" <v.********@com Acast.net> wrote in message
news:0M******** *********@newsr ead1.mlpsca01.u s.to.verio.net. ..

Howard wrote:

"Howard" <al*****@hotmai l.com> wrote in message
news:lp******** *************@b gtnsc05-news.ops.worldn et.att.net...

<gu******@gm ail.com> wrote in message
news:11***** *************** *@g47g2000cwa.g ooglegroups.com ...

Hi,

see this code:

auto_ptr<in t> int_auto_p(new int(3));
auto_ptr<in t> int_auto_p2(int _auto_p.get());

By the way, if you want to accomplish the above, try something like this:

auto_ptr<int> int_auto_p(new int(3));
auto_ptr<int> int_auto_p2(new int(*int_auto_p .get()));

I *think* I got the syntax right. The idea is to initialize a new int
pointer with the contents of the other guy's int pointer, instead of
using the other guy's int pointer directly.

I am not sure what the 'guru' wanted to accomplish there. Are you? Why
not simply do

auto_ptr<int> int_auto_p2(int _auto_p1);

which will transfer the ownership?...

V

You're right, I don't know really what he wanted to accomplish (if
anything). I made a guess.

-H

[Phil Endecott]

> auto_ptr<int> int_auto_p(new int(3));

auto_ptr<int> int_auto_p2(int _auto_p.get());

I wonder what can be done to make this sort of code either look more
dangerous or to generate more warnings. I'm thinking of things like
reinterpret_cas t<> which takes so long to type that by the time you've
got to the end of it you've been able to reflect on whether it's what
you really wanted to do or not. Other cases where you end up with a
dangling pointer can be picked up by the compiler, e.g. returning a
pointer to a local variable. Is there anything that the compiler or
library implementation can do to discourage people from doing stupid
things like this? (I hope people agree that, in general, compiler
warnings are good things.)

--Phil.

[guru.slt]

i want to show:

1). auto_ptr is not so safe.
2). given 1) is true, then it seems no much reason to use auto_ptr,
because we can use normal pointer safely, with care.

in this respect, auto_ptr does not have much obvious advantage over
normal pointer.