The c++coreguidelinesforsavercode

The C++ Core
Guidelines for
Safer Code
Rainer Grimm
Training, Coaching and,
Technology Consulting
www.ModernesCpp.de

Guidelines
Best Practices for the Usage of C++
 Why do we need guidelines?
 C++ is a complex language in a complex domain.
 A new C++ standard is published all three years.
 C++ is used in safety-critical systems.
Reflect your coding habits.

Most Prominent Guidelines
 MISRA C++
 Motor Industry Software Reliability Association
 Based on MISRA C
 Industry standard in automotive, avionic, and medicine domain
 Published 2008 C++03
 AUTOSAR C++14
 Based on C++14
 More and more used in automotive domain (BMW)
 C++ Core Guidelines
 Community driven

Overview
 Philosophy
 Interfaces
 Functions
 Classes and class hierarchies
 Enumerations
 Resource management
 Expressions and statements
 Error handling
 Constants and immutability
 Templates and generic programming
 Concurrency
 The standard library
 Guideline support library

Syntactic Form
 About 350 rules and a few hundred pages
 Each rule follows a similar structure
 The rule itself
 A rule reference number
 Reason(s)
 Example(s)
 Alternative(s)
 Exception(s)
 Enforcement
 See also(s)
 Note(s)
 Discussion

Guidelines Support Library (GSL)
A small library for supporting the guidelines of the C++ core
guidelines.
 Implementations are available for
 Windows, Clang, and GCC
 GSL-lite works with C++98, and C++03
 Components
 Views
 Owner
 Assertions
 Utilities
 Concepts

Interfaces
I.11: Never transfer ownership by a raw pointer (T*)
 func(value)
 func has an independent copy of value and the runtime is the owner
 func(pointer*)
 pointer is borrowed but can be zero
 func is not the owner and must not delete the pointer
 func(reference&)
 reference is borrowed but can’t be zero
 func is not the owner and must not delete the reference
 func(std::unique_ptr)
 std::unique_ptr is the owner of the pointer
 func(std::shared_ptr)
 std::shared_ptr is an additional owner of the pointer
 std::shared_ptr extends the lifetime of the pointer

Interfaces
I.13: Do not pass an array as a single pointer
 What if n is wrong?
 Use span from the GSL

Functions
F.43: Never (directly or indirectly) return a pointer or a
reference to a local object

Classes
C.2: Use class if the class has an invariant; use struct if
the data members can vary independently
 The data members can vary independently
 The data members has an invariant

Classes
C.20: If you can avoid defining any default operations, do
C.21: If you define or =delete any default operation,
define or =delete them all
Sticky Bits - Becoming a Rule of Zero Hero

Enum
Enum.3: Prefer enum classes over “plain” enums
 Can only be accessed in the scope of the enumeration.
 Don't implicitly convert to int.
 Don't pollute the global namespace.
 The default type is int, but you can adjust it.

Resource Management
R.1: Manage resources automatically using resource
handles and RAII (Resource Acquisition Is Initialization)
 RAII-Idiom (Resource Acquisition Is Initialization)
 The lifetime of a resource is bound to an automatic object.
 The resource will be initialized in the constructor of the object;
released in the destructor of the object.
 Used
 Containers of the Standard Template Library and std::string
 Smart pointers
 Locks
 std::jthread (C++20)

Expressions and Statements
ES.28: Use lambdas for complex initialization,
especially of const variables
but widget x should be const

Expressions and Statements
ES.100: Don’t mix signed and unsigned arithmetic
mixed arithmetic with GCC, Clang, and MSVC

Concurrency and Parallelism
CP.8: Don’t try to use volatile for synchronization
 std::atomic
 Atomic (thread-safe) access to shared state.
 volatile
 Access to special memory, for which read and write optimisations
are not allowed.
Java volatile C++ atomic== C++ volatile!=

Concurrency and Parallelism
CP.9: Whenever feasible use tools to validate your
concurrent code
Thread Sanitizer detects data races at runtime.
g++ threadArguments.cpp -fsanitize=thread -g –o threadArguments
skip

Error Handling
E.7: State your preconditions
E.8: State your postconditions
 Precondition: should hold upon entry in a function.
 Postcondition: should hold upon exit from the function
 Assertion: should hold at its point in the computation.

Constants and Immutability
Con.2: By default, make member functions const
The method read should be const!

Constants and Immutability
 Physical constness:
 The object is const and can not be changed.
 Logical constness:
 The object is const but could be changed.

Templates and Generic Programming
 Usage  Definition
T.10: Specify concepts for all template arguments
 Concepts are a compile-time predicate.

 Core language concepts
 Same
 DerivedFrom
 ConvertibleTo
 Common
 Integral
 Signed Integral
 Unsigned Integral
 Assignable
 Swappable
 Comparison concepts
 Boolean
 EqualityComparable
 StrictTotallyOrdered
 Object concepts
 Destructible
 Constructible
 DefaultConstructible
 MoveConstructible
 Copy Constructible
 Movable
 Copyable
 Semiregular
 Regular
 Callable concepts
 Callable
 RegularCallable
 Predicate
 Relation
 StrictWeakOrder

The c++coreguidelinesforsavercode

More Related Content

What's hot (17)

Similar to The c++coreguidelinesforsavercode (20)

Recently uploaded (20)

The c++coreguidelinesforsavercode