Effective C++ Digital Collection: 140 Ways to Improve Your Programming

Scott Meyers’s seminal C++ books– Effective C++ , More Effective C++ , and Effective STL –have been immensely helpful to hundreds of thousands of C++ programmers. All three are finally available together in this eBook collection.

Effective C++ has been embraced by hundreds of thousands of programmers worldwide. The reason is clear: Scott Meyers’s practical approach to C++ describes the rules of thumb used by the experts 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.

In More Effective C++, Meyers presents 35 ways to improve your programs and designs. Drawing on years of experience, Meyers explains how to write software that is more effective: more efficient, more robust, more consistent, more portable, and more reusable. In short, how to write C++ software that’s just plain better.

In Effective STL, Meyers goes beyond describing what’s in the STL to show you how to use it. Each of the book’s 50 guidelines is backed by Meyers’s legendary analysis and incisive examples, so you’ll learn not only what to do, but also when to do it–and why.

Together in this collection, these books include the following important features:

• 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.
• Proven methods for improving program efficiency, including incisive examinations of the time/space costs of C++ language features
• Comprehensive descriptions of advanced techniques used by C++ experts, including placement new, virtual constructors, smart pointers, reference counting, proxy classes, and double-dispatching
• Examples of the profound impact of exception handling on the structure and behavior of C++ classes and functions
• Practical treatments of new language features, including bool, mutable, explicit, namespaces, member templates, the Standard Template Library, and more. If your compilers don’t yet support these features, Meyers shows you how to get the job done without them.
• Advice on choosing among standard STL containers (like vector and list), nonstandard STL containers (like hash_set and hash_map), and non-STL containers (like bitset).
• Techniques to maximize the efficiency of the STL and the programs that use it.
• Insights into the behavior of iterators, function objects, and allocators, including things you should not do.
• Guidance for the proper use of algorithms and member functions whose names are the same (e.g., find), but whose actions differ in subtle (but important) ways.
• Discussions of potential portability problems, including straightforward ways to avoid them.

Table of Contents

Effective C++: 55 Specific Ways to Improve Your Programs and Designs, Third Edition
Chapter 1. Accustoming Yourself to C++
Chapter 2. Constructors, Destructors, and Assignment Operators
Chapter 3. Resource Management
Chapter 4. Designs and Declarations
Chapter 5. Implementations
Chapter 6. Inheritance and Object-Oriented Design
Chapter 7. Templates and Generic Programming
Chapter 8. Customizing new and delete
Chapter 9. Miscellany
Appendix A. Beyond Effective C++
Appendix B. Item Mappings Between Second and Third Editions

More Effective C++ 35 New Ways to Improve Your Programs and Designs
Item 1: Distinguish between pointers and references.
Item 2: Prefer C++-style casts.
Item 3: Never treat arrays polymorphically.
Item 4: Avoid gratuitous default constructors.
Item 5: Be wary of user-defined conversion functions.
Item 6: Distinguish between prefix and postfix forms of increment and decrement operators.
Item 7: Never overload &&, ||, or ,.
Item 8: Understand the different meanings of new and delete.
Item 9: Use destructors to prevent resource leaks.
Item 10: Prevent resource leaks in constructors.
Item 11: Prevent exceptions from leaving destructors.
Item 12: Understand how throwing an exception differs from passing a parameter or calling a virtual function.
Item 13: Catch exceptions by reference.
Item 14: Use exception specifications judiciously.
Item 15: Understand the costs of exception handling.
Item 16: Remember the 80-20 rule.
Item 17: Consider using lazy evaluation.
Item 18: Amortize the cost of expected computations.
Item 19: Understand the origin of temporary objects.
Item 20: Facilitate the return value optimization.
Item 21: Overload to avoid implicit type conversions.
Item 22: Consider using op= instead of stand-alone op.
Item 23: Consider alternative libraries.
Item 24: Understand the costs of virtual functions, multiple inheritance, virtual base classes, and RTTI.
Item 25: Virtualizing constructors and non-member functions.
Item 26: Limiting the number of objects of a class.
Item 27: Requiring or prohibiting heap-based objects.
Item 28: Smart pointers.
Item 29: Reference counting.
Item 30: Proxy classes.
Item 31: Making functions virtual with respect to more than one object.
Item 32: Program in the future tense.
Item 33: Make non-leaf classes abstract.
Item 34: Understand how to combine C++ and C in the same program.
Item 35: Familiarize yourself with the language standard.

Effective STL 50 Specific Ways to Improve Your Use of the Standard Template Library
Chapter 1. Containers
Chapter 2. vector and string
Chapter 3. Associative Containers
Chapter 4. Iterators
Chapter 5. Algorithms
Chapter 6. Functors, Functor Classes, Functions, etc
Chapter 7. Programming with the STL
Appendix A. Locales and Case-Insensitive String Comparisons
Appendix B. Remarks on Microsoft’s STL Platforms