Explicit memory management has in C++ a high complexity but also provides great functionality. Sadly, this special domain is not so known in C++. For example, you can directly create objects in static memory, in a reserved area, or even a memory pool. That is functionality, which is often key in safety-critical applications in the embedded world. Before the harvest is the work, therefore, I will give in this post an overview, before I dive deeper into the details.<\/p>\n
<\/p>\n
<\/p>\n
In C++, we use new<\/span> and new[]<\/span> for memory allocation and delete<\/span> and delete[]<\/span> for memory deallocation. But that is by far not the whole story.<\/p>\n Thanks to the operator new<\/span>, you can dynamically allocate memory for the instance of a type.<\/span><\/p>\n <\/p>\n <\/p>\n The in parentheses used arguments are the arguments for the constructor. The result of the new<\/span> call is a pointer to the according to type. The initialization of the instance is happing after the allocation of the memory. Placement new<\/span> uses the fact that new<\/span> consists of two steps. If the object is an object of a class hierarchy, the constructors of all base classes will automatically be performed.<\/p>\n new[]<\/span> creates in opposite to new a<\/span> C array of objects. The newly created objects need a default constructor.<\/p>\n <\/p>\n Placement new is often used to instantiate an object in a pre-reserved memory area. In addition, you can overload placement new globally and for your own data types. This is a big benefit that C++ offers.<\/p>\n <\/p>\n <\/p>\n Placement new needs an additional argument (lines 2 and 5). Lines 1 and 4 are why the <\/span>operator<\/span> new(sizeof(Account),memory) <\/span>can be used. Or to say it the other way around. The object will be instantiated in the memory area <\/span>memory<\/span>. Accordingly, the same holds for the C array b<\/span>.<\/span><\/p>\n If the memory allocations fail new<\/span> and new[]<\/span> will raise a std::bad_alloc<\/span> exception. But that is often not the behavior you want. Therefore, you can invoke placement new with a constant std::nothrow:<\/span> char* c new(std::nothrow) char[10].<\/span> This call causes you will get a nullptr<\/span> in the error case.<\/p>\n In the case of a failed allocation, you can use std::set_new_handler<\/span> as your own handler. std::set_new_handler<\/span> returns the older handler and needs a callable unit. This callable unit should take no argument and return nothing. You can get the currently used handler by invoking the function std::get_new_handler.<\/span><\/p>\n Your handler allows you to implement special strategies for failed allocations:<\/p>\n A with new<\/span> previously allocated memory will be deallocated with delete.<\/span><\/p>\n <\/p>\n <\/p>\n The object’s destructors and base classes’ destructors will automatically be called. If the base class’s destructor is virtual, you can destroy the object with a pointer or reference to the base class.<\/p>\n After the object’s memory is deallocated, access to the object is undefined. You can point the pointer of the object to a different object.<\/p>\n You have to use the operator delete[]<\/span> to deallocate a C array that was allocated with new[].<\/span><\/p>\n <\/p>\n <\/p>\n By invoking delete[]<\/span> all destructors of the objects will automatically be invoked.<\/p>\n The deallocation of a C array with delete<\/span> is undefined behavior.<\/p>\n According to placement new, you can implement placement delete. But, remarkably, the C++ runtime will not automatically call placement delete. Therefore, it’s the programmer’s duty.<\/p>\n A typically used strategy invokes the destructor in the first step and placement delete in the second step. The destructor deinitializes the object, and placement new deallocates the memory.<\/p>\n <\/p>\n Of course, according to statements and strategies, the usage of placement delete for C arrays holds.<\/p>\n<\/span>Memory allocation<\/span><\/h2>\n
<\/span>new<\/span><\/h3>\n
int<\/span>* i= new<\/span> int<\/span>;\ndouble<\/span>* x= new<\/span> double<\/span>(10.0);\nCircle* c= new<\/span> Circle;\nPoint* p= new<\/span> Point(1.0, 2.0);\n<\/pre>\n<\/div>\n<\/span>new[]<\/span><\/h3>\n
double<\/span>* da= new<\/span> double<\/span>[5];\nCircle* ca= new<\/span> Circle[8];\n<\/pre>\n<\/div>\n<\/span>Placement new<\/span><\/h3>\n
\n\n
\n \n 1\n2\n3\n4\n5<\/pre>\n<\/td>\n
\n char<\/span>* memory= new<\/span> char<\/span>[sizeof<\/span>(Account)];\nAccount* a= new<\/span>(memory) Account;\n\nchar<\/span>* memory2= new<\/span> char<\/span>[5*sizeof<\/span>(Account)];\nAccount* b= new<\/span>(memory2) Account[5];\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/span>Failed allocation<\/span><\/h3>\n
New handler<\/h4>\n
\n
<\/span>Memory deallocation<\/span><\/h2>\n
<\/span>delete<\/span><\/h3>\n
Circle* c= new<\/span> Circle;\n...\ndelete<\/span> c;\n<\/pre>\n<\/div>\n<\/span>delete[]<\/span><\/h3>\n
Circle* ca= new<\/span> Circle[8];\n...\ndelete<\/span>[] ca;\n<\/pre>\n<\/div>\n<\/span>Placement delete<\/span><\/h3>\n
char<\/span>* memory= new<\/span> char<\/span>[sizeof<\/span>(Account)];\nAccount* a= new<\/span>(memory) Account; \/\/ placement new<\/span>\n...\na->~Account(); \/\/ destructor<\/span>\noperator<\/span> delete(a,memory); \/\/ placement delete\n<\/span>\n<\/pre>\n<\/div>\n<\/span>What’s next?<\/span><\/h2>\n