Effective C++

50 specific ways to improve your programs and designs

Scott Meyers - Collection Professional computing

304 pages, parution le 09/10/1997

Ajouter à une liste

Indisponible

Résumé

The first edition of Effective C++ sold nearly 100,000 copies and was translated into four languages. It's easy to understand why. Scott Meyers' practical approach to C++ described the rules of thumb employed by the experts--the things they almost always do or almost always avoid doing--to produce clear, correct, efficient code.

Each of this book's 50 guidelines summarizes a way to write better C++, and the accompanying discussions are backed by specific examples. For this new edition, Meyers reworked every guideline in the book. The result is exceptional adherence to C++'s Draft International Standard, current compiler technology, and the latest insights into the use of C++ for real-world applications.

Highlights of Effective C++, 2nd Edition include:

Expert guidance on object-oriented design, class design, and the proper use of inheritance
An examination of the standard C++ library, including how the Standard Template Library and classes like string and vector affect the structure of well-written programs
Discussions of late-breaking language features like in-class constant initializations, namespaces, and member templates
Wisdom usually possessed by only the most experienced developers

Effective C++ continues to be essential reading for every developer working with C++.

Preface ..... xiii
Acknowledgments ..... xvii
Introduction ..... 1
Shifting from C to C++ ..... 13
- Item 1: Prefer const and inline to #define. ..... 13
- Item 2: Prefer <iostream> to <stdio.h>. ..... 17
- Item 3: Prefer new and delete to malloc and free. ..... 19
- Item 4: Prefer C++-style comments. ..... 21
Memory Management ..... 22
- Item 5: Use the same form in corresponding uses of new and delete. ..... 23
- Item 6: Use delete on pointer members in destructors. ..... 24
- Item 7: Be prepared for out-of-memory conditions. ..... 25
- Item 8: Adhere to convention when writing operator new and operator delete. ..... 33
- Item 9: Avoid hiding the "normal" form of new. ..... 37
- Item 10: Write operator delete if you write operator new. ..... 39
Constructors, Destructors, and Assignment Operators ..... 49
- Item 11: Declare a copy constructor and an assignment operator for classes with dynamically allocated memory. ..... 49
- Item 12: Prefer initialization to assignment in constructors. ..... 52
- Item 13: List members in an initialization list in the order in which they are declared. ..... 57
- Item 14: Make destructors virtual in base classes. ..... 59
- Item 15: Have operator= return a reference to *this. ..... 64
- Item 16: Assign to all data members in operator=. ..... 68
- Item 17: Check for assignment to self in operator=. ..... 71
Classes and Functions: Design and Declaration ..... 77
- Item 18: Strive for class interfaces that are complete and minimal. ..... 79
- Item 19: Differentiate among member functions, non-member functions, and friend functions. ..... 84
- Item 20: Avoid data members in the public interface. ..... 89
- Item 21: Use const whenever possible. ..... 91
- Item 22: Prefer pass-by-reference to pass-by-value. ..... 98
- Item 23: Don't try to return a reference when you must return an object. ..... 101
- Item 24: Choose carefully between function overloading and parameter defaulting. ..... 106
- Item 25: Avoid overloading on a pointer and a numerical type. ..... 109
- Item 26: Guard against potential ambiguity. ..... 113
- Item 27: Explicitly disallow use of implicitly generated member functions you don't want. ..... 116
- Item 28: Partition the global namespace. ..... 117
Classes and Functions: Implementation ..... 123
- Item 29: Avoid returning "handles" to internal data. ..... 123
- Item 30: Avoid member functions that return non-const pointers or references to members less accessible than themselves. ..... 129
- Item 31: Never return a reference to a local object or to a dereferenced pointer initialized by new within the function. ..... 131
- Item 32: Postpone variable definitions as long as possible. ..... 135
- Item 33: Use inlining judiciously. ..... 137
- Item 34: Minimize compilation dependencies between files. ..... 143
Inheritance and Object-Oriented Design ..... 153
- Item 35: Make sure public inheritance models "isa." ..... 154
- Item 36: Differentiate between inheritance of interface and inheritance of implementation. ..... 161
- Item 37: Never redefine an inherited nonvirtual function. ..... 169
- Item 38: Never redefine an inherited default parameter value. ..... 171
- Item 39: Avoid casts down the inheritance hierarchy. ..... 173
- Item 40: Model "has-a" or "is-implemented-in-terms-of" through layering. ..... 182
- Item 41: Differentiate between inheritance and templates. ..... 185
- Item 42: Use private inheritance judiciously. ..... 189
- Item 43: Use multiple inheritance judiciously. ..... 194
- Item 44: Say what you mean; understand what you're saying. ..... 210
Miscellany ..... 212
- Item 45: Know what functions C++ silently writes and calls. ..... 212
- Item 46: Prefer compile-time and link-time errors to runtime errors. ..... 216
- Item 47: Ensure that non-local static objects are initialized before they're used. ..... 219
- Item 48: Pay attention to compiler warnings. ..... 223
- Item 49: Familiarize yourself with the standard library. ..... 224
- Item 50: Improve your understanding of C++. ..... 232
Afterword ..... 237
Index ..... 239

L'auteur - Scott Meyers

Scott Meyers - Consultant américain, expert de niveau international reconnu dans la communauté des développeurs C++, diplômé de Stanford et de Brown University.Il est déjà l'auteur des ouvrages de référence Effective C++ (3e ed, 2005 Addison-Wesley), de More Effective C++ (1996 Addison-Wesley) et de Effective STL (2001 Addison-Wesley). Il a longtemps été conseiller éditorial pour l'informatique chez Addison-Wesley.