Re: Automatic and Dynamic Storage
On May 15, 1:22 pm, V <vdu...@gmail.com> wrote:
....
Thank you for your clear answer. I'm still surprised that B::a is
automatically (implicitly) destroyed, even if it's placed into the
free store: I'm accustomed to think that anything stored into the free
store must be removed with delete/delete[] :)
You are right ... BUT B::a is not allocated on the free store all by
itself but as a part of B. Simple example (ignoring encapsulation and
other good stuff):
class Cls
{
public:
int count_;
int index_;
};
When you allocate an instance of Cls with operator new, you don't
have to allocate storage for count_ and index_ manually. In fact
the layout of Cls in memory is most probably two integers one after
the other (modulo alignment required by a particular cpu). So when
you say something like:
Cls* ptr( new Cls );
this results in something like (in pseudo-C):
ptr = ( Cls* )malloc( sizeof( Cls )); // of course it doesn't have to
be malloc
Cls::Cls( ptr ); // inserted call to synthesized constructor, would be
optimized away
// as "trivial" in this case
Here sizeof( Cls ) >= 2*sizeof( int ).
Then when you access member variables:
ptr->count_ = 0;
ptr->index = 12;
that translates into (approximately):
*( int* )(( char* )ptr + offsetof( Cls, count_ )) = 0;
*( int* )(( char* )ptr + offsetof( Cls, index_ )) = 12;
And when you finally go to deallocate the instance:
delete ptr;
That gets transformed into (aprox.):
Cls::~Cls( ptr ); // inserted call to (again trivial) destructor
free( ptr ); // again memory management doesn't have to be based on
malloc/free
The _automatic_ instances of Cls, i.e. variables of type Cls local
to some [member] function or a code block get pretty much the same
treatment except instead of calls to memory allocation/release
functions
space for them is usually reserved on the stack. With a trivial class
as above, compiler might just optimize away that too and keep member
variables in the cpu registers.
This is for illustration only and is not based on any particular
compiler.
All this gets more interesting with virtual functions, multiple
and virtual inheritance, etc. This is why I mentioned Lippman's book.
Did you know other sources (websites, books, section of the
standard, ...) from which I can obtain more informations about this
subject?
You have previously mentioned Lippman's "Inside the C++ Object Model",
but I see that it is 12 years old. It's still a good book?
That's still an excellent read - gives you some (though probably not
most up to date) understanding of inner workings of a C++ compiler and
the original ideas behind the language. Another book that I would
recommend is "Ruminations on C++" by Andrew Koenig and Barbara Moo.
Both of these are probably not for beginners, but a "must read"
material.
Hope this helps.
--
Nikolai
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]