Memory Leaks:

What is Memory Leak?

-

Memory leak occurs when programmers create a memory in heap and forget to delete it.
Memory leaks are particularly serious issues for programs like daemons and servers which by
definition never terminate.

Example:

/* Function with memory leak */

#include <stdlib.h>
void f()
{
int *ptr = (int *) malloc(sizeof(int));
/* Do some work */
return; /* Return without freeing ptr*/
}

1. Many C library functions malloc's memory which MUST be freed:

i.e.: strdup(),

Note: You can NOT use the C++ delete call. The strdup() function is part of
the C library and you must use free().
2. Programmer must free() malloc()'ed memory:
Also for calloc(), malloc() and realloc();

Check for memory allocation errors. Can't free it if it didn't get allocated.

If there was insufficient memory to permit the allocation, malloc() will return
NULL and the error code will be set to ENOMEM. Note that a call to malloc()
with a size of zero may also return NULL
3. Programmer must delete new'ed memory:
New/delete is preferred to malloc()/free() because it can initialize the memory
and it invokes the constructor for new objects. New/delete also point to the
correct memory type. Note on mixing source code containing new/delete and
malloc()/free(). This is not a problem with the GNU C++ compiler but this is
not guaranteed for all C++ compilers.

4. Inheritance, polymorphism and the wrong delete:

If you are counting on the destructor to delete memory allocated in the constructor
beware of this mistake as it will cause a memory leak. Use a virtual destructor to
avoid this problem. The ~BaseClass() destructor is called and then the destructor
~DerivedClass() is chosen and called at run time because it is a virtual destructor. If
it is not declared virtual then only the ~BaseClass() destructor is called leaving any
allocated memory from the DerivedClass object to persist and leak. The behavior of
this error is undefined so don't do it.
The same ill effect can be achieved with a C style cast to a class of less scope which
will dumb down the destructor to that which may not execute all the freeing of the
original class. A C++ style dynamic cast may prevent this error as it will recognize
the loss of translation and not allow the cast to take place resulting in a traceable
crash rather a tough to find memory leak

5. Pointer re-assignment error leads to dangling pointer:

If the pointer is re-assigned a new value before being freed, it will lead to a
"dangling pointer" and memory leak.

6. Default copy constructor may not give correct results:

Memory allocated by copy constructors for pointer duplication: Check the
pointer in the destructor and delete if necessary. Memory allocated when
passing the class by value, invokes the copy constructor. Also beware, the
default copy constructor may not give you the results you want especially
when dealing with pointers as the default copy constructor has no knowledge
of how to copy the contents of what the pointer points to. To prohibit the use
of the default copy constructor one can define a null assignment operator.
One can also write a proper copy constructor.

Good practice: Use assert to check pointers before freeing or using:

How can we avoid?

To avoid memory leaks, memory allocated on heap should always be freed when no longer needed.
/* Function without memory leak */
#include <stdlib.h>;
void f()
{
int *ptr = (int *) malloc(sizeof(int));
/* Do some work */

free(ptr);
return;

How to Find A Memory Leak

Memory Corruption:
-

Buffer overflow:

Example 1:
Overwrite beyond allocated length - overflow.

Example 2:
Index of array out of bounds: (array index overflow - index too large/underflow negative index)

Overflow by one byte.

-

Using an address before memory is allocated and set:

In this case the memory location is NULL or random.

-

Using a pointer which is already freed:

Freeing memory which has already been freed. Also applies to

delete.

Incorrect use of delete: The delete must match the use of new.

Use of "delete abc_ptr" is an error.

Do not use malloc()/free() with a C++ class as it will not call the constructor or
destructor. Also malloc()/free() can not be mixed with new/delete. i.e. Free() can
not be used to free memory allocated with new and delete can not be used to
free memory allocated with malloc().
-

Exception Errors:

Freeing memory never allocated: If you use a constructor to allocate memory but
an exception is thrown before all is allocated, the destructor needs to be aware
that fact or else it may try to free memory which was never allocated.
Also the converse is true. If the destructor throws an exception, subsequent
steps which free memory may not be executed. This applies to the destructor
and all nested destructors which handle/re-throw the exception while the stack
unwinds.
BTW: Resources tied to the lifetime of the object is known as RAII (Resource
Acquisition Is Initialization), where the resource allocation is done during object
creation in the constructor and resource deallocation is done by the destructor.
-

Pointer persistence:

Function returning a pointer from the stack which can get overwritten by the
calling function (in this case main()):

This is also true for a local variable within the scope of only { and } as well as for
the scope of a function.
-

Incorrect passing of a function argument:

If the pointer is passed around as an argument and does not get passed
correctly, one may try to free the incorrect pointer.
-

Mixing the object base class and derived class:

If mixing the object base class and derived class when passing an object by
value as a function parameter, make sure that you understand what may be lost.

Note that this is a cautionary warning to be careful and not necessarily an error as it
depends on the intent and use. This can be used properly.
-

Copying an object:

Don't use memcpy() or any bit for bit copy function to copy an object. It will not
execute the class constructor. What kind of person would do this?? Passing an
object in a va_arg() list will result in a bit for bit copy and will not use the default
copy constructor.

Link:
[1] http://www.yolinux.com/TUTORIALS/C+
+MemoryCorruptionAndMemoryLeaks.html

[2] https://msdn.microsoft.com/en-us/library/x98tx3cf(v=vs.140).aspx