I am planning on purchasing this book to learn more about C++ programming with regards to fast code. However, the book was published in 1999 and I am worried most of it may be irrelevant now due to optimizations that compilers perform.
Could anyone please advise?
edit:
Found this book too, albeit also rather old:
http://www.amazon.com/Optimizing-C-Steve-Heller/dp/0139774300
The book touches on subjects like temporaries, constructors/destructors, the overhead of virtual functions, benefits and pitfalls of inlining, memory pooling, caching, CPU cache effects, registers etc.
Many of those techniques are still valid - even if the language and compilers will be providing a lot more help now than in 1999, and the hardware you are running it on is different.
It helps to know what has changed since then, but I'd still recommend reading the book if you don't know where to start, simply because I do not know of anything more recent that covers these kinds of topics specifically.
I think it's not necessarily irrelevant just because it's old. For example, C++ lets you put a constructor invocation anywhere an expression can occur. That means the compiler isn't allowed to move your constructor invocations to make the runtime code more efficient, because there are rules about what is guaranteed to have happened between sequence points in a C++ program. OK, it's just one example, and the rule is simple (lazy instantiation means not running a constructor until you need to), but it means there are compiler-independent techniques to improve code efficiency.
More relevantly, there are simply new techniques and new language features- especially rvalue references, and compiler optimizations are much stronger than they used to be with features like cross-TU inlining, RVO, and NRVO. I would look for a newer book.
No, the book is not irrelevant at all. It's somewhat old school in places, but a lot of coding companies are that way too. Further, most of what it teaches will always be a part of C++.
That said, I personally think that Sutter's books are better. They don't cover the same material though, so if what's in Meyers's books is new to you...get both.
The compiler tries to optimize what it can, but you have to optimize what you can, and the book should help you with that (somewhat).
If you are going to write significantly large programs, it is very easy to put in slowness, without meaning to, that the compiler could never undo.
My favorite example is here. It consists of a realistically large program that was optimized. It was made faster by 50%. But that did not mean it could not be further optimized. The second attempt knocked out a healthy percent of what was left. But that still wasn't the end. This was done six times, and guess what the overall speedup ratio was?
730 times.
Toward the end, the optimizations being done were, out of the original program's time, so small as to be insignificant. But after a series of other problems were removed, small problems become larger, percentage-wise, so they become worth removing. The individual speedup ratio that you get with each optimization may not be too surprising, but they multiply together like compound interest.
That's how you can really optimize code. By all means, use the book, but don't limit yourself to what it says.
