Re: noob question - destructors - freeing memory...
On Sat, 31 Dec 2011 02:43:28 +0100, someone <newsboost@gmail.com>
wrote:
Hi
See this (stolen from the internet):
----------------------------------------
#include <iostream>
using namespace std;
class Base
{
public:
Base(){ cout<<"Constructing Base"<<endl;}
// this is a destructor:
virtual ~Base(){ cout<<"Destroying Base"<<endl;}
};
class Derive: public Base
{
public:
Derive(){ cout<<"Constructing Derive"<<endl;}
~Derive(){ cout<<"Destroying Derive"<<endl;}
};
int main()
{
Base *basePtr = new Derive();
// delete basePtr; // <<<======== !! ! ! ! ! NB !!
return 0;
}
----------------------------------------
See middle line of main():
delete basePtr; // <<<======== !! ! ! ! ! NB !!
If I enable (uncomment) middle line, I get:
Constructing Base
Constructing Derive
Destroying Derive
Destroying Base
If I disable (comment out) middle line, I get:
Constructing Base
Constructing Derive
========
This, I didn't quite expect, because I thought that at the end of
the
program, all destructors where guaranteed to be called...
In my case, I have a longer program and I allocate memory with one
of my
constructors, hence it is crucial to free the memory, but since the
virtual destructor is never called, I never free the memory...
In addition: In my full program (not shown here), I instantiate my
new
object like:
int main(...)
{
...
Derive d1();
return 0; // or exit(1); if something went wrong somewhere
}
Is it required that I do, like in the example above:
int main(...)
{
...
Base *myPtr = new Derive();
delete myPtr;
return 0; // or exit(1); if something went wrong somewhere
}
???????
But what if my code does an exit(1) somewhere, which it could do at
least a dozens of times, in different parts of the program?
Please advice, thank you!
A statically constructed object will be destroyed when the scope is
left.
e.g destructors will be called in:
int main()
{
Derived d;
return 0;
}
A dynamically constructed object (created using new) is destroyed
when delete is called.
e.g destructors called in this:
int main()
{
Base * b = new Derived();
delete b;
return 0;
}
but not this:
int main()
{
Base * b = new Derived();
return 0;
}
When exit(int) is called, the program is terminated *without
unwinding the stack* so no destructors are called.
When a execption is thrown and not caught, the program is terminated
*with stack unwinding*, so static objects are destroyed.
Note:
int main()
{
Base * b = new Derived();
throw std::exception();
delete b;
return 0;
}
In the above, the delete expression is never reached, so destructors
are not called.
If this is an issue, a smart pointer (boost::shared_ptr,
boost::scoped_ptr, etc:) should be used.