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’m out for a compelling reason. It depends on how you define “compelling”. Many of the arguments you have thus far rejected are certainly compelling to most C++ programmers, as your suggestion is not the standard way to allocate naked arrays in C++. The simple fact is this: yes, you absolutely can do things the … Read more
You aren’t rebinding a reference, you’re creating a new object in the memory of another one with a placement new. Since the destructor of the old object was never run I think this would be undefined behavior.
Er…use new? That’s kind of the point. You can also call the constructor explicitly, but there’s little reason to do it that way Using new/delete normally: A* a = new A(); delete a; Calling the constructor/destructor explicitly (“placement new”): A* a = (A*)malloc(sizeof(A)); new (a) A(); a->~A(); free(a);
While I can’t see much of a question in there except “Has anyone ever needed placement new to correctly handle the null pointer case?” (I haven’t), I think the case is interesting enough to spill some thoughts on the issue. I consider the standard broken or incomplete wrt the placement new function and requirements to … Read more
The important pieces of your code line by line… Allocate memory for one Person object: auto p = (Person*)malloc(sizeof(Person)); Construct a Person object in that already allocated memory via calling its constructor: p = new(p)Person(); Free the memory allocated via malloc: free(p); Calling the constructor via placement new creates a std::string. That string would be … Read more
Sort of. You can use placement new to run the constructor using already-allocated memory: #include <new> Object1 ooo[2] = {Object1(“I’m the first object”), Object1(“I’m the 2nd”)}; do_smth_useful(ooo); ooo[0].~Object1(); // call destructor new (&ooo[0]) Object1(“I’m the 3rd object in place of first”); So, you’re still using the new keyword, but no memory allocation takes place.
Update Nicol Bolas correctly points out in the comments below that this has been fixed such that the overhead is always zero for operator new[](std::size_t, void* p). This fix was done as a defect report in November 2019, which makes it retroactive to all versions of C++. Original Answer Don’t use operator new[](std::size_t, void* p) … Read more
std::destroy_at provides two objective improvements over a direct destructor call: It reduces redundancy: T *ptr = new T; //Insert 1000 lines of code here. ptr->~T(); //What type was that again? Sure, we’d all prefer to just wrap it in a unique_ptr and be done with it, but if that can’t happen for some reason, putting … Read more