CODEWITHSUNDEEP
c++c
vico
vico

Reputation: 18171

dealing with C++/C structures memory freeing

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?

Upvotes: 2

Views: 170

Answers (4)

cybertextron
cybertextron

Reputation: 10961

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*)

Upvotes: 0

Linuxios
Linuxios

Reputation: 35783

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?

Upvotes: 0

user267885
user267885

Reputation:

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.

Upvotes: 5

Mike Seymour
Mike Seymour

Reputation: 254431

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.

Upvotes: 8

Related Questions