placement-new

Is the following legal in C++? As far as I can tell, Reference has a trivial destructor, so it should be legal. But I thought references can't be rebound legally... can they? template<class T> struct Reference { T &r; Reference(T &r) : r(r) { } }; int main() { int x = 5, y = 6; Reference<int> r(x); new (&r) Reference<int>(y); } I think I found the answer in a passage below the "quoted" one that talks about trivial dtor / dtor side effects, namely [basic.life]/7: 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

I've been looking into this for the past few days, and so far I haven't really found anything convincing other than dogmatic arguments or appeals to tradition (i.e. "it's the C++ way!" ). If I'm creating an array of objects, what is the compelling reason (other than ease) for using: #define MY_ARRAY_SIZE 10 // ... my_object * my_array=new my_object [MY_ARRAY_SIZE]; for (int i=0;i<MY_ARRAY_SIZE;++i) my_array[i]=my_object(i); over #define MEMORY_ERROR -1 #define MY_ARRAY_SIZE 10 // ... my_object * my_array=(my_object *)malloc(sizeof(my_object)*MY_ARRAY_SIZE); if (my_object==NULL) throw MEMORY

Is the following well defined? #include <iostream> #include <string.h> using namespace std; struct Const { const int i; Const (int i) : i(i) {} int get0() { return 0; } // best accessor ever! }; int main() { Const *q,*p = new Const(1); new (p) Const(2); memcpy (&q, &p, sizeof p); cout << q->i; return 0; } Note that after construction of second Const , p doesn't semantically (intentionally?) points to new object, and the first is gone, so it is usable "as a void* ". But the second object is constructed at the exact same address, so the bit pattern of p represents the address of the new object.

In this question of mine , @DeadMG says that reinitializing a class through the this pointer is undefined behaviour. Is there any mentioning thereof in the standard somewhere? Example: #include <iostream> class X{ int _i; public: X() : _i(0) { std::cout << "X()\n"; } X(int i) : _i(i) { std::cout << "X(int)\n"; } ~X(){ std::cout << "~X()\n"; } void foo(){ this->~X(); new (this) X(5); } void print_i(){ std::cout << _i << "\n"; } }; int main(){ X x; x.foo(); // mock random stack noise int noise[20]; x.print_i(); } Example output at Ideone (I know that UB can also be "seemingly correct behaviour")

Background: I have a complicated class with many variables. I have a sound and tested copy constructor: Applepie::Applepie( const Applepie &copy) : m_crust(copy.m_crust), m_filling(copy.m_filling) { } Some of the member variable copy constructors called in the intializer list perform allocation. Question: I need to create operator= . Rather than duplicating the existing constuctor with assignment instead of initialization list, and freeing memory that's being replaced, and etc etc etc, can I simply do the following: Applepie& Applepie::operator=( const Applepie &copy) { if( this != &copy) {

SomeObj<unsigned int>* Buffer; char* BufferPtr = MemoryManager::giveMeSomeBytes(resX*resY*sizeof(SomeObj<unsigned int>)); Buffer = new(BufferPtr) SomeObj<unsigned int>[resX*resY]; when I step past these lines with the debugger, it shows me the values for the variables Buffer and BufferPtr: BufferPtr: 0x0d7f004c Buffer: 0x0d7f0050 I don't really understand why those values differ. The way I understand it, placement new should use the memory starting at address 'BufferPtr' to initialize the array elements using theyr default constructors on the allocated memory and return a pointer to the first

char * buf = new char[sizeof(T)]; new (buf) T; T * t = (T *)buf; //code... //here I should destruct *t but as it is argument of template and can be //instantiated via basic types as well (say int) so such code /*t->~T();*/ //is incorrect (maybe correct? Strange, but it works on VS 2005 for basic types.) //and this code /*delete t;*/ //crashes the program. delete [] buf; So what is correct way to destruct t ? P.S. The code above is only for describing my problem, and have not real relationship with code I'm going to write. So please don't give answers like (Why use placement new instead of non

I just learned about the C++ construct called "placement new". It allows you to exactly control where a pointer points to in memory. It looks like this: #include <new> // Must #include this to use "placement new" #include "Fred.h" // Declaration of class Fred void someCode() { char memory[sizeof(Fred)]; void* place = memory; Fred* f = new(place) Fred(); // Create a pointer to a Fred(), // stored at "place" // The pointers f and place will be equal ... } (example from C++ FAQ Lite ) In this example, the this pointer of Fred will be equal to place . I've seen it used in our team's code once or