• Page:
  Rule 01. Declarations and Initialization (DCL)
• Page:
  Rule 02. Expressions (EXP)
• Page:
  Rule 03. Integers (INT)
• Page:
  Rule 04. Containers (CTR)
• Page:
  Rule 05. Characters and Strings (STR)
• Page:
  Rule 06. Memory Management (MEM)
• Page:
  Rule 07. Input Output (FIO)
• Page:
  Rule 08. Exceptions and Error Handling (ERR)
• Page:
  Rule 09. Object Oriented Programming (OOP)
• Page:
  Rule 10. Concurrency (CON)
• Page:
  Rule 49. Miscellaneous (MSC)

Rule Listing

• Page:
  AA. Bibliography
• Page:
  BB. Definitions
• Page:
  CON50-CPP. Do not destroy a mutex while it is locked
• Page:
  CON51-CPP. Ensure actively held locks are released on exceptional conditions
• Page:
  CON52-CPP. Prevent data races when accessing bit-fields from multiple threads
• Page:
  CON53-CPP. Avoid deadlock by locking in a predefined order
• Page:
  CON54-CPP. Wrap functions that can spuriously wake up in a loop
• Page:
  CON55-CPP. Preserve thread safety and liveness when using condition variables
• Page:
  CON56-CPP. Do not speculatively lock a non-recursive mutex that is already owned by the calling thread
• Page:
  CTR50-CPP. Guarantee that container indices and iterators are within the valid range
• Page:
  CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container
• Page:
  CTR52-CPP. Guarantee that library functions do not overflow
• Page:
  CTR53-CPP. Use valid iterator ranges
• Page:
  CTR54-CPP. Do not subtract iterators that do not refer to the same container
• Page:
  CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow
• Page:
  CTR56-CPP. Do not use pointer arithmetic on polymorphic objects
• Page:
  CTR57-CPP. Provide a valid ordering predicate
• Page:
  CTR58-CPP. Predicate function objects should not be mutable
• Page:
  DCL50-CPP. Do not define a C-style variadic function
• Page:
  DCL51-CPP. Do not declare or define a reserved identifier
• Page:
  DCL52-CPP. Never qualify a reference type with const or volatile
• Page:
  DCL53-CPP. Do not write syntactically ambiguous declarations
• Page:
  DCL54-CPP. Overload allocation and deallocation functions as a pair in the same scope
• Page:
  DCL55-CPP. Avoid information leakage when passing a class object across a trust boundary
• Page:
  DCL56-CPP. Avoid cycles during initialization of static objects
• Page:
  DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions
• Page:
  DCL58-CPP. Do not modify the standard namespaces
• Page:
  DCL59-CPP. Do not define an unnamed namespace in a header file
• Page:
  DCL60-CPP. Obey the one-definition rule
• Page:
  ERR50-CPP. Do not abruptly terminate the program
• Page:
  ERR51-CPP. Handle all exceptions
• Page:
  ERR52-CPP. Do not use setjmp() or longjmp()
• Page:
  ERR53-CPP. Do not reference base classes or class data members in a constructor or destructor function-try-block handler
• Page:
  ERR54-CPP. Catch handlers should order their parameter types from most derived to least derived
• Page:
  ERR55-CPP. Honor exception specifications
• Page:
  ERR56-CPP. Guarantee exception safety
• Page:
  ERR57-CPP. Do not leak resources when handling exceptions
• Page:
  ERR58-CPP. Handle all exceptions thrown before main() begins executing
• Page:
  ERR59-CPP. Do not throw an exception across execution boundaries
• Page:
  ERR60-CPP. Exception objects must be nothrow copy constructible
• Page:
  ERR61-CPP. Catch exceptions by lvalue reference
• Page:
  ERR62-CPP. Detect errors when converting a string to a number
• Page:
  EXP50-CPP. Do not depend on the order of evaluation for side effects
• Page:
  EXP51-CPP. Do not delete an array through a pointer of the incorrect type
• Page:
  EXP52-CPP. Do not rely on side effects in unevaluated operands
• Page:
  EXP53-CPP. Do not read uninitialized memory
• Page:
  EXP54-CPP. Do not access an object outside of its lifetime
• Page:
  EXP55-CPP. Do not access a cv-qualified object through a cv-unqualified type
• Page:
  EXP56-CPP. Do not call a function with a mismatched language linkage
• Page:
  EXP57-CPP. Do not cast or delete pointers to incomplete classes
• Page:
  EXP58-CPP. Pass an object of the correct type to va_start
• Page:
  EXP59-CPP. Use offsetof() on valid types and members
• Page:
  EXP60-CPP. Do not pass a nonstandard-layout type object across execution boundaries
• Page:
  EXP61-CPP. A lambda object must not outlive any of its reference captured objects
• Page:
  EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation
• Page:
  EXP63-CPP. Do not rely on the value of a moved-from object
• Page:
  FIO50-CPP. Do not alternately input and output from a file stream without an intervening positioning call
• Page:
  FIO51-CPP. Close files when they are no longer needed
• Page:
  INT50-CPP. Do not cast to an out-of-range enumeration value
• Page:
  MEM50-CPP. Do not access freed memory
• Page:
  MEM51-CPP. Properly deallocate dynamically allocated resources
• Page:
  MEM52-CPP. Detect and handle memory allocation errors
• Page:
  MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime
• Page:
  MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity
• Page:
  MEM55-CPP. Honor replacement dynamic storage management requirements
• Page:
  MEM56-CPP. Do not store an already-owned pointer value in an unrelated smart pointer
• Page:
  MEM57-CPP. Avoid using default operator new for over-aligned types
• Page:
  MSC50-CPP. Do not use std::rand() for generating pseudorandom numbers
• Page:
  MSC51-CPP. Ensure your random number generator is properly seeded
• Page:
  MSC52-CPP. Value-returning functions must return a value from all exit paths
• Page:
  MSC53-CPP. Do not return from a function declared [[noreturn]]
• Page:
  MSC54-CPP. A signal handler must be a plain old function
• Page:
  OOP50-CPP. Do not invoke virtual functions from constructors or destructors
• Page:
  OOP51-CPP. Do not slice derived objects
• Page:
  OOP52-CPP. Do not delete a polymorphic object without a virtual destructor
• Page:
  OOP53-CPP. Write constructor member initializers in the canonical order
• Page:
  OOP54-CPP. Gracefully handle self-copy assignment
• Page:
  OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members
• Page:
  OOP56-CPP. Honor replacement handler requirements
• Page:
  OOP57-CPP. Prefer special member functions and overloaded operators to C Standard Library functions
• Page:
  OOP58-CPP. Copy operations must not mutate the source object
• Page:
  Rule 01. Declarations and Initialization (DCL)
• Page:
  Rule 02. Expressions (EXP)
• Page:
  Rule 03. Integers (INT)
• Page:
  Rule 04. Containers (CTR)
• Page:
  Rule 05. Characters and Strings (STR)
• Page:
  Rule 06. Memory Management (MEM)
• Page:
  Rule 07. Input Output (FIO)
• Page:
  Rule 08. Exceptions and Error Handling (ERR)
• Page:
  Rule 09. Object Oriented Programming (OOP)
• Page:
  Rule 10. Concurrency (CON)
• Page:
  Rule 49. Miscellaneous (MSC)
• Page:
  STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator
• Page:
  STR51-CPP. Do not attempt to create a std::string from a null pointer
• Page:
  STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string
• Page:
  STR53-CPP. Range check element access