C++ Coding Standard

Coding Standard

Version 4.0

Contents

0 Introduction 7

0.1 Typographical Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

0.2 Escalation policy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

0.3 Base Standard and Policy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

0.3.1 ISO Standard C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

0.3.2 Statically detectable restrictions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.1 Implementation compliance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.1.1 Ensure that code complies with the 2011 ISO C++ Language Standard . . . . . . . . . . . . 10

1.2 Redundancy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.2.1 Ensure that all statements are reachable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.2.2 Ensure that no expression or sub-expression is redundant . . . . . . . . . . . . . . . . . . . . 11

1.3 Deprecated features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.3.1 Do not use the increment operator (++) on a variable of type bool . . . . . . . . . . . . . . . 12

1.3.2 Do not use the register keyword . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.3.3 Do not use the C Standard Library .h headers . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.3.4 Do not use deprecated STL library features . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.3 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.3.1 Do not use the C comment delimiters /* ... */ . . . . . . . . . . . . . . . . . . . . . . . . 16

2.3.2 Do not comment out code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.4 Identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.4.1 Ensure that each identifier is distinct from any other visible identifier . . . . . . . . . . . . . . 18

2.5 Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.5.1 Do not concatenate strings with different encoding prefixes . . . . . . . . . . . . . . . . . . . 18

2.5.2 Do not use octal constants (other than zero) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.5.3 Use nullptr for the null pointer constant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3 Basic concepts 21

3.4 Object lifetime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.4.1 Do not return a reference or a pointer to an automatic variable defined within the function . . 23

3.4.2 Do not assign the address of a variable to a pointer with a greater lifetime . . . . . . . . . . . 24

3.4.3 Use RAII for resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3.5 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.5.1 Do not make any assumptions about the internal representation of a value or object . . . . . 27

4 Standard conversions 29

4.1 Array-to-pointer conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.1.1 Ensure that a function argument does not undergo an array-to-pointer conversion . . . . . . 29

4.2 Integral conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.4.1 Do not convert floating values to integral types except through use of standard library functions 33

5 Expressions 34

5.1 Primary expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

5.1.1 Use symbolic names instead of literal values in code . . . . . . . . . . . . . . . . . . . . . . . 34

5.1.2 Do not rely on the sequence of evaluation within an expression . . . . . . . . . . . . . . . . . 34

5.1.3 Use parentheses in expressions to specify the intent of the expression . . . . . . . . . . . . . 35

5.1.4 Do not capture variables implicitly in a lambda . . . . . . . . . . . . . . . . . . . . . . . . . . 36

5.1.5 Include a (possibly empty) parameter list in every lambda expression . . . . . . . . . . . . . . 37

5.1.6 Do not code side effects into the right-hand operands of: &&, ||, sizeof, typeid or a function

passed to condition variable::wait . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.3.3 Ensure that the form of delete matches the form of new used to allocate the memory . . . . 42

5.4 Explicit type conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

5.4.1 Only use casting forms: static cast (excl. void*), dynamic cast or explicit constructor call 43

5.4.2 Do not cast an expression to an enumeration type . . . . . . . . . . . . . . . . . . . . . . . . 44

5.4.3 Do not convert from a base class to a derived class . . . . . . . . . . . . . . . . . . . . . . . 45

5.5 Multiplicative operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

5.5.1 Ensure that the right hand operand of the division or remainder operators is demonstrably

non-zero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

5.6 Shift operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

5.6.1 Do not use bitwise operators with signed operands . . . . . . . . . . . . . . . . . . . . . . . . 46

6.1 Selection statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

6.1.1 Enclose the body of a selection or an iteration statement in a compound statement . . . . . . 49

6.1.2 Explicitly cover all paths through multi-way selection statements . . . . . . . . . . . . . . . . 49

6.1.3 Ensure that a non-empty case statement block does not fall through to the next label . . . . . 50

6.1.4 Ensure that a switch statement has at least two case labels, distinct from the default label . . 50

6.2 Iteration statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

6.2.1 Implement a loop that only uses element values as a range-based loop . . . . . . . . . . . . 52

6.2.2 Ensure that a loop has a single loop counter, an optional control variable, and is not degenerate 53

6.2.3 Do not alter a control or counter variable more than once in a loop . . . . . . . . . . . . . . . 54

6.2.4 Only modify a for loop counter in the for expression . . . . . . . . . . . . . . . . . . . . . . . . 54

6.3 Jump statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

6.3.1 Ensure that the label(s) for a jump statement or a switch condition appear later, in the same

or an enclosing block . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

7.1 Specifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

7.1.3 Do not place type specifiers before non-type specifiers in a declaration . . . . . . . . . . . . . 60

7.1.4 Place CV-qualifiers on the right hand side of the type they apply to . . . . . . . . . . . . . . . 61

7.1.5 Do not inline large functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

7.1.6 Use class types or typedefs to abstract scalar quantities and standard integer types . . . . . 62

7.1.7 Use a trailing return type in preference to type disambiguation using typename . . . . . . . . 63

7.1.8 Use auto id = expr when declaring a variable to have the same type as its initializer func-

tion call . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

7.1.9 Do not explicitly specify the return type of a lambda . . . . . . . . . . . . . . . . . . . . . . . 65

7.1.10 Use static assert for assertions involving compile time constants . . . . . . . . . . . . . . 65

7.2 Enumeration declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

defined in an unnamed namespace in the main source file . . . . . . . . . . . . . . . . . . . . 68

7.4.2 Ensure that an inline function, a function template, or a type used from multiple translation

units is defined in a single header file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

7.4.3 Ensure that an object or a function used from multiple translation units is declared in a single

header file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

7.5 The asm declaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

7.5.1 Do not use the asm declaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

8.2.2 Do not declare functions with an excessive number of parameters . . . . . . . . . . . . . . . 72

8.2.3 Pass small objects with a trivial copy constructor by value . . . . . . . . . . . . . . . . . . . . 73

8.2.4 Do not pass std::unique ptr by const reference . . . . . . . . . . . . . . . . . . . . . . . . 73

8.3.4 Define =delete functions with parameters of type rvalue reference to const . . . . . . . . . . 76

8.4 Initializers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

8.4.1 Do not access an invalid object or an object with indeterminate value . . . . . . . . . . . . . . 76

8.4.2 Ensure that a braced aggregate initializer matches the layout of the aggregate object . . . . . 78

9 Classes 79

9.1 Member functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

9.1.1 Declare static any member function that does not require this. Alternatively, declare const

9.2 Bit-fields . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

10 Derived classes 84

10.1 Multiple base classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

10.1.1 Ensure that access to base class subobjects does not require explicit disambiguation . . . . 84

10.2 Virtual functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

10.2.1 Use the override special identifier when overriding a virtual function . . . . . . . . . . . . . . 85

10.3 Abstract classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

10.3.1 Ensure that a derived class has at most one base class which is not an interface class . . . . 86