dealing with C++/C structures memory freeing

Question

Must I free structure memory after using it? I have sample code:

struct aa 
{
int a;
char * b ;
    aa()
    {
    a=0;
    b= new char[255];
    }
} ;


aa *ss = new aa[3];

void fill()
{
    aa * ssss = new aa;
    aa * sss = new aa;

    sss->a=10;
    ss[0] = *sss;
    cout<<ss[0].a<<"\n";
    ss[1] = *sss;

    cout<<ss[1].a<<"\n";
    cout<<ssss[1].a<<"\n";
}

int _tmain(int argc, _TCHAR* argv[])
{


    fill();
    delete(ss);
}

Must I do delete(ssss) at the end of fill ?

Must I delete ss array of structure at the end of main ?

Must I create destruct or to structure ss that frees *b memory?

What about classes is it the same logic?

Answer 1

Must I do delete(ssss) at the end of fill?

Yes, you must delete anything created with new . However, there's no need to use new here, just make it automatic:

void fill() {
    aa ssss; // automatically destroyed on exit from the function
}

Must I delete ss array of structure at the end of main?

Yes, but it is an array, so must be deleted as an array:

delete [] ss;
       ^^

But again, there's no reason for this to be dynamically allocated:

aa ss[3]; // automatically destroyed on exit from the program

Must I create destruct or to structure ss that frees *b memory?

If you really want to use a raw pointer to manage the dynamic array, then yes. You will also need to think about a copy constructor and copy-assignment operator (per the Rule of Three ) to make the class safe to use. Alternatively, use a smart pointer or container to manage the memory for you:

struct aa 
{
    int a;
    std::vector<char> b ;

    aa() : a(0), b(255) {}
} ;

What about classes is it the same logic?

Yes, the rule is always the same: anything created with new must be destroyed with delete . Managing objects is much easier if you avoid dynamic allocation where possible, and use smart pointers, containers and other RAII classes when you really do need it.

Answer 2

If you use new , you must use delete to avoid a memory leak. If you declare a variable on stack, it will be freed automatically when you exit the scope.

void something();
{
    aa b = new aa();
    // Do something
    delete b; // You must use delete
}

void something();
{
    aa b();
    // Do something
    // You don't have to use delete
}

In your specific case , it is not strictly necessary to use delete , because the program is going to terminate anyway and all the assigned memory will be freed by the OS.

It is still a good practice to do so, so as to be consistent (though there are some specific cases where you DON'T want to do this because freeing a lot of complex objects can take some time thus slowing down the program termination).

Anyhow, using naked pointers is not such a good idea in C++ since there are many so-called smart pointers (such as shared_ptr and unique_ptr ) that take care of calling the destructor and freeing the memory after they run out of scope.

PS: In your code, you will have a memory leak, because the aa structure uses new inside the constructor and does not call delete in destructor.

Answer 3

YES

Please, please, please free your memory. I won't go into detail here, but take a look at this answer: Can a memory block allocated by using operator new/malloc persist beyond end of program execution?

Answer 4

Rule of thumb in C/C++ :

• Allocated with new ? free the memory with delete
• Allocated with malloc , calloc , realloc ? free the memory with free(void*)