On 16.02.2011 11:00, James Kanze wrote:
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();
—end example ]
I think I can fill in the details on that.
Consider an expression like:
new( a1, a2, a3 ) T( b1, b2, b3 );
In order for the above to compile, there needs to be a function
declared of the form:
void* operator new( std::size_t, U1, U2, U3 ) noexcept; //or without
noexcept.
That can match the call expression "operator new( a1, a2, a3 )".
That new expression has to call that allocation function and compare
the return value to null, in order to decide whether to construct an
object or not. Generally, there's no way for the new expression to
know apriori that the return value isn't null.
See 5.3.4/11:
The new-placement syntax is used to supply additional arguments to an
allocation function. If used, overload
resolution is performed on a function call created by assembling an
argument list consisting of the amount of
space requested (the first argument) and the expressions in the new-
placement part of the new-expression (thesecond and succeeding
arguments). The first of these arguments has type std::size_t and the
remaining arguments have the corresponding types of the expressions in
the new-placement.
See 5.4.3/13:
[ Note: unless an allocation function is declared with a non-throwing
exception-specification (15.4), it indicates
failure to allocate storage by throwing a std::bad_alloc exception
(Clause 15, 18.6.2.1); it returns a
non-null pointer otherwise. If the allocation function is declared
with a non-throwing exception-specification,
it returns null to indicate failure to allocate storage and a non-null
pointer otherwise. —end note ] If the
allocation function returns null, initialization shall not be done,
the deallocation function shall not be called,
and the value of the new-expression shall be null.
In our case: p is of type U*.
new( p ) T( b );
The standard says in 18.6.1.3 that there is a function pre-defined by
the implementation:
void* operator new( std::size_t, void* ptr ) noexcept
{
return ptr;
}
//it says it only returns ptr, and does nothing else.
It our case, the allocation function returns the value given to its
second parameter, originally from our variable p in the new
expression. But it must check whether it is null or not, and construct
an instance of T only if non-null.
There's no much way to avoid this pointer comparison, in this case,
that you want the object to be created in the address pointed to by p.
Even if you add your own allocation function to be called instead, the
new expression must compare its return value with null to decide
whether to construct.
Maybe if the optimizer could somehow prove that p is null, it would
ommit the comparision.
itaj
