Re: placement new overhead
On Feb 16, 12:03 pm, "Martin B." <0xCDCDC...@gmx.at> wrote:
On 16.02.2011 11:00, James Kanze wrote:
On Jan 29, 3:31 pm, Marc<marc.gli...@gmail.com> wrote:
I have a memory region (I got it through std::aligned_storage), and I
initialize it using placement new. Looking at the generated code
(gcc-4.6), I notice that:
new(location) Type(arguments);
is implemented as:
if(location!=0) call the constructor
this causes quite a bit of overhead when Type is a trivial type (the
compiler can't always prove that location is not null).
I can't seem to find where the standard says that placement new can be
called with a null argument and should do nothing in that case. Is
this the case?
The signature of placement new is:
void* operator new( size_t, void* ) throw();
The "throw()" means that operator new can return a null pointer,
and that the generated code must behave correctly if it does.
...
Interesting conclusion. Could you explain how you arrive at this
conclusion from the std?
I'll quote N3092 (p 448):
- - -
18.6.1.3 Placement forms
1 (...)
void* operator new(std::size_t size, void* ptr) throw();
2 Returns: ptr.
3 Remarks: Intentionally performs no other action.
4 [ Example: This can be useful for constructing an
object at a known address:
void* place = operator new(sizeof(Something));
Something* p = new (place) Something();
=97end example ]
- - -
=A73.7.3.1 (which specifies the requirements for allocator
functions), particularly =A73.7.3.1/2: "If [the allocation
function] is successful, it shall return the address of the
start of a block of storage whose length in bytes shall be at
least as large as the requested size" and =A73.7.3.1/3: "[...] If
an allocation function declared with an empty
exception-specification (15.4), throw(), fails to allocate
storage, it shall return a null pointer." Together, this
specifies clearly that the only legal return values of an
allocator function (and all "operator new" are allocator
functions) are a pointer to valid memory and a null pointer, and
the latter only if the allocator function has an empty exception
specifier.
Since "void* operator new(size_t size, void* ptr) throw()"
returns ptr directly, it stands to reason that ptr must meet the
requirements for a legal return value of this function. Without
the empty exception specification, that would mean a valid
pointer to the requested size; with the empty exception
specification, a null pointer is also valid.
--
James Kanze