placement-new

I read this When should I worry about alignment? but I am still do not know if I have to worry about not aligned pointer returned by placement new operator - like in this example: class A { public: long double a; long long b; A() : a(1.3), b(1234) {} }; char buffer[64]; int main() { // (buffer + 1) used intentionally to have wrong alignment A* a = new (buffer + 1) A(); a->~A(); } __alignof(A) == 4 , (buffer + 1) is not aligned to 4 . But everything works fine - full example here: http://ideone.com/jBrk8 If this depends on architecture then I am using: linux/powerpc/g++ 4.x.x. [UPDATE] Just

Possible Duplicate: C++'s “placement new” What is an in-place constructor in C++? e.g. Datatype *x = new(y) Datatype(); 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 will use the memory allocated by the call to malloc . new will not allocate any more. You are not, however, limited to classes. You can use a placement new operator for any type you

I'm dang certain that this code ought to be illegal, as it clearly won't work, but it seems to be allowed by the C++0x FCD. class X { /* ... */}; void* raw = malloc(sizeof (X)); X* p = new (raw) X(); // according to the standard, the RHS is a placement-new expression ::operator delete(p); // definitely wrong, per litb's answer delete p; // legal? I hope not Maybe one of you language lawyers can explain how the standard forbids this. There's also an array form: class X { /* ... */}; void* raw = malloc(sizeof (X)); X* p = new (raw) X[1]; // according to the standard, the RHS is a placement-new

Can I call constructor explicitly, without using new , if I already have a memory for object? class Object1{ char *str; public: Object1(char*str1){ str=strdup(str1); puts("ctor"); puts(str); } ~Object1(){ puts("dtor"); puts(str); free(str); } }; Object1 ooo[2] = { Object1("I'm the first object"), Object1("I'm the 2nd") }; do_smth_useful(ooo); ooo[0].~Object1(); // call destructor ooo[0].Object1("I'm the 3rd object in place of first"); // ???? - reuse memory Sort of. You can use placement new to run the constructor using already-allocated memory: #include <new> Object1 ooo[2] = {Object1("I'm

Why is that undefined behaviour? struct s { const int id; // <-- const member s(int id): id(id) {} s& operator =(const s& m) { return *new(this) s(m); // <-- undefined behavior? } }; (Quote from the standard would be nice). This question arose from this answer . 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 the

I've been reading somewere that when you use placement new then you have to call the destructor manually. Consider the folowing code: // Allocate memory ourself char* pMemory = new char[ sizeof(MyClass)]; // Construct the object ourself MyClass* pMyClass = new( pMemory ) MyClass(); // The destruction of object is our duty. pMyClass->~MyClass(); As far as I know operator delete normally calls the destructor and then deallocates the memory, right? So why don't we use delete instead? delete pMyClass; //what's wrong with that? in the first case we are forced to set pMyClass to nullptr after we