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

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]

C standard library and C++ standard library
C# 2nd 3rd 4th 5th 6th 7th 8th [See also .NET]
C++ Programming Language, The
C++ standard library 2nd
     <iosfwd> and
     array replacements and
     C standard library and
     C89 standard library and
     header organization of
     list template
     logic_error and
     set template
     vector template
C++ Templates
C++, as language federation 2nd
C++-style casts
C++0x
C-style casts
C99 standard library, TR1 and
caching
     const and
     mutable and
Cai, Steve
calling swap
calls to base classes, casting and
Cargill, Tom
Carrara, Enrico
Carroll, Glenn
cast of int to double
casting 2nd
     aaa] [See also const_cast, static_cast, dynamic_cast, and reinterpret_cast[casting]
     base class calls and
     constness away 2nd
     encapsulation and
     grep and
     syntactic forms 2nd
     type systems and
     undefined behavior and
chaining assignments
Chang, Brandon
Clamage, Steve
class definitions
     artificial client dependencies, eliminating
     class declarations vs
     object sizes and
class design [See type design]
class names, explicitly specifying
class, vs. typename
classes
     aaa] [See also class definitions, interfaces[classes]
     abstract 2nd
     base [See also base classes[classes:base:aaa]]
         duplication of data in
         polymorphic
         templatized 2nd
         virtual
     defining
     derived [See also inheritance]
         virtual base initialization of
     Handle 2nd
     Interface 2nd
     meaning of no virtual functions
    RAII [See RAII]
    specification [See interfaces]
     traits 2nd
client
code
     bloat 2nd 3rd
         avoiding, in templates 2nd
     copy assignment operator
    duplication [See duplication]
     exception-safe 2nd
     factoring out of templates 2nd
     incorrect, efficiency and
     reuse
    sharing [See duplication, duplication;avoiding]
Cohen, Jake
Comeau, Greg 2nd
     URL for his C/C++ FAQ
common features and inheritance
commonality and variability analysis
compatibility, vptrs and
compatible types, accepting 2nd
compilation dependencies
     minimizing 2nd 3rd
     pointers, references, and objects and
compile-time polymorphism
compiler warnings 2nd
     calls to virtuals and
     inlining and
     partial copies and
compiler-generated functions 2nd
     disallowing 2nd
     functions compilers may generate
compilers
     parsing nested dependent names
    programs executing within [See template metaprogramming]
     register usage and
     reordering operations
     typename and
     when errors are diagnosed
composition 2nd
     meanings of
     replacing private inheritance with
     synonyms for
     vs. private inheritance
conceptual constness [See const, const;logical]
consistency with the built-in types 2nd
const 2nd 3rd
     bitwise 2nd
     caching and
     casting away 2nd
     function declarations and
     logical 2nd
     member functions 2nd
         duplication and 2nd
     members, initialization of
     overloading on 2nd
     pass by reference and 2nd
     passing std::auto_ptr and
     pointers
     return value
     uses
     vs. #define 2nd
const_cast 2nd
     aaa] [See also casting[const_cast]
const_iterator, vs. iterators
constants
    aaa] [See const[constants]
constraints on interfaces, from inheritance
constructors
     copy
     default
     empty, illusion of
     explicit 2nd 3rd
     implicitly generated
     inlining and 2nd
     operator new and
     possible implementation in derived classes
     relationship to new
     static functions and
     virtual 2nd
     virtual functions and 2nd
     with vs. without arguments
containers, in Boost
containment [See composition]
continue, delete and
control over data members accessibility
convenience functions
Conversion library, in Boost
conversions, type [See type conversions]
copies, partial
copy assignment operator
     code in copy constructor and
     derived classes and
copy constructors
     default definition
     derived classes and
     generalized
     how used
     implicitly generated
     pass-by-value and
copy-and-swap
     assignment and
     exception-safe code and
copying
     base class parts
     behavior, resource management and 2nd
     functions, the
     objects
correctness
     designing interfaces for 2nd
     testing and, Boost support
corresponding forms of new and delete 2nd
corrupt data structures, exception-safe code and
cows, coming home
crimes against English 2nd
cross-DLL problem
CRTP
ctor
curiously recurring template pattern