What is memory allocation in c plus plus?

Answer 1

Whenever we instantiate an object of type T, we must allocate sizeof(T) bytes to that object. When that object falls from scope, the memory it occupied is released back to the system. In most cases this is done for us, automatically, thus we don't often consider the memory allocations and deallocations going on behind the scenes. However, in order to make best use of memory, it is vital to know exactly where and when every allocation occurs, and when that memory is released.

In C++ there are generally 4 areas of memory to consider. The code area is the area that contains our program's machine code. In essence, this is the area where our program's functions reside. The next area is called the global area, which is essentially where our static allocations reside. The next area is the call stack, or simply the stack. This is the area where we do most of our work, it is where scoped variables are automatically allocated and released. The final area is the heap or free store. Unlike the other areas, which have a fixed size, the heap gives us the freedom to utilise as much memory as we need for any purpose we desire (within the limitations of the platform). In order to do so we must allocate that memory as and when it is needed and release it when it is no longer required.

In order to allocate memory on the heap, we must use the new operator. To release the memory, we use the delete operator. We can also instantiate and release arrays of objects using the new [] and delete [] operators.

We can also use the C-style functions, malloc and free, to achieve the same thing. However, it's important to note that when malloc is used to instantiate an object of a class, the object's constructor (if it has one) is not invoked as it is with new. Moreover, malloc returns a void pointer (void*) which must subsequently be cast to the appropriate type before it can be used. You must also be careful not to delete memory allocated with malloc, or to free memory allocated with new. The same restrictions apply to the other C-style allocators, calloc and realloc. Although you are free to use these C-style functions if you wish, they are best avoided as they offer no advantages over the new operator.

The new operator is a unary operator. Its only argument is the type of memory we wish to allocate. The return value is a pointer of that type. However, the return value is temporary. If we don't immediately assign that value to a local pointer of the same type, the memory address will be lost. And if we lose the memory address, there's no way to release the allocation -- resulting in a memory leak.

For example, is we wish to allocate memory for an int, we would use the following statements:

int* p = new int;

// use p...

delete p;

It is important to note that we've actually got two variables here, not one. The first is the pointer named p. The second is the integer itself. However, the integer has no name of its own, so the only way we can refer to it is by dereferencing p. It's also important to note that p can fall from scope before we've deleted the memory it points to. Although that's usually bad, it is sometimes necessary if we want the allocated memory to exist beyond the scope of the pointer. Fortunately, we do not need the pointer itself, we only need the memory address stored in the pointer. Thus we often encounter functions similar to the following:

int* allocate (int value=0)

{

int* p = new int {value};

return p;

}

Note that p will fall from scope when this function returns, but its value will not -- provided we immediately assign that return value to another pointer:

void foo ()

{

int* ptr = allocate (42);

// use ptr...

delete ptr;

}

Although these functions are trivial, you should avoid using these types of function as ownership of the memory is vague at best. For instance, if you have two pointers pointing at the same address, neither pointer can be said to own the memory. And if you delete one of those pointers, the other is immediately invalidated. In general, the function that allocates memory should also be responsible for deallocating that memory. But sometimes that's neither possible nor desirable. However there are ways to define ownership of a raw pointer, using smart pointers and resource handles.

Smart pointers are classes that encapsulate a pointer and behave exactly like the pointer. There are generally two types of smart pointer: unique and shared. When a unique pointer falls from scope, it automatically releases the memory being pointed to. This has the advantage that you no longer have to remember to delete the pointer when you're finished with it (indeed, smart pointers simply won't allow you to delete the encapsulated pointer). This is fine when ownership of the memory can be confined to a single scope. But for memory where ownership is harder to define, a shared pointer comes into its own. A shared pointer maintains a count of all instances of the shared pointer that refer to the same memory. As each comes into scope, the count is incremented and as each falls from scope the count is decremented. Only when the last instance falls from scope does the destructor finally release the memory.

Resource handles are a bit like unique pointers in terms of memory ownership, however you don't use them as you would a pointer. This is because the memory being pointed to might move around. Consider an array. Whenever you need to add a new element to the end of an array you first need to reallocate the array to make space for the new element. This can result in the entire array being moved to new memory, in which case your original pointer is no longer valid. This is similar to how the C-style realloc function works with raw pointers. However, if you use a resource handle, the actual address is of no real concern to you. The resource handle takes care of the dynamic allocation and reallocation of the underlying memory for you. This is exactly how std::string and std::vector work.