Effective C++: 50 Specific Ways to Improve Your Programs and Design / Edition 2

Effective C++: 50 Specific Ways to Improve Your Programs and Design / Edition 2

by Scott Meyers
     
 

ISBN-10: 0201924889

ISBN-13: 9780201924886

Pub. Date: 09/02/1997

Publisher: Addison-Wesley

From the Author

Both my books (and more) in one revolutionary package. As the author of Effective C++ and More Effective C++, I've had access to electronic versions of both books since, well, since I wrote them. I've wanted to give you on-line access to them for years, but it wasn't really practical until HTML and JavaScript, etc., emerged as

Overview

From the Author

Both my books (and more) in one revolutionary package. As the author of Effective C++ and More Effective C++, I've had access to electronic versions of both books since, well, since I wrote them. I've wanted to give you on-line access to them for years, but it wasn't really practical until HTML and JavaScript, etc., emerged as electronic publishing standards. On this CD, I've exploited those standards like they've never been exploited before.

The CD includes capabilities that are, as far as I know, unprecedented. These include (1) Dynamic user control over the size of images, navigation bars, and HTML files. You configure things *your* way. (2) The ability to bookmark and/or link to *any paragraph* on the CD. You can now set a bookmark that takes you *exactly* where you want to go. Among other things, this is useful for linking your coding guidelines to the technical discussions in my books that back you up. (3) The results of full-text searches link to specific *paragraphs* containing hits, not just to specific documents. No more 'double searching', once to find the document, once again to find the correct place in the document. (I hate that.) (4) Links from the CD to the Internet go indirect via an on-line lookup table, so links on the CD remain valid even when Internet URLs change. (I also hate broken links.) Of course, the CD includes features you should be able to take for granted in an electronic publication, e.g., color images and diagrams, lots of links (there are thousands, and I specified every last one of them), the ability to legally copy the material to a hard drive for faster and more convenient access, etc. If you're familiar with my books, you know I have definite opinions and I'm not afraid to voice them. I voiced them repeatedly during the design and implementation of this CD, and it shows. This isn't just an 'Effective C++' CD, it's an *effective* CD. I spent more time and energy on this project than I did in writing *both* editions of Effective C++. I honestly think you'll find the CD to be informative and useful for years to come. If you don't, I know you'll let me hear about it :-)

Scott Meyers (smeyers@aristeia.com), the author, February 4, 1999.

Product Details

ISBN-13:
9780201924886
Publisher:
Addison-Wesley
Publication date:
09/02/1997
Series:
Professional Computing Series
Edition description:
Older Edition
Pages:
256
Product dimensions:
7.39(w) x 9.18(h) x 0.57(d)

Table of Contents

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

Customer Reviews

Average Review:

Write a Review

and post it to your social network

     

Most Helpful Customer Reviews

See all customer reviews >