CPP20

C++20/23 Programming Guidelines

Core Principles & Philosophy

• RAII (Resource Acquisition Is Initialization): Manage resources (memory, files, locks, sockets) through objects whose destructors automatically release the resource.
• Value Semantics: Prefer passing and returning objects by value when copying is cheap and makes sense, promoting clarity and avoiding lifetime issues.
• Const Correctness: Use const extensively for variables, pointers/references, and member functions that do not modify observable state.
• Type Safety: Leverage the C++ type system. Avoid C-style casts; use C++ casts (static_cast, dynamic_cast, const_cast, reinterpret_cast) appropriately and sparingly.
• Standard Library First: Prefer using components from the C++ Standard Library (std) over custom implementations or C-style approaches.
• Zero-Overhead Principle: Don't pay for what you don't use. Use language features efficiently.

Modern C++ Features (C++11/14/17/20/23)

• Use auto for type deduction where it improves readability, but use explicit types for clarity in interfaces or complex expressions.
• Range-Based for Loops: Use for iterating over containers (for (const auto& item : container)).
• Smart Pointers: Use std::unique_ptr for unique ownership and std::shared_ptr for shared ownership. Avoid raw new and delete for owning pointers.
• Move Semantics: Understand and utilize move constructors and move assignment operators (often implicitly generated) for efficient resource transfer. Use std::move explicitly when transferring ownership.
• Lambdas: Use lambda expressions for inline functions, especially with standard library algorithms.
• nullptr: Use nullptr instead of 0 or NULL for null pointers.
• enum class: Prefer strongly-typed, scoped enumerations (enum class) over unscoped enum.
• Structured Bindings (C++17): Use for unpacking tuples, pairs, or struct/class members (auto [key, value] = myMap.begin();).
• if constexpr (C++17): Use for compile-time conditional code based on template parameters.
• std::optional (C++17): Use for representing optional values, replacing nullable pointers or magic values.
• std::variant (C++17): Use for type-safe unions.
• std::string_view (C++17): Use for non-owning, read-only views of character sequences, avoiding unnecessary string copies.
• std::filesystem (C++17): Use for portable filesystem operations.
• Concepts (C++20): Use to constrain template parameters, improving template error messages and expressing design intent.
• Ranges (C++20): Utilize the ranges library (std::ranges) for more composable and expressive algorithms.
• Coroutines (C++20): Use for cooperative multitasking and asynchronous operations (generators, async/await patterns).
• Modules (C++20): Consider using modules for better encapsulation and potentially faster compile times (compiler/build system support varies).
• std::format (C++20): Prefer over iostreams or C-style formatting for type-safe and efficient string formatting.
• std::span (C++20): Use for non-owning views of contiguous sequences (like arrays, vectors).
• std::expected (C++23): Consider for functions that can return either a value or an error, as an alternative to exceptions or std::optional + error code.