Placement new and exceptions

Question

The "placement new" operator is declared as such:

void* operator new (std::size_t size, void* ptr) noexcept;

But while it doesn't involve any actual allocation so bad allocation exceptions are eliminated, it is still possible that the pointer points to a bad location, in which case one would expect to get a range or over/underflow error, but won't the fact that it was declared as noexcept simply terminate execution instead?

Also does this mean prior to C++11 placement new will throw and try to handle an std::unexpected in case of std::set_unexpected instead of directly crashing?

Shouldn't there be a throwing overload of placement new "just in case"?

Answer 1

To understand what this function does, I think it is necessary to take a look at what a new-expression does: It calls an allocation function to obtain storage for the object, then it constructs that object in the memory region the allocation function indicated (by returning a pointer to said memory region).

This implies that construction is never performed by the allocation function itself. The allocation function has the strange name operator new.

It is possible to supply additional parameters for the allocation function by using the placement-new syntax:

new int(5)        // non-placement form
new(1,2,3) int(5) // placement-form

However, placement-new typically refers to a very specific new-expression:

void* address = ...;
::new(address) int(5) // "the" placement-form

This form is intended to construct an object in an already allocated region of memory, i.e. it is intended to just call the constructor, but not perform any allocation.

No special case has been introduced in the core language for that case. Rather, a special allocation function has been added to the Standard Library:

void* operator new (std::size_t size, void* ptr) noexcept;

Being a no-op (return ptr;), it allows calling the constructor for an object explicitly, constructing at a given memory location. This function call can be eliminated by the compiler, so no overhead is introduced.

Answer 2

Placement new exists to make possible explicit constructor calls targeted into arbitrary buffers (for custom allocators, debugging, etc...). That's about it.

You can write your own that validates its input.

For example: A class might require some kind of alignment, and you suspect some custom allocator of fudging this up. So, you give the class a different placement new and see what happens when said allocator uses it.

Answer 3

Point of using placement syntax is to achieve non standard allocation, so non standard freeing is typically required. Consequently action taken depends on the allocator used.

It's your job to provide correct address for placement new to work.

EDITED IN RESPONSE TO COMMENTS:-

#include <new>        // Must #include this to use "placement new"
#include "Fred.h"     // Declaration of class Fred

    void someCode()
    {
      char memory[sizeof(Fred)];     // Line #1     //Allocate enough memory.
      void* place = memory;          // Line #2     // There's no need for this.

      Fred* f = new(place) Fred();   // Line #3 (see "NOTE" below)
      // The pointers f and place will be equal

      ...
    }

NOTE: You are taking sole responsibility that the pointer you pass to the "placement new" operator points to a region of memory that is big enough and is properly aligned for the object type that you're creating. Neither the compiler nor the run-time system make any attempt to check whether you did this right. If your Fred class needs to be aligned on a 4 byte boundary but you supplied a location that isn't properly aligned, you can have a serious disaster on your hands.

In short this means you should be careful with the use of placement new OR if your a guy like me then never use it:)

Hope this would clear your doubts.

Answer 4

You seem to think that the function could somehow validate the pointer it gets passed.

It cannot. There is nothing in the language standard that allows that. Granted, checking for the nullptr case would be possible, but only marginally useful.

Alignment errors are strictly UB, so any implementation is free to do anything. (even just have it work: x86)

Checking whether the memory area is big enough especially does not make any sense with placement new, as it may be quite likely that the user code puts other stuff in that area also, and the compiler cant check that. Apart from that C and C++ nowhere offer the ability to check the size of an allocated region of mem.