The implementation of C++'s Destructor efficientlyWhen writting a destructor it is important to understand why and what before just writting it.
*a structure and pointer recipe are on the way to explain anything thing complex here.
The point or rather to not point. A destructor removes pointers in the case of manually watching your memory leak. This method is automaticlally called whenever an object loses scope.
Scope - part of the code (eg, method, class, etc) in which a variable or parameter can be accessed.
thus, it takes care of all local and dynamic variables for us, preventing memory leak if it is written properly.
*The example will be written as if it were inside a class which has a structure within it implementing a linked list by the pointer:
Next* next;
which of course the struct is called Next.
Destructor Syntax:
-A destructor never takes any parameters, it's only parameter is the implied one accesable by this.
-always starts with a ~, tild or tilda as it in known
now within a structure iplementing a linked list this becomes the most crucial part of your code. The structure not only has things pointing to it, but it is pointing to other objects of it's own type. These all need to be handled dynamically, but how?
*I said earlier that C++ will call this for every object, but we have no way to be sure that it will be efficient and call them in the reverse order they are pointing in! if we were to delete the lead pointer only it is possible that C++ would accept this as a completed destruction, which is not true!!
As long as the other pointers and objects are linked, the memory is not freed and we have memory leak.
So we need to delete all pointers below the current this object to insure a proper destruciton. If all goes well each object will only destroy one pointer, but we cannot be sure of this.
This will require a loop and a temp variable (which we will also destroy at the end of the destructor)
Complete Linked List Destructor:
*within the Next structure, so it gets the title of it's class or struct.
~Next(){
Next* n = this->next;
Next* nn = NULL;
while(n){
nn = n->next;
delete n;
n = nn;
}
nn = NULL;
n = NULL;
}-This loop is based on n which is true as long as n is not NULL (eg there is another Next object in the linked list)
this code itterates through the linked list objects and deletes the pointers 1 by 1, once finished with all pointers below itself setting the temporary variables to NULL, which will allow the GC or Garbage Collector to destroy them.
This example is meant to improve your knowledge of memory leak, the less leakage there is in your own programs the better, because we all know that Operating Systems are not leak free, so the more help we can give them, the better!!
