This book is well recommended by people and the way I found about this book is from the old article by Don Box because I was reading 'Essential Com'. Hence, the book contains very unique material that describes the internals of C++. For instance, the book mainly deals with what exactly occurs when we use copy constructor and when/how we should use it. One important lesson I think I have learned from this book is not so much of technical details but the attitude to understand the internals of C++ to write better programs. The book describes how things are actually built and run when we write our C++ code. If we are not careful, it is very easy to create a program that would not perform very well. Of course, this book is pretty old so some stuff might not be appropriate any more but it still does give us very good insight into C++. One more thing I would like to mention if you want to read this book is that the book has some number of typos and wrong diagrams so be prepare for that because I spent hours to figure out the code but it turned out that there was typo. I tried to find errata site for this book but I could not find on the web so please take note of that.
With that then, I would like to illustrate a couple of things from the chapter 2 of the book.
First, constructor. The author mentions that programmer new to C++ often have two common misunderstandings:
- That a default constructor is synthesized for every class that does not define one.
- That the compiler-synthesized default constructor provides explicit default initializers for each data member declared within the class.
Compiler only generates a default constructor under certain circumstances and it is the programmer's job to explicitly initialize data members if needed. For instance, compiler would generate default constructor if the class contains data members that has default constructor and hence it can call default constructor for that member. Compiler also generate default constructor if the class either declares (or inherits) a virtual function so that it takes care of virtual function table and pointers hold in the table. So lessons we can learn from this is that we need to take care of initialization if necessary and not rely on default constructor. In addition, a great deal happens when we define 'T object;' so keep that in mind.
Second, temporary objects. Understand that temporary objects are created at times. For example, look at the following code.
X bar()
{
X xx;
// Process xx...
return xx;
}
Here, return value is copy constructed from its local object xx. So compiler would generate the code as follows.
void
bar (X& __result )
{
X xx;
// compiler generated invocation
// of default constructor
xx.X::X();
// Process xx...
// compiler generated invocation
// of copy constructor
__result.X::X( xx );
return;
}
Then, the author shows two ways to optimize the code above and the following is what can be done by compiler.
void
bar (X& __result )
{
// compiler generated invocation
// of copy constructor
__result.X::X();
// Process in __result directly
return;
}
Although this looks great but there could be issues with the code above. For instance, if we have instrumented the code to do something with the destructor of local objects, then now we do not have that option since we removed the destructor. So we need to be mindful of our code and what is actually taking place.
The book has plenty of points and illustrations of internals of C++ so maybe I will try to summarize the important points in my blog again to remind myself in the future but basically as you can see, if you are interested in these kind of insight, give it a try. After all, the book is not so thick. ;-)
