Effective C++ 55 Specific Ways to Improve Your Programs and Designs - Addison-Wesley Professional Computing Series

More Books

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

Preface

Acknowledgments

Introduction

Terminology

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

Addison-Wesley Professional Computing Series

Brian W. Kernighan, Consulting Editor

Matthew H. Austern, Generic Programming and the STL: Using and Extending the C++ Standard Template Library

David R. Butenhof, Programming with POSIX^® Threads

Brent Callaghan, NFS Illustrated

Tom Cargill, C++ Programming Style

William R. Cheswick/Steven M. Bellovin/Aviel D. Rubin, Firewalls and Internet Security, Second Edition: Repelling the Wily Hacker

David A. Curry, UNIX^® System Security: A Guide for Users and System Administrators

Stephen C. Dewhurst, C++ Gotchas: Avoiding Common Problems in Coding and Design

Dan Farmer/Wietse Venema, Forensic Discovery

Erich Gamma/Richard Helm/Ralph Johnson/John Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software

Erich Gamma/Richard Helm/Ralph Johnsn/John Vlissides, Design Patterns CD: Elements of Reusable Object-Oriented Software

Peter Haggar, Practical Java^™ Programming Language Guide

David R. Hanson, C Interfaces and Implementations: Techniques for Creating Reusable Software

Mark Harrison/Michael McLennan, Effective Tcl/Tk Programming: Writing Better Programs with Tcl and Tk

Michi Henning/Steve Vinoski, Advanced CORBA^® Programming with C++

Brian W. Kernighan/Rob Pike, The Practice of Programming

S. Keshav, An Engineering Approach to Computer Networking: ATM Networks, the Internet, and the Telephone Network

John Lakos, Large-Scale C++ Software Design

Scott Meyers, Effective C++ CD: 85 Specific Ways to Improve Your Programs and Designs

Scott Meyers, Effective C++, Third Edition: 55 Specific Ways to Improve Your Programs and Designs

Scott Meyers, More Effective C++: 35 New Ways to Improve Your Programs and Designs

Scott Meyers, Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library

Robert B. Murray, C++ Strategies and Tactics

David R. Musser/Gillmer J. Derge/Atul Saini, STL Tutorial and Reference Guide, Second Edition: C++ Programming with the Standard Template Library

John K. Ousterhout, Tcl and the Tk Toolkit

Craig Partridge, Gigabit Networking

Radia Perlman, Interconnections, Second Edition: Bridges, Routers, Switches, and Internetworking Protocols

Stephen A. Rago, UNIX^® System V Network Programming

Eric S. Raymond, The Art of UNIX Programming

Marc J. Rochkind, Advanced UNIX Programming, Second Edition

Curt Schimmel, UNIX^® Systems for Modern Architectures: Symmetric Multiprocessing and Caching for Kernel Programmers

W. Richard Stevens, TCP/IP Illustrated, Volume 1: The Protocols

W. Richard Stevens, TCP/IP Illustrated, Volume 3: TCP for Transactions, HTTP, NNTP, and the UNIX^® Domain Protocols

W. Richard Stevens/Bill Fenner/Andrew M. Rudoff, UNIX Network Programming Volume 1, Third Edition: The Sockets Networking API

W. Richard Stevens/Stephen A. Rago, Advanced Programming in the UNIX^® Environment, Second Edition

W. Richard Stevens/Gary R. Wright, TCP/IP Illustrated Volumes 1-3 Boxed Set

John Viega/Gary McGraw, Building Secure Software: How to Avoid Security Problems the Right Way

Gary R. Wright/W. Richard Stevens, TCP/IP Illustrated, Volume 2: The Implementation

Ruixi Yuan/W. Timothy Strayer, Virtual Private Networks: Technologies and Solutions

Visit www.awprofessional.com/series/professionalcomputing for more information about these titles.