What is memory leakage in c plus plus?

Answer 1

Memory leakage occurs when you allocate memory dynamically but do not keep track of the allocation. If you lose track of an allocation then you cannot release the memory back to the system until the program terminates. If you continually allocate without releasing, you not only waste a lot of memory unnecessarily, you could easily run out of memory altogether. The following code demonstrates this:

#include <iostream>

int main()

{

int* p=NULL;

do {

p=(int*)malloc(sizeof(int));

} while(p);

return(0);

}

In the above code, p is continually allocated memory which is not released before the next allocation. The program will eventually exit when you run out of memory, releasing all memory back to the system, but you should never code like this. Always release memory as soon as it is no longer required.

#include <iostream>

int main()

{

int* p=(int*)malloc(sizeof(int));

while(p)

{

delete(p); // release memory

p=(int*)malloc(sizeof(int));

}

return(0);

}

This time the program will never terminate so long as p is non-NULL. Although the program may never exit, memory is no longer leaking.

Obviously these programs are merely demonstrations and not useful in any way (we're not actually using the memory we allocate). In real applications, however, you will always delete pointers as soon as you're finished with them and especially when you wish to re-use a pointer, as per the second example.

So long as you maintain at least one pointer to allocated memory you can return that memory back to the system as soon as it is no longer required. If you fail to keep track of allocated memory, leakage is only to be expected. Even if it doesn't cause any problems, as per the first example, it is bad programming practice to allow any pointer to allocated memory to fall from scope.

Answer 2

Memory leaks refer to data in memory that no longer has a proper way to be accessed. Though memory leaks can be caused in many ways, the most common way is by changing the address of a pointer without first deleting the data that it points to.

int *p = new int;

*p = 3;

*p = new int;

*p = 4;

In the example above I allocated memory for an int variable and set p to point at it. I then set the value of that memory location to 3. Then I again allocated memory for an int variable and set p to point at it. However, I did not delete the first memory that I allocated. Since p was changed to point at a new memory location, I have now lost that first memory location and have no way to get back to it. The memory is still allocated and taking up resources, but can no longer be used by anything.