C++ Coding Standards: 101 Rules, Guidelines, and Best Practices

Front Cover
Pearson Education, Oct 25, 2004 - Computers - 240 pages
0 Reviews

Consistent, high-quality coding standards improve software quality, reduce time-to-market, promote teamwork, eliminate time wasted on inconsequential matters, and simplify maintenance. Now, two of the world's most respected C++ experts distill the rich collective experience of the global C++ community into a set of coding standards that every developer and development team can understand and use as a basis for their own coding standards.

The authors cover virtually every facet of C++ programming: design and coding style, functions, operators, class design, inheritance, construction/destruction, copying, assignment, namespaces, modules, templates, genericity, exceptions, STL containers and algorithms, and more. Each standard is described concisely, with practical examples. From type definition to error handling, this book presents C++ best practices, including some that have only recently been identified and standardized-techniques you may not know even if you've used C++ for years. Along the way, you'll find answers to questions like

  • What's worth standardizing--and what isn't?
  • What are the best ways to code for scalability?
  • What are the elements of a rational error handling policy?
  • How (and why) do you avoid unnecessary initialization, cyclic, and definitional dependencies?
  • When (and how) should you use static and dynamic polymorphism together?
  • How do you practice "safe" overriding?
  • When should you provide a no-fail swap?
  • Why and how should you prevent exceptions from propagating across module boundaries?
  • Why shouldn't you write namespace declarations or directives in a header file?
  • Why should you use STL vector and string instead of arrays?
  • How do you choose the right STL search or sort algorithm?
  • What rules should you follow to ensure type-safe code?

Whether you're working alone or with others, C++ Coding Standards will help you write cleaner code--and write it faster, with fewer hassles and less frustration.


What people are saying - Write a review

We haven't found any reviews in the usual places.


How to Use This Book
Coding Standards and You
About This Book
Organizational and Policy Issues
Know what not to standardize
1 Compile cleanly at high warning levels
50 Make base class destructors public and virtual or protected and nonvirtual
51 Destructors deallocation and swap never fail
52 Copy and destroy consistently
53 Explicitly enable or disable copying
54 Avoid slicing Consider Clone instead of copying in base classes
55 Prefer the canonical form of assignment
56 Whenever it makes sense provide a nofail swap and provide it correctly
Namespaces and Modules

2 Use an automated build system
3 Use a version control system
4 Invest in code reviews
Design Style
5 Give one entity one cohesive responsibility
6 Correctness simplicity and clarity come first
7 Know when and how to code for scalability
8 Dont optimize prematurely
9 Dont pessimize prematurely
10 Minimize global and shared data
11 Hide information
12 Know when and how to code for concurrency
13 Ensure resources are owned by objects Use explicit RAII and smart pointers
Coding Style
14 Prefer compile and linktime errors to runtime errors
15 Use const proactively
16 Avoid macros
17 Avoid magic numbers
18 Declare variables as locally as possible
19 Always initialize variables
20 Avoid long functions Avoid deep nesting
21 Avoid initialization dependencies across compilation units
22 Minimize definitional dependencies Avoid cyclic dependencies
23 Make header files selfsufficient
24 Always write internal include guards Never write external include guards
Functions and Operators
25 Take parameters appropriately by value smart pointer or reference
26 Preserve natural semantics for overloaded operators
27 Prefer the canonical forms of arithmetic and assignment operators
28 Prefer the canonical form of ++ and Prefer calling the prefix forms
29 Consider overloading to avoid implicit type conversions
30 Avoid overloading or comma
31 Dont write code that depends on the order of evaluation of function arguments
Class Design and Inheritance
32 Be clear what kind of class youre writing
33 Prefer minimal classes to monolithic classes
34 Prefer composition to inheritance
35 Avoid inheriting from classes that were not designed to be base classes
36 Prefer providing abstract interfaces
37 Public inheritance is substitutability Inherit not to reuse but to be reused
38 Practice safe overriding
39 Consider making virtual functions nonpublic and public functions nonvirtual
40 Avoid providing implicit conversions
41 Make data members private except in behaviorless aggregates Cstyle structs
42 Dont give away your internals
43 Pimpl judiciously
44 Prefer writing nonmember nonfriend functions
45 Always provide new and delete together
46 If you provide any classspecific new provide all of the standard forms plain inplace and nothrow
Construction Destruction and Copying
47 Define and initialize member variables in the same order
48 Prefer initialization to assignment in constructors
49 Avoid calling virtual functions in constructors and destructors
57 Keep a type and its nonmember function interface in the same namespace
58 Keep types and functions in separate namespaces unless theyre specifically intended to work together
59 Dont write namespace usings in a header file or before an include
60 Avoid allocating and deallocating memory in different modules
61 Dont define entities with linkage in a header file
62 Dont allow exceptions to propagate across module boundaries
63 Use sufficiently portable types in a modules interface
Templates and Genericity
64 Blend static and dynamic polymorphism judiciously
65 Customize intentionally and explicitly
66 Dont specialize function templates
67 Dont write unintentionally nongeneric code
Error Handling and Exceptions
68 Assert liberally to document internal assumptions and invariants
69 Establish a rational error handling policy and follow it strictly
70 Distinguish between errors and nonerrors
71 Design and write errorsafe code
72 Prefer to use exceptions to report errors
73 Throw by value catch by reference
74 Report handle and translate errors appropriately
75 Avoid exception specifications
76 Use vector by default Otherwise choose an appropriate container
77 Use vector and string instead of arrays
c_str to exchange data with nonC++ APIs
79 Store only values and smart pointers in containers
80 Prefer push_back to other ways of expanding a sequence
81 Prefer range operations to singleelement operations
82 Use the accepted idioms to really shrink capacity and really erase elements
83 Use a checked STL implementation
84 Prefer algorithm calls to handwritten loops
85 Use the right STL search algorithm
86 Use the right STL sort algorithm
87 Make predicates pure functions
88 Prefer function objects over functions as algorithm and comparer arguments
89 Write function objects correctly
Type Safety
90 Avoid type switching prefer polymorphism
91 Rely on types not on representations
92 Avoid using reinterpret_cast
93 Avoid using static_cast on pointers
94 Avoid casting away const
95 Dont use Cstyle casts
96 Dont memcpy or memcmp nonPODs
97 Dont use unions to reinterpret representation
98 Dont use varargs ellipsis
99 Dont use invalid objects Dont use unsafe functions
100 Dont treat arrays polymorphically
Summary of Summaries

Common terms and phrases

About the author (2004)

Herb Sutter is the author of three highly acclaimed books, Exceptional C++ Style, Exceptional C++, and More Exceptional C++ (Addison-Wesley). He chairs the ISO C++ standards committee, and is contributing editor and columnist for C/C++ Users Journal. As a software architect for Microsoft, Sutter leads the design of C++ language extensions for .NET programming.

Andrei Alexandrescu is the author of the award-winning book Modern C++ Design (Addison-Wesley, 2001) and is a columnist for C/C++ Users Journal.

Bibliographic information