Customer Reviews

Effective C++: 50 Specific Ways to Improve Your Programs and Design (2nd Edition) (Addison-Wesley Professional Computing)

5 star:		(81)
4 star:		(8)
3 star:		(2)
2 star:		(0)
1 star:		(1)

 

 

From beginning to end this book is packed with information that is IMMEDIATELY applicable. For example "Always declare destructors to be virtual" otherwise you may end leaking memory when subclasses are deleted. Or hiding the implementation of a class in an "Impl" that your class just passes through to. That way, if the implementation changes, the clients of the class are protected from recompilation.

Beyond the wealth of just downright practical information the oragization is fabulous. The only other technical book that has organization as good as this one is "Design Patterns" There are several chapters such as "Memory Management" that have "Items" and each item has a few paragraphs describing the motivation for why you should believe Meyers with examples to prove it. Then there are solid examples that show the implemantation of an example usage.

My company gave this book out with "Design Patterns" to EVERY developer in the company, and it was probably the smartest thing I've ever seen a company do.

Read it and learn a TON.

An absolutely terrific book focusing on basic C++ and object-oriented programming techniques. A crucial book for anyone new to C++ to read.

While _Effective C++_ is an important and fundamental part of any C++ programmer's library, truly advanced C++ engineers are likely familiar with most or all of the techniques presented here (dynamic allocation, constructors, basic coding style, etc.). Scott Meyers' second book, _More Effective C++_, covers significantly more advanced techniques which the experienced programmer may not have encountered in everyday code and which may be more instructive. It is only in deference to that book that I have given this one 4 (or, if I could, 4.9) stars.

There seems to be a whole slew of books out titled "<adjective> C++" and I suspect this was the first. If not, it should at least be the model.

The book is set up as 50 small chapters describing particular principles. Each is useful and clearly-presented in a manner that is not daunting.

I've read many C++ books, including many of the <adjective> books and I have no problem proclaiming this as simply the best. Other books may cover more ground (Stroustrup's books, for example), others may be more current and others may be more advanced (I've recently been humbled by "Exceptional C++") but I think "Effective C++" is the most useful.

If you're looking for a book to teach you the language, or if you're just learning the language, I'd say wait a little while before reading this book. If you've been writing code and haven't read this book, go for it. Although it's dated (pre-standard library) the concepts it covers are important ones that have not disappeared after standardization.

I hope that when I write my book, "Extraterrestrial C++," I can do half as good a job.

This book contains a list of no less that 50 pratical tips for the C++ programmer. These tips are basically just common sense, and the advanced C++ will already know the vast majority of them (he should buy the book anyway just for the ones he doesn't know). The beginning C++ programmer will feel overwhelmed by this book so for those it cannot be recommended. It is mainly targeted the intermediate C++ programmer that have learned the language but have not found experience in using it.

My favorite one is the one that tell how to reduce dependencies among files. It is common sense, but I just hadn't thought about it until I read this book. As a result the build time for our company project went down significantly. That was literally *very* valuable advice.

The book is extremely well written (even somewhat entertaining!) and both short and consise. I really liked this book, and I recommend any serious C++ programmer to buy it....

After having spent several years programming in C and dabbling in C++ here and there, I felt I had a pretty good grasp of C++. However, after finishing this book, I found myself boldly corrected.

The book covers answers to questions that I hadn't even realized that I should be asking. Reading C++ reference books teach you the syntax but completely hide the level of complexity as to what's really going on behind the scenes. To use a quote from the book "Saying what you mean is only half the battle. The flip side of the coin is understanding what you're saying, and it's just as important."

What happens if you override a non-virtual function? What does private inheritance do and why would you want to use it? What code will the compiler automatically generate for you if you fail to do so yourself? When should you use references to objects versus the objects themselves? The list goes on and on. It covers the topics of Memory Management, Constructors & Destructors, Operator Overloading, Design & Decleration of Classes and Functions, Implementation, Inheritance and Object Oriented Design. But, most importantly, for every answer - there is a logical explanation of *why* things are the way that they are.

Reading this book gave me a new appreciation for the complexity behind C++. It is not a book on syntax, so this should not be the 1st C++ book that you read -- but it should *definitely* be the 2nd!

Meyers has an excellent, and amusing(!) writing style which makes the book much easier to read then you'd expect from a technical book. The concepts might still make your brain hurt if you're new to C++, but keep at it -- before you write any C++ code you need to understand what's going on behind the scenes and this book will show it to you.

The subtitle of the book '50 specific ways to improve your programs and designs' is a pretty good summary of what this book is all about. It's is very well structured, the table of contents summarizes each point in one sentence, together with the extensive and complete index it's very easy to use as a quick reference. But thanks to Meyers clear and oftentimes amusing style of writing it's also a joy to read from cover to cover. You'd be a fool if you didn't anyways, since you'd miss out on lots of excellent source code examples and very well stated arguments for each of the tips. Some of the tips may seem obvious, like item 5 which reads: "use the same form in corresponding uses of new and delete". Others like item 1: "prefer const and inline to #define" might seem pretty alien to seasoned C programmers/preprocessor magicians or performance freaks. After reading the author's arguments for his points you'll have a hard time defending your position, though (in the unlikely case that you are still not convinced, that is). Meyers does explicitly encourage critical thinking over blind following of the rules though, and in the tradition of Donald Knuth has promised a reward for every error discovered in his work.
How universally accepted these tips have become you can guess form reading the C++ newsgroups or noticing that they have been fully integrated into automatic source checking tools such as gimpel's PC-Lint. Professional programmers should know these 50 gems by heart - buy the book!

I consider this to be *the* most important C++ book for the practicing developer. It's not a tutorial, but once you have learned the basic C++ syntax, this book should be on the top of your list. If you are a beginning or intermediate C++ programmer, you need this book. If you are already an advanced C++ programmer then many or most of these techniques may already be familiar to you, but you owe it to yourself (and whomever cuts your paycheck) to be sure. I also find myself consulting this book frequently as a reference. After you've read this one, get the sequel, "More Effective C++" for some more advanced techniques. These two books belong on every C++ developer's bookshelf. Period.

I'm not going to repeat the book contents. You can find it here or on the publisher's website. Others also commented on it more or less. I'd just like to make a few points that may have an influence on your decision to read or buy the book.

I agree with the opinion of lots of people who already posted their reviews here that this book is an essential read for profesional C++ programmers. If a professional does not do things more or less in the fashion described in the book, he/she isn't doing them right. With increasing experience over the years, a professional would naturally approach the right ways, but the book collects distilled wisdom in one place and would accelarate one's accetance and practice of them. Still I believe there are professionals who have not read the book, which is a shame to themselves and bad for the reputation of software products.

Another point I want to make is that the book deserves multiple readings. In other words, it's not a book you read once and then throw away (or sell here :-), which is indeed the case for more than 99.999% of the books ever published. It makes a perfect companion as one develops his/her career engineering software systems/applications in C++ & its associated libraries/tools.

One thing I noticed when reading it is that the items about memory management appear near the beginning of the book. Compared to most other items later on, they are less quick to understand. So you may want keep that in mind so as not to be discouraged. I believe you may read the 50 items in the book in a random order.

To adequately appreciate the book, it's likely necessary for one to have at least read a couple of C++ books (such as Accelarated C++ by Koenig & Moo and C++ Primer by Lippman) and at least a few months of experience on a job coding in C++.

All in all, this book is strongly recommended and a must read for professionals.

I think this is the first book a C++ programmer should read after reading a C++ syntax book. Every item is useful. This book is not as complete as <<C++ faq>>, but more concise.

Some items need to be updated, however. For example, Item 28, "Use structs to partition the global namespace", you can use namespace now (it is also mentioned at the bottom of the page).

I think the items can be better organized, for example Item 23 "Don't try to return a reference when you must return an object" and item 31 "Never return a reference to a local object or a dereferenced pointer initialized by new within the function" can be combined to one, in item 23, "object" means a local object, it is better to say it explicitely. Also similar items are better to put closer, maybe it is difficult, since many items relate to each other.

This is a book for intermediary level, it lacks some more advanced issues as exception, namespace, etc. Exceptions are discussed in its following book <<More effective C++>>, however, I would like to mention the discussion in <<more effective C++>> is not complete neither, up to now, I can find the most advanced discussions about exception in <<Exceptional C++>> by Herb Sutter, which is the book a advanced programmer should read. Discussion about namespace can also be found in this book.

Overall, I think <<Effective C++>> is a good book for a serious programmer to start his/her c++ career, he/she can read <<More effective C++>> and <<Exceptional C++>> (maybe also <<Advanced C++ styles and idioms>> and <<C++ for real programmers>>) for more advanced topics/discussions, and <<C++ faq>> for a complete review of C++.

I regret not being able to find a book for comparison of C++ and java, two most used programming languages. These two languages are similar in syntax, but have different features. For example, auto_ptr exists only for C++ and delegation exists only for java, The differences of languages affect the design and implementation, <<Design patterns>> discussed the design patterns with C++ and Smalltalk, however, Java is more popular than Smalltalk now and I hope to find a book which discusses the C++ and Java together. A more complete discussion of C++ advanced features is also needed, Herb Sutter is working on this.

First time i read Effective C++ was while i was in college and had gone through some programming courses. Soon after, i wasn't just satisfied with knowing what to do while porgramming, but why to do it, and how what i did affected/utilized on memory, run-time, compile time. Needless to say it was an easy but detailed read, where more is learned the more you revisit the text. Many people just getting into programming with C++ aren't exactly sure when to use pointers or references, how to write efficient constructors in classes, when to make a function public, private or friend, when to correctly use inheritance or abstract classes, things like that. Effective c++ clarifies alot of these things.

One thing is for sure - for each item you read, you notice your programming errors and/or strong points, and generally move on to become a better C++ programmer. It doesn't teach you how to program (if a novice), it makes you better understand what you know or have an idea of if you've already been doing some (or alot) coding. It is also broken into sections, so you can jump right into where you think you need more clarification. Highly recommended.