Track 02 · Intermediate · Free
Modern C++17, templates and CMake: the heart of ROS 2 C++.
Phase 3 teaches modern C++ (C++11 to C++17): smart pointers, move semantics, lambdas, the STL, threads and the C++17 vocabulary types. Phase 4 covers templates and generic programming. Phase 5 covers CMake, gdb and clang-tidy, which every ROS 2 package depends on.
Prerequisite: C++ Beginner, or comfort with classes, pointers, references and virtual functions.
You will be able to
How the compiler deduces types, auto with references and const, and structured bindings.
45–60 minOpen lessonExclusive ownership, make_unique, transferring ownership and returning from functions.
45–75 minOpen lessonShared ownership, reference counts, weak observers and breaking cycles.
60–90 minOpen lessonTransferring resources instead of copying, and the rule of five.
60–90 minOpen lessonAnonymous functions, [=] vs [&] vs explicit captures, and lambdas as callbacks.
60–90 minOpen lessonChoosing between the standard containers and their costs.
60–90 minOpen lessonExpressing intent with <algorithm> instead of hand-written loops.
45–75 minOpen lessonThe five iterator categories and what each one allows.
45–75 minOpen lessonClocks, time points, durations, and typed time literals.
45–60 minOpen lessonStarting threads, joining them, data races and protecting shared data.
60–90 minOpen lessonRunning work in the background and collecting the result later.
45–75 minOpen lessonValues that may be missing, and values that are one of several types.
45–75 minOpen lessonStoring any callable, callback members and the cost of type erasure.
45–60 minOpen lessonstd::is_same, std::is_integral, enable_if and compile-time type questions.
45–75 minOpen lessonComputing values at compile time, constexpr functions and constexpr if.
45–60 minOpen lessonType parameters, deduction, explicit arguments and when templates fail to compile.
45–75 minOpen lessonGeneric containers and value types, template arguments and class template deduction (C++17).
60–90 minOpen lessonFull and partial specialization, and overriding the generic behaviour for one type.
45–75 minOpen lessonSubstitution failure is not an error: enable_if and choosing overloads by type.
60–90 minOpen lessonPolicies, tag dispatch, CRTP and writing small generic algorithms.
60–90 minOpen lessoncmake_minimum_required, project, add_executable and an out-of-source build.
45–75 minOpen lessonLibraries as targets, target_link_libraries and PUBLIC vs PRIVATE.
60–90 minOpen lessonadd_library STATIC and SHARED, position-independent code, and runtime paths.
45–75 minOpen lessonFolder layout, add_subdirectory, tests and a public include tree.
60–90 minOpen lessonfind_package, imported targets, FetchContent and pkg-config.
60–90 minOpen lessonDebug builds, breakpoints, stepping, backtraces and watching variables.
60–90 minOpen lessonFinding bugs without running the code, and using compile_commands.json.
45–75 minOpen lessonA ring buffer class template holding any sample type, protected by a mutex so a producer thread and a consumer thread can share it safely.
template <typename T, std::size_t N>
class RingBuffer {
std::array<T, N> data_{};
public:
bool push(const T& v);
};Wrap a fake serial device in a move-only RAII type that can never leak or double-close its handle, and transfer it between owners with std::move.
class Device {
int fd_{-1};
public:
Device(Device&& o) noexcept : fd_{std::exchange(o.fd_, -1)} {}
~Device() { if (fd_ >= 0) ::close(fd_); }
};One templated interpolator that works for scalars, 2D points and 6-axis joint vectors, built as a CMake library with unit tests.
template <typename P>
P lerp(const P& a, const P& b, double t) {
return a + (b - a) * t;
}Free course
27 lessons · 3 phases · self-paced. Curriculum aligned with the ISO C++ reference material and verified September 2026.
ISO C++ resources