Re: auto_ptr<void>
Ulrich Eckhardt ha scritto:
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.
You are focusing to 5.3.5/5, but the key point here is, IMHO, in
5.3.5/2: "In the first alternative (delete object), the value of the
operand of delete shall be a pointer to a non-array object or a pointer
to a sub-object (1.8) representing a base class of such an object
clause. If not, the behavior is undefined."
If you allocate memory with
void* x = ::operator new(1000)
then x won't point neither to "a non-array object" neither to "a
sub-object" (*). Therefore the expression "delete x" leads to undefined
behaviour.
By the way, it's a nonsense to say that the dynamic type coincide with
the static type in this case, because there's NO object at all! No
object, no type!
Just my 2 cent,
Ganesh
(*) 1.8/1 says explicitly that "An object is created by a definition
(3.1), by a new-expression (5.3.4) or by the implementation (12.2) when
needed." So the mere invocation of an allocation function, although it
returns a "region of storage", does not "create" an object.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]