When you call placement new on a buffer: A *a = new (buf) A; you are invoking the built-in void* operator new (std::size_t size, void* ptr) noexcept as defined in: c++11 18.6.1.3 Placement forms [new.delete.placement] These functions are reserved, a C++ program may not define functions that displace the versions in the Standard C++ library … Read more
It’s really, really simple: new can be thought of as doing two things: Allocating the memory. Placement-constructing the object in the allocated memory. There’s no guarantee that malloc is actually used by the implementation, but typically it is. You cannot assume it about the implementation, but for the purpose of understanding it’s an OK assumption. … Read more
The issue of pointer arithmetic on allocated memory, as in your example: T* storage = static_cast<T*>(operator new(sizeof(T)*size)); // … T* p = storage + i; // precondition: 0 <= i < size new (p) T(element); being technically undefined behaviour has been known for a long time. It implies that std::vector can’t be implemented with well-defined … Read more
It allows you to do your own memory management. Usually this will get you at best marginally improved performance, but sometimes it’s a big win. For example, if your program is using a large number of standard-sized objects, you might well want to make a pool with one large memory allocation. This sort of thing … Read more
There is nothing that makes the shown code snippet inherently UB. However, it is almost certain UB will follow immediately under any normal usage. From [basic.life]/8 (emphasis mine) If, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, a new object is created at … Read more
If you are using Visual Studio 2010 or 2012, be advised: the compiler does not automatically generate move constructors for you. That wasn’t implemented. So you need to write them yourself.
Only a can safely be used to directly access the Foo object created by the placement new-expression (which we’ll call x for ease of reference). Using b requires std::launder. The value of a is specified in [expr.new]/1: If the entity is a non-array object, the result of the new-expression is a pointer to the object … Read more
This is called the placement new operator. It allows you to supply the memory the data will be allocated in without having the new operator allocate it. For example: Foo * f = new Foo(); The above will allocate memory for you. void * fm = malloc(sizeof(Foo)); Foo *f = new (fm) Foo(); The above … Read more
Using the new expression does two things, it calls the function operator new which allocates memory, and then it uses placement new, to create the object in that memory. The delete expression calls the object’s destructor, and then calls operator delete. Yeah, the names are confusing. //normal version calls these two functions MyClass* pMemory = … Read more
I think the only way to make this really safe to use is to require the called constructor to be noexcept, for example by adding a static_assert: static_assert(noexcept(T(22, Brown, true)), “The constructor must be noexcept for inplace reconstruction”); T x(31, Blue, false); x.~T(); ::new (&x) T(22, Brown, true); Of course this will only work for … Read more