|
|
Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition) (Addison-Wesley Professional Computing Series) (Paperback)
by Scott Meyers
| Category:
C++ language, Software development, IT, Technology |
| Market price: ¥ 508.00
MSL price:
¥ 468.00
[ Shop incentives ]
|
| Stock:
Pre-order item, lead time 3-7 weeks upon payment [ COD term does not apply to pre-order items ] |
MSL rating:
 Good for Gifts |
| MSL Pointer Review:
Focusing on productive and practical techniques and offering clearly well thought out advice, this classic on C++ language has always been worth your money and time. |
| If you want us to help you with the right titles you're looking for, or to make reading recommendations based on your needs, please contact our consultants. |
Detail |
Author |
Description |
Excerpt |
Reviews |
|
|
|
Author: Scott Meyers
Publisher: Addison-Wesley Professional
Pub. in: May, 2005
ISBN: 0321334876
Pages: 320
Measurements: 9.5 x 7.2 x 0.2 inches
Origin of product: USA
Order code: BA00540
Other information: 3 edition
|
|
Rate this product:
|
|
- MSL Picks -
Effective C++: 55 Specific Ways to Improve Your Programs and Designs recently came out in its 3rd edition. The first came out in 1991, making this line of book revisions positively ancient in high tech terms. But you should consider the elapsed 14 years an investment in wisdom, not obsolescence. Unlike the 2nd edition, this is a complete rewrite from the ground up. More than that, Scott Meyers begins from first principles, reevaluating what topics are most important to the programmers of 2005.
This was a very strategic and insightful move. Not only has the language evolved over that time, but the audience has too. In the first edition, the likely readers were coming from languages like C. Now the likely readers cross over from some other object-orient language, like Java or C#. Keep in mind that the author focuses strictly on standard C++; he does not address anything that is platform-specific.
Like its predecessors, the items can be read stand-alone, and he does cross reference related items. The 55 items are grouped into the following chapters:
Chapter 1: Accustoming Yourself to C++
Chapter 2: Constructors, Destructors, and Assignment Operators
Chapter 3: Resource Management
Chapter 4: Designs and Declarations
Chapter 5: Inheritance
Chapter 6: Implementations and Object-Oriented Design
Chapter 7: Templates and Generic Programming
Chapter 8: Customizing new and delete
Chapter 9: Miscellany
I would hate to have to learn the lessons in this book by hard experience. It would be costly in time and unfortunately might even cover more than one employment span.
Most decisions that are undertaken by developers should consider ROI (return on investment), which always is measured in terms of time. For developers considering professional education material like this, the measure should be in terms of how many mistakes could be avoided before the book pays for itself. In this case, the ROI is probably less than 2 defects.
If your shelfspace for C++ books has only a few slots, this book should be in your "must haves."
(From quoting Allen Clarke, USA)
Target readers:
C++ programmers, Computer Science majors, People interested in learning C++, and University lecturers.
|
|
- Better with -
Better with
The C++ Standard Library: A Tutorial and Reference
:
|
|
Customers who bought this product also bought:
 |
Peopleware : Productive Projects and Teams, 2nd Ed. (Paperback)
by Tom Demarco, Timothy Lister
The book made a clear and compelling augument that the human factor, not technology, makes or breaks a software development effort. |
 |
The Pragmatic Programmer: From Journeyman to Master (Paperback)
by Andrew Hunt, David Thomas
A classic reading on programming ranking with Code Complete and The Mythtical Man-Month. |
 |
The C++ Standard Library: A Tutorial and Reference (Hardcover)
by Nicolai M. Josuttis
Extremely well organized and well written, this book is an excellent reference to advanced C++ features. |
 |
The C++ Programming Language (Special 3rd Edition) (Hardcover)
by Bjarne Stroustrup
Presents the complete C++ language and a discussion of design and software development issues. Provides an emphasis on tutorial aspects aimed at the serious programmer. |
 |
Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series) (Hardcover)
by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
A modern classic in the literature of object-oriented development, it's a book of design patterns that describe simple and elegant solutions to specific problems in object-oriented software design. |
|
|
Scott Meyers is one of the world's foremost authorities on C++, providing training and consulting services to clients worldwide. He is the author of the best-selling Effective C++ series of books (Effective C++, More Effective C++, and Effective STL) and of the innovative Effective C++ CD. He is consulting editor for Addison Wesley's Effective Software Development Series and serves on the Advisory Board for The C++ Source (http://www.artima.com/cppsource). He holds a Ph.D. in Computer Science from Brown University. His web site is http://www.aristeia.com.
|
|
From the Publisher:
The first two editions of Effective C++ were embraced by hundreds of thousands of programmers worldwide. The reason is clear: Scott Meyers’ practical approach to C++ describes the rules of thumb used by the experts - the things they almost always do or almost always avoid doing - to produce clear, correct, efficient code.
The book is organized around 55 specific guidelines, each of which describes a way to write better C++. Each is backed by concrete examples. For this third edition, more than half the content is new, including added chapters on managing resources and using templates. Topics from the second edition have been extensively revised to reflect modern design considerations, including exceptions, design patterns, and multithreading.
Important features of Effective C++ include:
* Expert guidance on the design of effective classes, functions, templates, and inheritance hierarchies.
* Applications of new "TR1" standard library functionality, along with comparisons to existing standard library components.
* Insights into differences between C++ and other languages (e.g., Java, C#, C) that help developers from those languages assimilate "the C++ way" of doing things.
|
I wrote the original edition of Effective C++ in 1991. When the time came for a second edition in 1997, I updated the material in important ways, but, because I didn't want to confuse readers familiar with the first edition, I did my best to retain the existing structure: 48 of the original 50 Item titles remained essentially unchanged. If the book were a house, the second edition was the equivalent of freshening things up by replacing carpets, paint, and light fixtures.
For the third edition, I tore the place down to the studs. (There were times I wished I'd gone all the way to the foundation.) The world of C++ has undergone enormous change since 1991, and the goal of this book - to identify the most important C++ programming guidelines in a small, readable package - was no longer served by the Items I'd established nearly 15 years earlier. In 1991, it was reasonable to assume that C++ programmers came from a C background. Now, programmers moving to C++ are just as likely to come from Java or C#. In 1991, inheritance and object-oriented programming were new to most programmers. Now they're well-established concepts, and exceptions, templates, and generic programming are the areas where people need more guidance. In 1991, nobody had heard of design patterns. Now it's hard to discuss software systems without referring to them. In 1991, work had just begun on a formal standard for C++. Now that standard is eight years old, and work has begun on the next version.
To address these changes, I wiped the slate as clean as I could and asked myself, "What are the most important pieces of advice for practicing C++ programmers in 2005?" The result is the set of Items in this new edition. The book has new chapters on resource management and on program- ming with templates. In fact, template concerns are woven throughout the text, because they affect almost everything in C++. The book also includes new material on programming in the presence of exceptions, on applying design patterns, and on using the new TR1 library facilities. (TR1 is described in Item54.) It acknowledges that techniques and approaches that work well in single-threaded systems may not be appropriate in multithreaded systems. Well over half the material in the book is new. However, most of the fundamental information in the second edition continues to be important, so I found a way to retain it in one form or another. (You’ll find a mapping between the second and third edition Items in Appendix B.)
I've worked hard to make this book as good as I can, but I have no illusions that it's perfect. If you feel that some of the Items in this book are inappropriate as general advice; that there is a better way to accomplish a task examined in the book; or that one or more of the technical discussions is unclear, incomplete, or misleading, please tell me. If you find an error of any kind - technical, grammatical, typographical, whatever - please tell me that, too. I'll gladly add to the acknowledge- ments in later printings the name of the first person to bring each problem to my attention.
Even with the number of Items expanded to 55, the set of guidelines in this book is far from exhaustive. But coming up with good rules - ones that apply to almost all applications almost all the time - is harder than it might seem. If you have suggestions for additional guidelines, I would be delighted to hear about them.
I maintain a list of changes to this book since its first printing, including bug fixes, clarifications, and technical updates. The list is available at the Effective C++ Errata web page, http://aristeia.com/BookErrata/ ec++3e-errata.html. If you'd like to be notified when I update the list, I encourage you to join my mailing list. I use it to make announcements likely to interest people who follow my professional work. For details, consult http://aristeia.com/MailingList/.
Scott Douglas Meyers
Stafford, Oregon
April 2005
|
This book is a direct outgrowth of my experiences teaching C++ to professional programmers through the Institute for Advanced Professional Studies. I found that most students, after a week of intensive instruction, felt comfortable with the basic constructs of the language, but were less sanguine about their ability to put the constructs together in an effective manner. Thus began my attempt to formulate short, specific, easy-to- remember guidelines for effective software development in C++: a summary of the things that experienced C++ programmers either almost always do or almost always avoid.
As a computer scientist, I was originally interested in rules that could be checked by a machine. To that end, I outlined a program to examine C++ software for constructs that were "almost always wrong." Currently under development, this checking program has become known as lint++. However, it quickly became apparent that the great majority of the guidelines used by good C++ programmers were too difficult to formalize, or had too many important exceptions, to be blindly enforced by a lint++-like program.
That led me to the notion of something less precise than a computer program but still more focused and to-the-point than a general C++ textbook. The result you now hold in your hands: a book containing 50 specific suggestions on how to improve your C++ programs and designs.
In this book you'll find advice on what you should do, and why, and what you should not do, and why not. Fundamentally, of course, the whys are much more important than the whats, but from a purely pragmatic point of view, it is much more convenient to have a list of guidelines in front of you than it is to memorize a textbook or two. Unlike most books on C++, my presentation here is not organized around particular language features. That is, I don't talk about constructors in one place, aboutvirtual functions in another, about inheritance in a third, etc. Instead, each explanation is tightly coupled to the specific guideline it accompanies, and my coverage of the various aspects of a particular feature is typically dispersed throughout the book.
The advantage of this approach is that it better reflects the complexity of the software systems for which C++ is often chosen, systems in which the understanding of individual language features is not enough. For example, experienced C++ developers know that understanding inline functions and understanding virtual destructors does not necessarily mean that you understand inline virtual destructors. Such battle-scarred developers recognize that comprehending the interactions between the features in C++ is of the greatest possible importance in using the language effectively. The organization of this book reflects that fundamental truth.
The disadvantage of my approach is that you may have to look in more than one place to discover everything I have to say about a particular construct in C++. To minimize the inconvenience inherent in this approach, I have sprinkled cross-references liberally throughout the text, and a comprehensive index is provided at the end of the book.
The set of guidelines in this book is far from exhaustive, but coming up with good rules - ones that are applicable to almost all applications almost all the time - is harder than it looks. Perhaps you know of additional guidelines, of more ways in which to program effectively in C++. If so, I would be delighted to hear about them.
On the other hand, you may feel that some of the items in this book are inappropriate as general advice; that there is a better way to accomplish a task examined in the book; or that one or more of the technical discussions is unclear, incomplete, or misleading. I encourage you to let me know about these things, too.
Donald Knuth has a long history of offering a small reward for people who notify him of errors in his books. The quest for a perfect book is laudable in any case, but in view of the number of bug-ridden C++ books that have been rushed to market, I feel especially strongly compelled to follow Knuth's example. Therefore, for each error in this book that is reported to me - be it technical, grammatical, typographical, or otherwise - I will, in future printings, gladly acknowledge the first person to report that error.
Send your suggested guidelines, your comments, your criticisms, and - sigh - your bug reports to:
Scott Meyersc/o Editor-in-Chief, Corporate and Professional Publishing Addison-Wesley Publishing Company 1 Jacob Way Reading, MA 01867 U. S. A.
Alternatively, you may send electronic mail to johnw@aw.com.
I maintain a list of changes to this book since its first printing, including bug-fixes, clarifications, and technical updates. This list is available via anonymous FTP from the Internet site ftp.aw.com in the directory cp/ec++. If you would like a copy of this file, but you lack access to the Internet, please send a request to one of the addresses above, and I will see that the list is sent to you.
Scott Douglas Meyers Providence, RI November 1991
|
|
| View all 15 comments |
Steve Schirripa (Software Engineer, Google) (MSL quote), USA
<2007-01-11 00:00>
Every C++ professional needs a copy of Effective C++. It is an absolute must-read for anyone thinking of doing serious C++ development. If you’ve never read Effective C++ and you think you know everything about C++, think again. |
Gerhard Kreuzer (Research and Development Engineer, Siemens AG) (MSL quote), USA
<2007-01-11 00:00>
C++ and the C++ community have grown up in the last fifteen years, and the third edition of Effective C++ reflects this. The clear and precise style of the book is evidence of Scott’s deep insight and distinctive ability to impart knowledge. |
Lan Zhongdan (MSL quote), USA
<2007-01-11 00:00>
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 discusses 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. |
An American reader (MSL quote), USA
<2007-01-11 00:00>
This is one of the most useful and knowledgeable books on the pitfalls of developing in C++ that I have ever read. This book is not for the beginner developer since most of the items covered here refer to advanced topics such as customer memory management and C++ object oriented best practices. I'd recommend reading some basic C++ syntax based books such as "C++ How to Program" or "C++ from the Ground Up" and then reading some OOAD conceptual books such as The Object-Oriented Approach: Concepts, Systems Development, and Modeling with UML or The Rational Unified Process Made Easy: A Practitioner's Guide to Rational Unified Process to get introduced to concepts. This book goes great with its follow-up book "More Effective C++." |
View all 15 comments |
|
|
|
|
