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++   Introduction 1A   Chapter 1: Accustoming Yourself to C++ 11A Item 1: View C++ as a federation of languages. 11A Item 2: Prefer consts, enums, and inlines to #defines. 13A Item 3: Use const whenever possible. 17A Item 4: Make sure that objects are initialized before they’re used. 26A   Chapter 2: Constructors, Destructors, and Assignment Operators 34A Item 5: Know what functions C++ silently writes and calls. 34A Item 6: Explicitly disallow the use of compiler-generated functions you do not want. 37A Item 7: Declare destructors virtual in polymorphic base classes. 40A Item 8: Prevent exceptions from leaving destructors. 44A Item 9: Never call virtual functions during construction or destruction. 48A Item 10: Have assignment operators return a reference to *this. 52A Item 11: Handle assignment to self in operator=. 53A Item 12: Copy all parts of an object. 57A   Chapter 3: Resource Management 61A Item 13: Use objects to manage resources. 61A Item 14: Think carefully about copying behavior in resourcemanaging classes. 66A Item 15: Provide access to raw resources in resourcemanaging classes. 69A Item 16: Use the same form in corresponding uses of new and delete. 73A Item 17: Store newed objects in smart pointers in standalone statements. 75A   Chapter 4: Designs and Declarations 78A Item 18: Make interfaces easy to use correctly and hard to use incorrectly. 78A Item 19: Treat class design as type design. 84A Item 20: Prefer pass-by-reference-to-const to pass-by-value. 86A Item 21: Don’t try to return a reference when you must return an object. 90A Item 22: Declare data members private. 94A Item 23: Prefer non-member non-friend functions to member functions. 98A Item 24: Declare non-member functions when type conversions should apply to all parameters. 102A Item 25: Consider support for a non-throwing swap. 106A   Chapter 5: Implementations 113A Item 26: Postpone variable definitions as long as possible. 113A Item 27: Minimize casting. 116A Item 28: Avoid returning “handles” to object internals. 123A Item 29: Strive for exception-safe code. 127A Item 30: Understand the ins and outs of inlining. 134A Item 31: Minimize compilation dependencies between files. 140A   Chapter 6: Inheritance and Object-Oriented Design 149A Item 32: Make sure public inheritance models “is-a.” 150A Item 33: Avoid hiding inherited names. 156A Item 34: Differentiate between inheritance of interface and inheritance of implementation. 161A Item 35: Consider alternatives to virtual functions. 169A Item 36: Never redefine an inherited non-virtual function. 178A Item 37: Never redefine a function’s inherited default parameter value. 180A Item 38: Model “has-a” or “is-implemented-in-terms-of” through composition. 184A Item 39: Use private inheritance judiciously. 187A Item 40: Use multiple inheritance judiciously. 192A   Chapter 7: Templates and Generic Programming 199A Item 41: Understand implicit interfaces and compile-time polymorphism. 199A Item 42: Understand the two meanings of typename. 203A Item 43: Know how to access names in templatized base classes. 207A Item 44: Factor parameter-independent code out of templates. 212A Item 45: Use member function templates to accept “all compatible types.” 218A Item 46: Define non-member functions inside templates when type conversions are desired. 222A Item 47: Use traits classes for information about types. 226A Item 48: Be aware of template metaprogramming. 233A   Chapter 8: Customizing new and delete 239A Item 49: Understand the behavior of the new-handler. 240A Item 50: Understand when it makes sense to replace new and delete. 247A Item 51: Adhere to convention when writing new and delete. 252A Item 52: Write placement delete if you write placement new. 256A Chapter 9: Miscellany 262A Item 53: Pay attention to compiler warnings. 262A Item 54: Familiarize yourself with the standard library, including TR1. 263A Item 55: Familiarize yourself with Boost. 269A   Appendix A: Beyond Effective C++ 273A Appendix B: Item Mappings Between Second and Third Editions 277A   Index 280A   More Effective C++   Introduction 1B   Basics 9B Item 1: Distinguish between pointers and references. 9B Item 2: Prefer C++-style casts. 12B Item 3: Never treat arrays polymorphically. 16B Item 4: Avoid gratuitous default constructors. 19B   Operators 24B Item 5: Be wary of user-defined conversion functions. 24B Item 6: Distinguish between prefix and postfix forms of increment and decrement operators. 31B Item 7: Never overload &&, ||, or ,. 35B Item 8: Understand the different meanings of new and delete. 38B   Exceptions 44B Item 9: Use destructors to prevent resource leaks. 45B Item 10: Prevent resource leaks in constructors. 50B Item 11: Prevent exceptions from leaving destructors. 58B Item 12: Understand how throwing an exception differs from passing a parameter or calling a virtual function. 61B Item 13: Catch exceptions by reference. 68B Item 14: Use exception specifications judiciously. 72B Item 15: Understand the costs of exception handling. 78B   Efficiency 81B Item 16: Remember the 80-20 rule. 82B Item 17: Consider using lazy evaluation. 85B Item 18: Amortize the cost of expected computations. 93B Item 19: Understand the origin of temporary objects. 98B Item 20: Facilitate the return value optimization. 101B Item 21: Overload to avoid implicit type conversions. 105B Item 22: Consider using op= instead of stand-alone op. 107B Item 23: Consider alternative libraries. 110B Item 24: Understand the costs of virtual functions, multiple inheritance, virtual base classes, and RTTI. 113B   Techniques 123B Item 25: Virtualizing constructors and non-member functions. 123B Item 26: Limiting the number of objects of a class. 130B Item 27: Requiring or prohibiting heap-based objects. 145B Item 28: Smart pointers. 159B Item 29: Reference counting. 183B Item 30: Proxy classes. 213B Item 31: Making functions virtual with respect to more than one object. 228B   Miscellany 252B Item 32: Program in the future tense. 252B Item 33: Make non-leaf classes abstract. 258B Item 34: Understand how to combine C++ and C in the same program. 270B Item 35: Familiarize yourself with the language standard. 277B   Recommended Reading 285B An auto_ptr Implementation 291B   General Index 295B Index of Example Classes, Functions, and Templates 313B   Effective STL   Introduction 1C   Chapter 1: Containers 11C Item 1: Choose your containers with care. 11C Item 2: Beware the illusion of container-independent code. 15C Item 3: Make copying cheap and correct for objects in containers. 20C Item 4: Call empty instead of checking size() against zero. 23C Item 5: Prefer range member functions to their single-element counterparts. 24C Item 6: Be alert for C++’s most vexing parse. 33C Item 7: When using containers of newed pointers, remember to delete the pointers before the container is destroyed. 36C Item 8: Never create containers of auto_ptrs. 40C Item 9: Choose carefully among erasing options. 43C Item 10: Be aware of allocator conventions and restrictions. 48C Item 11: Understand the legitimate uses of custom allocators. 54C Item 12: Have realistic expectations about the thread safety of STL containers. 58C   Chapter 2: vector and string 63C Item 13: Prefer vector and string to dynamically allocated arrays. 63C Item 14: Use reserve to avoid unnecessary reallocations. 66C Item 15: Be aware of variations in string implementations. 68C Item 16: Know how to pass vector and string data to legacy APIs. 74C Item 17: Use “the swap trick” to trim excess capacity. 77C Item 18: Avoid using vector. 79C   Chapter 3: Associative Containers 83C Item 19: Understand the difference between equality and equivalence. 83C Item 20: Specify comparison types for associative containers of pointers. 88C Item 21: Always have comparison functions return false for equal values. 92C Item 22: Avoid in-place key modification in set and multiset. 95C Item 23: Consider replacing associative containers with sorted vectors. 100C Item 24: Choose carefully between map::operator[] and map::insert when efficiency is important. 106C Item 25: Familiarize yourself with the nonstandard hashed containers. 111C   Chapter 4: Iterators 116C Item 26: Prefer iterator to const_iterator, reverse_iterator, and const_reverse_iterator. 116C Item 27: Use distance and advance to convert a container’s const_iterators to iterators. 120C Item 28: Understand how to use a reverse_iterator’s base iterator. 123C Item 29: Consider istreambuf_iterators for character-bycharacter input. 126C   Chapter 5: Algorithms 128C Item 30: Make sure destination ranges are big enough. 129C Item 31: Know your sorting options. 133C Item 32: Follow remove-like algorithms by erase if you really want to remove something. 139C Item 33: Be wary of remove-like algorithms on containers of pointers. 143C Item 34: Note which algorithms expect sorted ranges. 146C Item 35: Implement simple case-insensitive string comparisons via mismatch or lexicographical_compare. 150C Item 36: Understand the proper implementation of copy_if. 154C Item 37: Use accumulate or for_each to summarize ranges. 156C   Chapter 6: Functors, Functor Classes, Functions, etc. 162C Item 38: Design functor classes for pass-by-value. 162C Item 39: Make predicates pure functions. 166C Item 40: Make functor classes adaptable. 169C Item 41: Understand the reasons for ptr_fun, mem_fun, and mem_fun_ref. 173C Item 42: Make sure less means operator<. 177C   Chapter 7: Programming with the STL 181C Item 43: Prefer algorithm calls to hand-written loops. 181C Item 44: Prefer member functions to algorithms with the same names. 190C Item 45: Distinguish among count, find, binary_search, lower_bound, upper_bound, and equal_range. 192C Item 46: Consider function objects instead of functions as algorithm parameters. 201C Item 47: Avoid producing write-only code. 206C Item 48: Always #include the proper headers. 209C Item 49: Learn to decipher STL-related compiler diagnostics. 210C Item 50: Familiarize yourself with STL-related web sites. 217C   Bibliography 225C Appendix A: Locales and Case-Insensitive String Comparisons 229C Appendix B: Remarks on Microsoft’s STL Platforms 239C   Index 245C