Memory Allocation

Introduction #

Explicit memory management in C++ has a high complexity but also provides us with great functionality. Sadly, this special domain of C++ is not so well known.

For example, we can directly create objects in static memory, in a reserved area, or even in a memory pool. This functionality is often key in safety-critical applications in the embedded world.

• C++ enables the dynamic allocation and deallocation of memory.

• Dynamic memory, or the heap, has to be explicitly requested and released by the programmer.

• We can use the operators new and new[] to allocate memory and the operators delete and delete[] to deallocate memory.

• The compiler manages its memory automatically on the stack.

Smart pointers manage memory automatically.

Memory allocation #

new #

Thanks to the new operator, we can dynamically allocate memory for the instance of a type.

int* i = new int;
double* d = new double(10.0); 
Point* p = new Point(1.0, 2.0);

• new causes memory allocation and object initialization.

• The arguments in the brackets go directly to the constructor.

• new returns a pointer to the corresponding object.

• If the class of dynamically created objects is part of a type hierarchy, more constructors are invoked.

new[] #

new[] allows us to allocate memory to a C array. The newly created objects need a default constructor.

   double* d = new double[5];
   Point* p = new Point[10];

• The class of the allocated object must have a default constructor.

• The default constructor will be invoked for each element of the C array.

The STL Containers and the C++ String automatically manage their memory.

Placement new #

Placement new is often used to instantiate an object or a C array in a specific area of memory. In addition, we can overload placement new globally or for our own data types. This is a big benefit offered by C++.

char* memory = new char[sizeof(Account)]; // allocate std::size_t 
Account* acc = new(memory) Account; // instantiate acc in memory

• The header, <new>, is necessary.

• Can be overloaded on a class basis or globally.

Typical use-cases #

• Explicit memory allocation

• Avoidance of exceptions

• Debugging

Failed allocation #

If the memory allocation operation fails, new and new[] will raise a std::bad_alloc exception. But that is not the behavior we want. Therefore, we can invoke placement new with the constant std::nothrow. This call will return a nullptr in the case of failure.

char* c = new(std::nothrow) char[10]; 
if (c){
  delete c; 
}
else{
// an error occured
}

New handler #

In the case of a failed allocation, we can use std::set_new_handler with our own handler. std::set_new_handler returns the older handler and needs a callable unit. A callable unit is typically a function, a function object, or a lambda-function. The callable unit should take no arguments and return nothing. We can get the handler currently being used by invoking the function std::get_new_handler.

Our own handler allows us to implement special strategies for failed allocations:

• request more memory
• terminate the program with std::terminate
• throw an exception of type std::bad_alloc

Further information #

• Smart pointers

---

In the next lesson, we will study how to deallocate memory.