Effective C++ 55 Specific Ways to Improve Your Programs and Designs - index_T

Effective C++ 55 Specific Ways to Improve Your Programs and Designs

Effective C++ Third Edition 55 Specific Ways to Improve Your Programs and Designs

Table of Contents

Praise for Effective C++, Third Edition

Addison-Wesley Professional Computing Series

Acknowledgments

Introduction

Chapter 1. Accustoming Yourself to C++

Item 1: View C++ as a federation of languages

Item 2: Prefer consts, enums, and inlines to #defines

Item 3: Use const whenever possible

Item 4: Make sure that objects are initialized before they're used

Chapter 2. Constructors, Destructors, and Assignment Operators

Item 5: Know what functions C++ silently writes and calls

Item 6: Explicitly disallow the use of compiler-generated functions you do not want

Item 7: Declare destructors virtual in polymorphic base classes

Item 8: Prevent exceptions from leaving destructors

Item 9: Never call virtual functions during construction or destruction

Item 10: Have assignment operators return a reference to *this

Item 11: Handle assignment to self in operator=

Item 12: Copy all parts of an object

Chapter 3. Resource Management

Item 13: Use objects to manage resources.

Item 14: Think carefully about copying behavior in resource-managing classes.

Item 15: Provide access to raw resources in resource-managing classes.

Item 16: Use the same form in corresponding uses of new and delete.

Item 17: Store newed objects in smart pointers in standalone statements.

Chapter 4. Designs and Declarations

Item 18: Make interfaces easy to use correctly and hard to use incorrectly

Item 19: Treat class design as type design

Item 20: Prefer pass-by-reference-to-const to pass-by-value

Item 21: Don't try to return a reference when you must return an object

Item 22: Declare data members private

Item 23: Prefer non-member non-friend functions to member functions

Item 24: Declare non-member functions when type conversions should apply to all parameters

Item 25: Consider support for a non-throwing swap

Chapter 5. Implementations

Item 26: Postpone variable definitions as long as possible.

Item 27: Minimize casting.

Item 28: Avoid returning "handles" to object internals.

Item29: Strive for exception-safe code.

Item 30: Understand the ins and outs of inlining.

Item31: Minimize compilation dependencies between files.

Chapter 6. Inheritance and Object-Oriented Design

Item 32: Make sure public inheritance models "is-a."

Item 33: Avoid hiding inherited names

Item 34: Differentiate between inheritance of interface and inheritance of implementation

Item 35: Consider alternatives to virtual functions

Item 36: Never redefine an inherited non-virtual function

Item 37: Never redefine a function's inherited default parameter value

Item 38: Model "has-a" or "is-implemented-in-terms-of" through composition

Item 39: Use private inheritance judiciously

Item 40: Use multiple inheritance judiciously

Chapter 7. Templates and Generic Programming

Item 41: Understand implicit interfaces and compile-time polymorphism

Item 42: Understand the two meanings of typename

Item 43: Know how to access names in templatized base classes

Item 44: Factor parameter-independent code out of templates

Item 45: Use member function templates to accept "all compatible types."

Item 46: Define non-member functions inside templates when type conversions are desired

Item 47: Use traits classes for information about types

Item 48: Be aware of template metaprogramming

Chapter 8. Customizing new and delete

Item 49: Understand the behavior of the new-handler

Item 50: Understand when it makes sense to replace new and delete

Item 51: Adhere to convention when writing new and delete

Item 52: Write placement delete if you write placement new

Chapter 9. Miscellany

Item 53: Pay attention to compiler warnings.

Item 54: Familiarize yourself with the standard library, including TR1

Item.55: Familiarize yourself with Boost.

Appendix A. Beyond Effective C++

Appendix B. Item Mappings Between Second and Third Editions

Index

Index

[SYMBOL] [A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [R] [S] [T] [U] [V] [W] [X] [Z]

template metaprogramming
     efficiency and
     hello world in
     pattern implementations and
     support in Boost
     support in TR1
Template Method pattern
templates
     code bloat, avoiding in 2nd
     combining with inheritance
     defining
     errors, when detected
     expression
     headers and
     in std, specializing
     inlining and
     instantiation of
     member functions 2nd
     names in base classes and 2nd
     non-type parameters
     parameters, omitting
     pointer type parameters and
     shorthand for
     specializations 2nd
         partial 2nd
         total 2nd 3rd
     type conversions and 2nd
     type deduction for 2nd
temporary objects, eliminated by compilers
terminology, used in this book 2nd
testing and correctness, Boost support for
text and string utilities, in Boost
third edition [See 3rd edition]
this->, to force base class lookup 2nd
threading [See multithreading]
Tilly, Barbara
TMP [See template metaprogramming]
Tondo, Clovis
Topic, Michael
total class template specialization
total specialization of std::swap 2nd
total template specializations
TR1 2nd 3rd
     array component
     bind component
     Boost and 2nd 3rd 4th
     boost as synonym for std::tr1
     C99 compatibility component
     function component
     hash tables component
     math functions component
     mem_fn component
     random numbers component
     reference_wrapper component
     regular expression component
     result_of component
     smart pointers component
     support for TMP
     tuples component
     type traits component
tr1::array
tr1::bind 2nd
tr1::function 2nd 3rd
tr1::mem_fn
tr1::reference_wrapper
tr1::result_of
tr1::shared_ptr 2nd 3rd 4th 5th
     construction from other smart pointers and
     cross-DLL problem and
     delete [i] and
     deleter support in 2nd 3rd
     member template ctors in 2nd
tr1::tuple
tr1::unordered_map 2nd
tr1::unordered_multimap
tr1::unordered_multiset
tr1::unordered_set
tr1::weak_ptr
traits classes 2nd
transfer, ownership
translation unit, definition of
Trux, Antoine
Tsao, Mike
tuples, in TR1
type conversions 2nd
     explicit ctors and
     implicit
     implicit vs. explicit 2nd
     non-member functions and 2nd 3rd 4th
     private inheritance and
     smart pointers and 2nd
     templates and 2nd
type deduction, for templates 2nd
type design 2nd
type traits, in TR1
typedef, typename and 2nd
typedefs, new/delete and
typeid 2nd 3rd 4th
typelists
typename 2nd
     compiler variations and
     typedef and 2nd
     vs. class
types
     built-in, initialization 2nd
     compatible, accepting all 2nd
     if...else for
     integral, definition of
     traits classes and 2nd