placement-new

Possible Duplicate: C++'s “placement new” in the below code what does Line 3 represents, is it the way of typecasting? or what void someCode() { char memory[sizeof(Fred)]; // Line #1 void* place = memory; // Line #2 Fred* f = new(place) Fred(); // Line #3 // The pointers f and place will be equal ... } This is a typical usage of Placement new . It allows you to allocate memory and then construct objects at that particular memory location. Line #3 essentially just calls the constructor Fred::Fred() . The this pointer in the Fred constructor will be equal to place . The returned pointer f will

I am exploring the possibility of implementing true (partially) immutable data structures in C++. As C++ does not seem to distinguish between a variable and the object that variable stores, the only way to truly replace the object (without assignment operation!) is to use placement new: auto var = Immutable(state0); // the following is illegal as it requires assignment to // an immutable object var = Immutable(state1); // however, the following would work as it constructs a new object // in place of the old one new (&var) Immutable(state1); Assuming that there is no non-trivial destructor to

I saw a presentation on cppcon of Piotr Padlewski saying that the following is undefined behaviour: int test(Base* a){ int sum = 0; sum += a->foo(); sum += a->foo(); return sum; } int Base::foo(){ new (this) Derived; return 1; } Note: Assume sizeof(Base) == sizeof(Derived) and foo is virtual. Obviously this is bad, but I'm interested in WHY it is UB. I do understand the UB on accessing a realloc ed pointer but he says, that this is the same. Related questions: Is `new (this) MyClass();` undefined behaviour after directly calling the destructor? where it says "ok if no exceptions" Is it valid

Here's a very easy way to define move assignment for most any class with a move constructor: class Foo { public: Foo(Foo&& foo); // you still have to write this one Foo& operator=(Foo&& foo) { if (this != &foo) { // avoid destructing the only copy this->~Foo(); // call your own destructor new (this) Foo(std::move(foo)); // call move constructor via placement new } return *this; } // ... }; Is this sequence of calling your own destructor followed by placement new on the this pointer safe in standard C++11? Only if you never, ever derive a type from this class. If you do, this will turn the

What is the <- operator/expression in Rust? You can find the symbol here . I happened to be looking at a page describing expressions and operations in Rust. I do not program in Rust, so I asked a friend who is pro-Rust what this symbol is but even he doesn't know what it is. The <- operator is not part of stable Rust. At least not yet. There is an RFC which proposes syntax involving <- for writing new objects directly to specific places in memory, as an alternative to another RFC , which proposes in . This is a generalisation of the (currently unstable) box syntax, which lets you allocate

I have a huge contiguous array x that I fread from a file. How do I drop this chunk into a std::vector<> ? In other words, I prefer to have the result to be in std::vector<> rather than the array, but I want the resultant C++ code to be as efficient as this plain C-version which drops the chunk right into the array. From searching around, I think I may have to use placement-new in some form, but I'm uncertain about the sequence of calls and ownership issues. Also, do I need to worry about alignment issues? I am testing for with T = unsigned , but I expect a reasonable solution to work for any