Modern Robotics C++ Notes (C++17 / C++20 / C++23)

Welcome to our Modern C++ Course, specifically tailored for Engineers focusing on Robotics.

Table of Contents

1. Module 01: Foundations & Compilation
   • Compilation Pipeline
   • Header Inclusion & #pragma once
   • One Definition Rule (ODR)
   • First Program Anatomy
   • Build Systems (CMake)
   • Understanding Errors
   • Cementing Foundation: Heartbeat
2. Module 02: Variables, Types & Constants
   • Type Reference
   • Fixed-Width Integers (<cstdint>)
   • Robotics Structs
   • Naming Rules
   • Scope & Shadowing
   • Namespaces
   • auto Deduction
   • const vs constexpr
   • Deep Dive: Const Correctness
   • std::string vs std::string_view
   • Cementing Foundation: Config Manager
3. Module 03: I/O & Arithmetic
   • Performance Checklist: I/O
   • Modern C++23 Formatting: std::println
   • Deep Dive: std::chrono — Timing
   • Cementing Foundation: Telemetry Math
4. Module 04: Control Flow
   • Cementing Foundation: State Controller
5. Module 05: Loops & Iteration
   • Storing Data: std::vector
   • Vector Mechanics: Size vs. Capacity
   • Vector Iterators & Ranges [begin, end)
   • Element Access: operator[] vs at()
   • Vector Optimization: reserve()
   • Fixed-Size Data: std::array
   • Deep Dive: STL Algorithms
   • STL Algorithms: std::minmax & std::count_if
   • Erasing Vector Elements: std::erase_if
   • Iterator Invalidation
   • Deep Dive: Real-Time Golden Rule
   • Cementing Foundation: Cloud Filter
6. Module 06: Structs & Enums
   • POD Structs
   • enum vs enum class
   • Cementing Foundation: Telemetry Pack/Unpack
7. Module 07: Memory & Ownership
   • Memory Bridge: Interlude
   • Pointers vs. References
   • Deep Dive: Pointer Const-ness
   • Manual Memory (new/delete)
   • Smart Pointers
   • RAII & Ownership
   • Move Semantics
   • Rule of Zero
   • The Ownership Decision Tree
   • Cementing Foundation: Hardware Factory
8. Module 08: Functions & Lambdas
   • Parameter Passing
   • inline Functions & Variables
   • Lambdas & Locality
   • Using Predicates in Algorithms
   • [[nodiscard]] Attribute
   • RVO Optimization
   • Lidar Filter Challenge
   • Safe Returns (std::optional)
   • C++ Exception Handling & Stack Unwinding
   • C++23 Monadic std::expected<T, E>
   • [[maybe_unused]] Attribute
   • Cementing Foundation: Safety Callback
9. Module 09: Project Structure & CMake
   • What is CMake?
   • Anatomy of CMakeLists.txt
   • The Build Workflow
   • Unit Testing (GTest)
   • Cementing Foundation: Architecture
10. Module 10: Classes & Encapsulation
    • State & Behavior
    • Interaction & Safety
    • Object Identity (this)
    • Creation & Destruction
    • Advanced Mechanics
11. Module 11: Templates & Polymorphism
    • Why Templates Exist
    • Good vs Bad Template Usage
    • Polymorphism in Robotics
    • Template vs Virtual Dispatch
    • Deep Dive: Fold Expressions
    • Cementing Foundation: Sensor Pipeline
12. Module 12: Concurrency
    • Why Concurrency Matters
    • Threads
    • Mutex and lock_guard
    • Multi-Mutex Safety: std::scoped_lock
    • Readers-Writer Locks: std::shared_mutex
    • join vs detach
    • Waiting for Events: condition_variable
    • Asynchronous Tasks: std::async & std::future
    • Concurrency Pitfalls
    • Lock-Free Primitives: std::atomic
    • Cementing Foundation: Telemetry Worker
13. Module 13: Production Deployment & Tooling
    • Static Analysis & Sanitizers
    • Time-Series Data: Bounded Sliding Window
    • Advanced CMake: PUBLIC vs PRIVATE
    • Thread-Safe Logging
    • Error Reporting: std::error_code
    • Static Analysis: clang-tidy
    • Cementing Foundation: Production Checklist
14. Module 14: Advanced Utilities (variant, any, tuple)
    • std::variant: Type-Safe Union
    • std::any: Type-Safe void*
    • std::tuple & Structured Bindings
    • std::invoke & std::function
    • std::filesystem
15. Module 15: Performance & Profiling Checklist
    • Performance Golden Rules
    • Senior Performance Internals
    • Profiling Tools & Workflow
16. Module 16: Capstone — Multi-Threaded Sensor Pipeline
    • Architecture Overview
    • Full Implementation
    • CMakeLists.txt with Sanitizers
    • Unit Tests (GTest)
    • Profiling Workflow
17. Appendix A: Real Robotics Failure Case Studies
18. Appendix B: Production Design Patterns
19. Appendix C: Testing Discipline
20. Appendix D: ROS 2 Senior Insights

Module 01 — What is C++? Compilation & Your First Program

Phase: Foundations

C++ is a high-performance, compiled language created by Bjarne Stroustrup. In robotics, it is the industry standard for real-time systems, providing "zero-cost abstractions" that allow for high-level code with maximum hardware efficiency.

[!NOTE] Design Philosophy: This module is designed to demystify the "black box" of how code reaches hardware. Robotics involves diverse hardware (ARM/x86); if you don't understand the Linker vs. Compiler, you will be paralyzed by the first library error you hit in ROS.

[!NOTE] Modern C++ (C++17): This course focuses specifically on the C++17 Standard, which introduced critical robotics features like std::optional, std::string_view, and structured bindings.

In the world of Robotics, C++ is the undisputed king. It provides zero-cost abstractions—high-level features that compile into highly efficient machine code. When processing point clouds from a LIDAR at 10Hz or calculating inverse kinematics for a robot arm in under a millisecond, performance is critical.

Who Uses This In The Real World?

• Tesla Autopilot — Real-time sensor fusion and vehicle control systems.
• Open Robotics (ROS) — ROS 2 core is written in C++ for real-time distributed systems.
• Boston Dynamics — Control software for Atlas and Spot.
• NVIDIA Isaac — Accelerated robotics simulation and AI pipelines.

How C++ Code Becomes a Robot Action (Compilation Pipeline)

Before we write code, it's crucial to understand how your text becomes a robot action.

Header Inclusion & #pragma once

In robotics frameworks like ROS 2, modular software is broken into header files (.hpp / .h) and source files (.cpp). During compilation, the preprocessor textually pastes the content of every #include directive into the translation unit.

If multiple files include the same header (e.g., IMUSensor.hpp included by both Controller.cpp and Telemetry.cpp), the compiler might attempt to declare the same class or struct multiple times, resulting in redefinition errors.

Traditional Include Guards vs #pragma once

Legacy Guards Example:

#ifndef ROBOTICS_SENSORS_IMU_HPP
#define ROBOTICS_SENSORS_IMU_HPP

struct IMUData {
    double ax, ay, az;
    double gx, gy, gz;
};

#endif // ROBOTICS_SENSORS_IMU_HPP

Modern Best Practice:

#pragma once

struct IMUData {
    double ax, ay, az;
    double gx, gy, gz;
};

[!TIP] Industry Rule in ROS 2: Always put #pragma once at the very first line of every header file to prevent multi-inclusion build failures and accelerate CMake compile times.

Deep Dive: The One Definition Rule (ODR)

The One Definition Rule (ODR) is a foundational C++ rule that dictates how entity definitions exist across translation units (TUs) during compilation and linking.

The Three Canonical Rules of ODR

1. Within a Single Translation Unit: An entity (variable, function, class/struct, enum) can have at most one definition.
2. Across the Entire Program (Non-Inline Entities): Global variables and non-inline functions must have exactly one definition across all object files (.o). Violating this produces a Linker Error (multiple definition of ... or duplicate symbol).
3. Across Translation Units (Inline & Types): Class types, structs, enums, inline functions/variables, and template definitions can appear in multiple translation units—provided every definition is token-for-token identical.

ODR Violation & Linker Crash Matrix

Real-World Robotics ODR Pitfall (Linker Error):

// ❌ BAD: LidarUtils.hpp (Header file)
#pragma once

// Linker error if included by more than one .cpp file!
int global_lidar_count = 0; 

void reset_lidar() { 
    global_lidar_count = 0; 
}

Correct Modern C++ Fix:

// ✅ GOOD: LidarUtils.hpp
#pragma once

// inline variables (C++17) and inline functions allow safe multi-TU inclusion!
inline int global_lidar_count = 0; 

inline void reset_lidar() {
    global_lidar_count = 0;
}

Your First Robot Program

Let's write a simple program that outputs the status of a robot.

Code Example

#include <iostream>

int main() {
    std::cout << "[Robot System] Initializing sensors... OK\n";
    std::cout << "[Robot System] Ready for C++17 Robotics!\n";
    return 0;
}

Anatomy of the Program (Key Term