Memory leak prevention C++ (Am I right or wrong?)

Question

I have searched the internet for hours and hours and came up with these steps to prevent memory leaks (w/o use of smart pointers and advance tools as such). Please let me know if there are any issues with any of the below findings... Thanks in advance.

1. for each new there should be a delete.
2. if the new is inside a class putting the delete in the destructor would take care of the dynamically allocated memory.
3. if you do a new object obj from class foo in main then in you would have to explicitly delete obj.
4. if you have multi-dimentional dynamic arrays you have to delete both levels. (I am a bit unsure of this being safe... I thought just one delete for the ptr might do it but after thinking harder I figured it is a dynamic array of dynamic arrays and should treat each as a dynamic array separately).

ex 1.

char *ptr;
ptr = new char[size];
// Some Code here
delete ptr;

ex 2.

//foo.h
class foo { 
private:
    char * ptr;
public
    foo();
    ~foo();
};
// foo.cpp
foo::foo()
{
    ptr = new char[100];
    for (int i = 0; i < 100; i++)
        ptr[i] = i;
}

foo::~foo()
{
    delete ptr;
}

ex 3.

//main.cpp   foo class stays the same as ex 2.
int main()
{
    foo obj = new foo();
    // Some code here
    delete obj;
    return 0;
}

ex 4.

//foo.h
class foo {
private:
    char ** ptr;
public
    foo();
    ~foo();
};

//foo.cpp
foo::foo()
{
    ptr = new char[100];
    for (int i = 0; i < 100; i++)
        ptr[i] = new char[100];
    for (int i = 0; i < 100; i++)
        for (int j = 0; j < 100; j++)
            ptr[i][j] = i;
}

foo::~foo()
{
    for (int i = 0; i < 100; i++)
        delete ptr[i];
    delete ptr;
}

Answer 1

Below are some tips you need to take care while managing memory on your own:-

First and most important of all is:-

1) Always use delete with new and delete[] with new[].Mixing these would result in undefined behavior.

2) Never combine malloc/delete OR new/free.

For your question "if you have multi-dimentional dynamic arrays you have to delete both levels." Yes you have to take care of them.

Things you mentioned are correct i.e you have to explicitly delete the memory whenever you are allocating memory in heap. Though you missed one important aspect which revolves around RAII. Let's say there's a function in which you are taking care of allocation/deallocation.

void fun ()
{
 1) int* ptr;
 2) ptr = new int;   //allocated memory.

 3) ...              //do something with ptr.

 4) delete ptr;     //done with ptr now delete it.
}

Now you are doing good by deleting memory which you allocated using new. However, there could be a chance that program execution won't even reach to your delete. ( in case exception is thrown in STEP#3). That case would constitute a memory leak.

To care of these issues we have smart pointers based on the concept of RAII. They will automatically delete the memory they are referring to whenever go out of scope that means you don't need to take care of memory management.

Answer 2

1. for each new there should be a delete.

Yes. And to be more precise: Every new must have a matching delete, and every new[] must have a matching delete[]

2. if the new is inside a class putting the delete in the destructor would take care of the dynamically allocated memory.

No! You also should take care on what should happen for copies through copy constructor or assignment, unless you explicitly forbid these operations. See What is The Rule of Three? for more details.

3. if you do a new object obj from class foo in main then in you would have to explicitly delete obj.

?? See 1.?

4. if you have multi-dimentional dynamic arrays you have to delete both levels. (I am a bit unsure of this being safe... I thought just one delete for the ptr might do it but after thinking harder I figured it is a dynamic array of dynamic arrays and should treat each as a dynamic array separately).

Yes, you always have to take care about proper memory management, if you're using raw pointers, no matter how many levels of indirection.

---

My final advice is, leave your head clean about bothering with such questions, but use the stuff provided with the <memory> smart pointers, and standard c++ containers.

Don't use new/delete directly, unless you're a 100% sure what you're doing, and you're a 200% sure you really need to do it.

---

As you're asking about actual issues:

(ex 2.) The delete doesn't match the new char[]

ptr = new char[100];
           // ^^^^^

foo::~foo() {
    delete [] ptr;
        // ^^ put the square brackets there
}

same for (ex 4.)