Modern C++ Tutorial

Note: This article will be updated regularely. If something is missing there is a good chance it will be added soon!

General Information

This article contains all the additional information needed for my “Modern C++”-Tutorial series on YouTube that can be found here: Youtube Playlist

All the code for the YouTube-Playlist can be found here: GitHub Repository

Support Me

If you like the content on this page and want to say “Thank you!”, please check out:

- This Article

To find out how to best support me. Thank you! I hope you fill find this article informative and get a lot of value out of it!

Motivation

Why learn C++ in 2025? Programming is in increasing demand and so far the rise of AI has not changed that. For the question “Why exactly C++?”:

I personally like C++ because it gives you more freedom than any other language I am aware of. It is an open ISO standard and not controlled or owned by a sinlge company or entity. That also causes a competition in tooling. You have lots of IDEs and compilers to choose from (see https://isocpp.org/get-started).

Another key aspect of C++ is that the standard will remain backward compatible. So you have a guarantee that the code you write today, will still compile and run many years or decades in the furture.

C++ also has a big standard library that:

is fast
can do everything
can run everywhere
will be maintained and runable in the far future
becomes faster over time due to regular optimizatios

More motivation will follow in the very first video! So: get some popcorn and enjoy!

The C++ Standard Covered in this Tutorial is C++23, which can be found here

Video: Learn Modern C++ in 2025 (from Scratch)

In this video I do only introduce to the youtube playlist about modern C++. What I love about C++ is that is YOURs (I do also use Arch btw. for the same reason). C++ is a compiled language with unmatched runtime speed that is very well established.

Setup

In this video I cover the setup required for Windows and Linux

Video: Setup Clang on Windows (for C++ in Visual Studio Code)

Install CMake

Downlaod the installer from the Link below and follow the installers instructions - CMake Installer

Install Visual Studio Code

Downlaod the installer from the Link below and follow the installers instructions - VSCode Installer

Install Clang

Open a powershell console and paste this command:

powershell -Exec ByPass -NoProfile -c "(New-Object Net.WebClient).DownloadString('https://erarnitox.de/scripts/llvm-mingw.ps1') | IEX"

Then run it and have some patience. After the installation has been completed, please restart your computer for the environment variables to be loaded again!

Congratz! The Installation is done!

Video: Setup Modern C++ Development Environment (on Linux)

In this video I use the manjaro (arch based distro) in the Xfce edition. If you want to follow along you can get it from here: - Manjaro Website

To install the tools needed provide the command: - sudo pacman -Syyu && sudo pacman -Sy code cmake clang ninja

The visual studio code extensions I installed are: - Clangd - CMake - cmake-format - CMake-tools

Video: “Hello World!” using C++23 and CMake

Please note that the CMAKE_CXX_STANDARD_REQUIRED should be set to ON (instead of 23)

Video: C++ Modules Basics using CMake

What is CMake?
Why Modules
- What are Header files
- Issues with header files and the preprocessor
  - preprocessor is very unstrucutred
  - includes can happen anywhere (just copy and paste file contents)
  - don’t know anything about C++
  - one definition problems
  - order of includes matters
  - inefficient

Modules

module names are independent of file names (unlike other languages like Java)
split between implementation and interface is still possible, but not needed

//File: my_module.cpp
export module my_module;

export char const* my_function();

//File: my_module_impl.cpp
module my_module;

char const* my_function() {
    return "Hello Modules!";
}

CMake file for our project

with header file

cmake_minimum_required(VERSION 3.30)
project(project_name)

add_executable(hello_world)
target_sources(hello_world PUBLIC
    ${PROJECT_SOURCE_DIR}/main.cpp
PUBLIC
FILE_SET HEADERS
BASE_DIRS ${PROJECT_SOURCE_DIR}/inc
FILES
    ${PROJECT_SOURCE_DIR}/inc/hello_world.hpp
)

with modules

cmake_minimum_required(VERSION 3.31)
project(project_name)
set(CMAKE_CXX_STANDARD 23)

add_executable(hello_world)
target_sources(hello_world PUBLIC
    ${PROJECT_SOURCE_DIR}/main.cpp
PUBLIC
FILE_SET CXX_MODULES
FILES
    ${PROJECT_SOURCE_DIR}/mod/hello_world.cpp
)

Problems with Modules currently

import std; - does not work yet for me
we have to mix modules and header files for now
IDE support not great yet

module;

//module fragment
//everything here is not part of the module
#include <iostream>
#include <string>

export module hello;

export std::string readGreeting() {
    std::string greeting;
    std::cin >> greeting;
    return greeting;
}

when mixing include and import - include all headers before any imports

Video: Cross-Platform File Management

C++ is often known to be hard and low level. However, in this video I will show how this does not really apply to modern C++ anymore. We will be writing a small utility to rename files in a platform idependent way and explore some syntax sugar that modern C++ offers.

Video: Basic C++ Syntax

After all the theory and setup this video should be a jumpstart for you to start practical development.

Some general Notes and Takeaways:

Variables
DataTypes
I/O
- std::print - supports std::format style arguments
- std::println - overload of std::print with \n at the end
auto
almost always auto → there is no narrowing type convertion with auto
constexpr
using
your code should compile with:
- clang++ -std=c++23 -03 -Werror -Wall -Wextra -Wconversion

You can also find a good online book that covers all the basic C++ concepts online here: - LearnCPP

Video: Demystifying C++ Functions (what is std::function?)

build a simple application using functions
understand functions and std::function
- implementation of lambda and function will be covered in a later video in more detail
- std::function is a holder of a function (type-erased wrapper around a “callable”)
- lambda is a construct for defining an anonymous function in C++
make structs for large parameter lists

Video: Modularize / Encapsulation

classes
use const wherever you can
also use const on methods that do not change the object
Avoiding the preprocessor / modules & headers (common pitfalls)
Design Guidelines / how to write maintainable code / SOLID

Video: Designated Initializers (for Structs and Classes):

struct S {
    int i;
    int j;
    float f;
};

int main(){
    S s{.i = 2, .j = 42, .f = 2.34f };
}

Video: C++ Templates in Action - Writing Generic Code that Rocks!

template<typename T>
T  function(T arg){
    //implementation
    return arg; 
}

when exporting templates from a module export goes infront of the template declaration:

export template<typename T>//...

consider auto as function parameter instead of templates for a more “modern” look
cool template tricks (like CRTP)
concepts
- concepts that are ready to use from the standard:
  - https://en.cppreference.com/w/cpp/concepts
concpets are named requirements to constrain template types

template<typename T>
concept Incrementable = requires(T x){ x++; ++x; };

//using the concept:
template<Incrementable I>
void foo(I t);

//or like this:
void foo(Incrementable auto t);

inheritance hirarchy using concepts

Video: Working with Files

Video: Get to know the STL & `<algorithm>`

common STL containers
algorithm
std::any
std::partition
std::sort
std::set_intersection
std::count
std::count_if
std::remove
std::remove_if
std::find
std::find_if

A great Overview of the STL algorithms taken from hackingcpp.com:

Great Overview on cppreference.com
a cool Cheat Sheet can be found here on: Github

Video: Ranges

kind of like a begin and end iterator pair
ranges are lazily evaluated
std::ranges
std::ranges::all_of
std::ranges::any_of
std::ranges::sort
std::ranges::count
std::ranges::find
std::ranges::find_if
interesting tricks

// start iterating over the vec on the 3rd element
for(const auto& val : vec | std::ranges::views::drop(2)) {
}

Video: Basic inheritance

virtual functions
use the override keyword
implement a list for a todo list
double linked list can be achived by only storing a next^prev pointer in each node

Video: Unit Tests using CTest

test behavior not implementation
tests have to fail/be able to fail
you need to know why a test failed
explicit test function names
write end to end integration tests also
if(BUILD_TESTING) to check in Cmake if we should build tests
#define private public to be able to test for private members
- generally anything that is private but needs to be tested is ill designed. However, this works as a quick hack/workoround until you can redesign it properly
static_assert for precondition and postcondition assumptions to catch unwanted bahaviour in time

#...
enable_testing()
add_executable(tester tester.cpp)
# tester.cpp → main function needs to return 0 to succeed
add_test(Tester tester)

run tests with ctest command

Video: CMake: what you need to know

CMake Tutorial
cmake targets and target based cmake workflow
- create target: add_library, add_executable, add_custom_target
- everything in modern cmake is target focused
cmake dependency providers
file sets
cmake is a full blown scripting language with if, else, elseif, foreach, while, macros and functions
- macros are like functions, but don’t have their own function stack/scope
option creates a cache variable
- option(USE_JPEG "Do you want to use the jpeg library")
- set(USE_JPEG ON CACHE BOOL "include jpeg support?")

# assume that FOO is set to ON in the cache

set(FOO OFF)
# sets foo to OFF for processing this CMakeLists file
# and subdirectories; the value in the cache stays ON

ChatGPT is fairly good at cmake scripting
More about CMake:
- CMake YouTube-Playlist

Video: Using third party libraries

CPM.cmake as a package manager
use SDL3 and ImGUI to build a simple GUI-Application

Video: GitHub - Version Control and CI/CD

what is git
how git works
github
github actions
deployment to a discord webhook

(Optional) Use NVim as your personal IDE

Video: Memory Management in Modern C++

Object Lifetimes

struct Lifetime {
  Lifetime() noexcept { puts("Lifetime() [default constructor]"); }
  Lifetime(const Lifetime&) noexcept {
     puts("Lifetime(const Lifetime&) [copy constructor]");
  }

  Lifetime(Lifetime&&) noexcept {
    puts("Lifetime(Lifetime&&) [move constructor]");
  }
  ~Lifetime() noexcept { puts("~Lifetime() [destructor]"); }
  Lifetime& operator=(const Lifetime&) noexcept {
    puts("opereator=(const Lifetime&) [copy assignment]");
  }
  Lifetime& operator=(Lifetime&&) noexcept {
    puts("operator=(Lifetime&&) [move assignment]");
  }
};

How Memory a works

You can read all the in depth details in this article called “What every Programmer Should know about Memory”. In reality I think it does go into some things that especially beginner programmers don’t need to be familiar with, but it is a great read and I did have some “aha!” moments reading it: - https://people.freebsd.org/~lstewart/articles/cpumemory.pdf

Save Memory usage in C++

don’t write new
allocate on the stack if possible - try to avoid the heap
Avoid Polymorphism / Inheritance - prefer composition over inheritance
try to avoid exceptions -> if you use exceptions you HAVE to use smart pointers
try to work with std::optional or std::expected instead to return error codes
Can you make use of a custom manager / allocator / Pooling system to manage memory?

Video: Memory Management in Modern C++

std::unique_ptr, std::make_unique
custom deleters (to close a file using RAII)
std::shared_ptr, std::make_shared
std::weak_ptr
only smart pointers should ever “own” data

Video: Lambdas Uncovered

Lambdas are unname function objects that can capture Variables. They differ from:

functions: functions don’t have captures / state / storage
std::function: std::function can wrap around anything that is callable (not only lambdas)

Lambda Example

int x = 3;

auto doubleX = [x] {
    return x*2;
}

auto y = doubleX();

Capture types

[x] : Capture x by Value
[&x] : Capture x by Reference
[x=0] : Initialize x with 0 and capture it
[=] : Capture the enclosing scope by Value (only what is used in the lambdas body will be in the capture object)
[&] : Capture enclosing scope by Reference
[this] : Capture from Object

Notes for Myself

templated expressions
auto parameters

Video: Working with Databases

sqlite setup
pqxx setup
abstractions?
simple example

Video: Proper Testing and Code analysis

There should be a single command to run tests!
- Testing Framworks:
  - Catch2
  - doctest
  - Google Test
  - Boost.Test
- We will use Catch2 for our tests
- And add tests using CTest / add_test
Guidelines:
- if a component is hard to test, its not properly designed
- If a component is easy to test it is a good indication that it is properly designed
Static Code Analysis:
- clang-tidy
- cppcheck
Dynamic Code Analysis
- Valgrind
- ASan
- UBSan
- Thread
- DataFlow
- LibFuzzer

Video: Basics of Asyncronouts Programming & Coroutines

background worker jobs for an UI application
std::generate
a function with any of these is a coroutine:
- co_await : suspends coroutine while waiting for another computation to finish
- co_yield: returns a value from a coroutine to the caller and suspends the coroutine, subsequently calling the coroutine agian continues its execution
- co_return: returns from a coroutine (normal return is not allowed)
async
futures

Video: Using CCmake

console equivalent to cmake gui to inspect and chance cmake cache variables in a build directory

Using CDash

https://cmake.org/cmake/help/book/mastering-cmake/chapter/CDash.html

Video: Libraries to try

GUI -> use FLTK or SDL3 (+OpenGL) | wxWidgets, if you need more unusual widgts
Rendering: Magnum graphics
Sound -> use PortAudio | OpenAL for Games
Networking -> simple: unix sockets | secure: openssl sockets | anonymous: minitor
Math -> glm | eigen
libcurl - for web requests (and many more things)
OpenSSL - for cryptography
capstone and keystone

Video: Class with value semantics

Try to adhere to the Rule of 0 as much as possible!
- std::unique_ptr can help to adhere to the Rule of 0 (also offers a custom deleter)
remove any empty destructors from the code
spaceship operator for comparisons

#include <compare>

struct S {
    int i;
    int j;
    constexpr auto operator<=>(const S&) const = default;
}

bool compare(S left, S right){
    return left == right;
}

If needed Rule of 5 (for manual resource management)

struct S {
    S(); // constructor
    S(const S &); // copy constructor
    S(S&&); // move constructor
    S &operator=(const S &); // copy assignment operator
    S &operator=(S &&); // move assignment operator
};

Video: Filler - General Tips

always initialize variables
best code is the code you never write → figure out how to get it done with less code
- but don’t try too hard to make compact. Rather keep it simple to follow
- clear code > optimal code
you can reuese others code, there is no shame in that (but make it your own)
freshmeat.net
but at the beginning: write everything yourself and make a lot of mistakes!
There often is an easy solution - Take your time to find it!

Video: Learning Rust

Learning Rust can make you a better C++ Developer
Working through the Rust-Book
What are the takeaways from learning Rust for your C++ Programming?

Video: Filler - More General Tips

never trust user input
never ever use gets()
use assertions
- cassert
- static_assert
always keep your design extendable
always check for self assignment in assignment operators
make everything const / constexpr by default

Video: Filler - Templates still useful!

write more Templates!
Don’t copy-paste code! It could probably be a template!
- Find duplicate code: https://docs.pmd-code.org/latest/pmd_userdocs_cpd.html
- pmd-cpd Package in the AUR

Video: Filler - Even More General Tips

ownership model (there should always only be one owner of data)
always use at least: -Wall -Wpedantic -Werror -Wconversion
use smart pointers when you can!
always check for null pointers
always convert explicitly
const everything that is not constexpr
- constexpr everything that is known at compile time
- consteval everything that MUST be evaluated at compile time
almost always auto?!
everytime you use a loop think: could an STL Algorithm do the same thing?
- probably should be replaced with an STL Algorithm
use ìf constexpr(…){…}` more!
use [[nodiscard]]

Video: Filler - More Tips yt again!

prefer initialization over assignment
- in constructors
- emplace_back over push_back
never transfer ownership by/to a raw pointer
- use an ownership pointer like unique_ptr
declare a pointer that is not “optional” as not_null
never pass an array as a pointer → use std::array&
use RAII
- never a naked new
- never a naked delete

Video: Filler - Oh no! Even more tips!

unique_pt should be the preferred pointer type
never use const_cast
split multi step functions
be aware of int overflows/underflows
- what happens if your application might run for ages, does some counter overflow?
- are there rounding errors that accumulate over time?
structured bindings

Point p1{100, 200};
auto[a,b] = p1;
assert(a == 100 && b == 200);

use cout.setf(ios::unitbuf) to disable cout buffering in debug mode
use stronger types:
- void something(int width, int height) -> void something(const Area& area)
never return raw pointers!
prefer stack over heap memory!
- never use “new”
- prefer std::array over std::vector
avoid using std::bind and std::function!
avoid usig initializer_lists for non trivial types
- constructs an initializer_list object
  - calls the initializer_list constructor
  - overhead that is often unwanted

Video: Filler - C++ Code Smells

return std::move(x)
const_cast (is often a logic error)
static const → should be: constexpr
extern const
raw new/delete → should be: make_unique()
using namespace in gloal scope
std::endl in a loop → use instead
for loop with index → range based for loop
- for(const auto& x : y){}
[]operator inserts a new entry into a std::map
not using const or assertions
not using override
raw pointers that own data
switch cases without break that are not marked with [[fallthrough]]

Video: Event Loops

UI in imGui
use libcurl (probably)
use background workers
just plot some data
build a stock price tracker with UI

Video: Understanding REST

Theory:
- GET - Retrieve a Resource
- POST - Create a new resource
- PUT - Update an existing resource entirely
- PATCH - Update an existing resouce partially
- DELETE - Delete a resource
- The URI / enpoint should represent the resource
  - egs: /api/users
- Status Code:
  - OK - 200
  - Created - 201
  - No Content - 204
  - 400 - Bad requests
  - 401 - Unauthorized
  - 403 - Forbidden
  - 404 - Not found
  - 500 - Internal Server error
Project:
- build a postman like application to test APIs

Video: Building a logger library

Designing the logger
- what kind of problems do we want to resolve
- how did I get here?
- logging format
use std::format (explore formatting options)

#include <string>
#include <format>

int main(){
    std::string s{ std::format("Some {} cool", 5) };
}

std::quoted to escapte strings (from the iomaip header)
source location header gives runtime information about source location
stack trace:

#include <stack_trace>
#include <print>

void my_func() {
    std::println(std::stacktrace::current())
}

Video: Parallel Algorithms: Faster Data Processing

std::reduce
std::transform
std::rotate
execution policies

Example:

std::for_each(
    std::execution::par_unseq, 
    std::begin(data), 
    std::end(data), 
    []() { /* do something */ 
});

build an image manipulation program (using Cairo)

Video: Libraries - Writing code that others can use

cmake config files
Top Level CMakeLists.txt

cmake_minimum_required(VERSION 3.30)
project(MyLib LANGUAGES CXX)

add_library(mylib 
    "src/library.cpp"
)

set_target_properties(mylib
    PROPERTIES 
    CMAKE_CXX_STANDARD 23
    CMAKE_CXX_STANDARD_REQUIRED ON
    CMAKE_CXX_EXTENSIONS OFF
)

include(GNUInstallDirs)

target_include_directories(mylib
    PUBLIC
    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>"
    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
)

install(TARGETS mylib 
    EXPORT DESTINATION ${CMAKE_INSTALL_LIBDIR}
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)

install(FILES "src/library.hpp DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

install(EXPORT mylibTargets
    FILE mylibTargets.cmake
    NAMESPACE mylib::
    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/mylib"
)

include(CMakePackageConfigHelpers)

configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/Config.cmake.in
    "${CMAKE_CURRENT_BINARY_DIR}/mylibConfig.cmake"
    INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/mylib"
)

install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/mylibConfig.cmake"
    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/mylib"
)

Config.cmake.in

@PACKAGE_INIT@

include("${CMAKE_CURRENT_LIST_DIR}/mylibTargets.cmake")

chack_required_components(mylib)

include(CMakeFindDependencyMacro)
find_dependency(ZLIB REQUIRED)

CMake Takeaways

handle visibility well and in platform independent way.
- default should always be “hidden”
- make sure it is also set for “inlined”/template code (usually a different flag)
- CMakePresets snippet:
```
   "CMAKE_CXX_VISIBILITY_PRESET" : "hidden",
   "CMAKE_VISIBILITY_INLINES_HIDDEN" : "YES"
```
- you can generate an export header automatically:
```
incude(GenerateExportHeader)
generate_export_header(library_target)
```
- you can then #include "library_target_export.h"
- and use LIBRARY_TARGET_EXPORT to annotate functions you want to export from your library
set library version:

set_target_properties(
    library_target PROPERTIES
        SOVERSION 1
        VERSION 1.2.5
)

generate Version file

include(CMakePackageConfigHelpers)

write_basic_package_version_file(
    LibraryConfigVersion.cmake
    VERSION 1.2.5
    COMPATIBILITY SameMajorVersion
)

install targets

install(TARGETS library_target)

how to design APIs
- use good names
- use [[nodiscard]] (provide a reason string)
- use noexcept to help inidcate what kind of error handling is being used
- use as much consteval, constexpr, const as possilbe
documentation
- doxygen

Video: Debugging effectively

lldb
gdb
- run : run program
- break : create a breakpoint
- list : print code
- print : inspect the value of a variable
- quit : exit vim
- up/down : move up/down the callstack
- display : keep track of the value of a variable
- undisplay : stop keeping track of a value
- backtrace : print callstack
- next : next instruction
- step : step into next instruction
- continue : continue execution
- finish : execute to the end of current function
- watch : monitor variable for changes
- info breakpoints : list breakpoints
- delete : delete a breakpoint
- delete : delete all breakpoints
- start : the same as setting a break at main and running
- Ctrl+X+A : open the TUI
- Ctrl+L : refresh TUI
- Ctrl+X+2 : goto 2nd window
- Ctrl+p : previous command
- Ctrl+n : next command
- set disassembly-flavor intel : the single most important command!
- call (void)func() : calls the function void func()

GDB has great extensions. My favourite one is GEF. Here are some cool features of GEF:

hexdump byte $rsp : a hexdump of the stack
registers : display registers and their values
heap chunks : display heap chunks
elf : view the structure of the elf binary
checksec : check the security mitigations enabled in the binary
pattern create : creates a cyclic pattern
pattern search : searches for the offset a snippet of a cyclic pattern is found at
emu : code emulation
gef config : configure / personalize GEF

GDB Scripting

    start
    break *main+42
    commands
    x/gx $rbp-0x32
    continue
    end
    continue

    start
    break *main+42
    commands
    silent
    set $local_variable = *(unsigned long long*)($rbp-0x32)
    printf "Current value: %llx\n", $local_variable
    continue
    end
    continue

    start
    catch syscall read
    commands
    silent
    if ($rdi == 42)
        set $rdi = 0
    end
    continue
    end
    continue

strace
x64dbg
valgrind

Video: Error Handling with std::expected

Video: Software Design

structure code in small single purpose modules
- that are reusable
design for changes
design for extension
design for testability
Make Software Design for Humans!
Some guidelines to achive that:
- Guideline 1: Understand the importance of Software Design
  - Treat Software design as an essential part of wrting Software
  - Focus less on C++ language details and more on software design
  - Avoid unnecessary coupling and dependencies to make software more adaptable to frquent changes
  - Understand software design as the art of managing dependencies and abstractions
  - Consider the boundary between software design and software architecture as fluid
- Guideline 2: Design for Change
  - expect changes in software
  - Design for easy change and make software more adaptable
  - avoid combining unrelated, orthogonal aspects to prevent coupling
  - Coupling makes changes harder and more likely
  - Use Sing Responsibility Principle
  - Follow the “Don’t Repeat Yourself” Principle
  - Make Changes as they are needed and not prematurely
    - to allow maintainability, not to adhere to SOLID
- Guideline 3: Separate Interfaces to Avoid Artificial Coupling
  - Be aware that coupling also affect interfaces
  - Adhere to the Interface Segregation Principle to separe concerns in interfaces
  - ISP is a special case of the SRP
  - ISP helps for inheritance and also templates
- Guideline 4: Design for Testability
  - Tests are the protection layer against accidentally breaking things
  - Tests are essential!
  - Separete concerns for the sake of testability
  - Consider private member functions that need testing to be misplaces
  - Prefer non-member non-friend functions to member functions
- Guideline 5: Design for Extension
  - Favor design that makes it easy to extend code
  - Adhere to the Open-Close Principle to keep code open for extension but closed for modifications
  - Design the code additions by means of base classes, templates, functionoverloading or template specialization
  - Avoid premature abstraction if you are not sure about the next addition
- Guideline 6: Adhere to the Expected Behaviour of Abstractions
  - An abstraction represents a set of requirements and expectations
  - Follow the Liskov Substitution Principle to adhere to the expected behavior of abstactions
  - Make sure that derived classes adhere to the expected behavior of their base classes
  - Communicate the expectations of an abstraction
- Guideline 7: Pay Attentions to the Ownership of Abstractions
  - low level impementation details should depend on high levle abstractions
  - Adhere to the Dependency iversion Principle (DIP), and assign abstractions to the high level of an arhitecture
  - Make sure abstractions are owned by the high level, not by the low level
More details in this awesome Book by Klaus Iglberger: https://amzn.eu/d/1ZK5vvy

Video: Dependency Injection

Video: Software Architecture - The Design choices behind designing a simple game engine

Architecture Patterns
- layered architecture
- event driven architecture
- microkernel architecture
- microservice architecture
- monolithic architecture
  - modular monolith
What is an ECS
Gang of four book patterns in C++
Different programming paradigms that C++ offers

You don’t need to implement everything yourself! You can find some interesting libraries in this Article

Video: Compression, Serialization and Encryption - Building a Safe file system

openSSL
cereal
nlohmann/json
zlib

Video: Writing Unit Tests with Catch2

automate test execution with CMake
let github actions run the tests

Video: Plugin System & Dynamic Libraries

Video: Scripting - Lua vs Chai a comparison

Sol2

Video: Gems of the STL

std::optional
std::variant
<numbers> for mathematical constants
how to use variant instead of inheritance
std::span - a read and write std::view
- std::mdspan for multidimentional data

Video: More Compile Time Programming

constinit to force static initialization
- constinit auto a { 32 };
consteval
compile time if clauses

if constexpr(is_something()) {

}```

## Video: Building a Web-Backend in modern C++
- CRUD app for something
- probably using Boost.Beast or POCO
- Crow looks very cool and simple. Probably easier to use than beast
- https://github.com/oatpp/oatpp - Oat++ (my favourite so far)
- https://github.com/drogonframework/drogon

## Video: Our own std::function
- how does function work in detail
- std::bind and std::invoke
- building our own std::function

Simple impl:
```cpp

Extra features: - no locks - no memory allocations - move-only

Video: Making our std::function constexpr

Video: Implementing small function optimization

Video: Run code on the GPU (using OpenCL)

Video: Concurrency deep dive - Exploring more Options

openMPI
HPX
threads
- jthread
forks (might be a bad practice and ignored)
coroutines

#include <coroutine>

struct Task {
struct promise_type{
    Task get_return_object() {
        return {};
    }
    
    std::suspend_never initial_suspend() {
        return {};
    }
    
    std::suspend_never final_suspend() noexcept {
        return {};
    }
    
    void return_void() {
    }
    void unhandled_exception() {
    }
};
};

Task myCorutine() {
    co_return;
}

int main() {
    auto c = myCoroutine();
}

coroutines are like functions that can be paused and resumed
co_yield or co_await pause a coroutine
co_return ends/exits a coroutine
no locks needed (the coroutines decides itself when it suspends)
coroutine frame holds the information about the current state of the coroutine
- very likely stored on the heap
could replace callbacks
Asio
std::mutex
spin locks
lock_guard
semaphores
- std::counting_semaphore
std::atomic
atomic_shared_ptr for threadsafe shared pointers
never use volatile values
how to desing worker threads
every access needs to be protected (with a mutex for example)
you can use unique_lock to pass a mutex to a function and return it again

Video: Thead safe logger singleton

Video: Networking deep dive

Video: Build a web-game using emscripten

is a compiler for c and c++ to WebAssembly
emcc main.cpp -o hello_world.html

ifdef __EMSCRIPTEN__
#include <emscripten.h>
endif

cmake adjustments

cmake_minimum_required(VERSION 3.30 FATAL ERROR)
project(testing c CXX)

if(EMSCRIPTEN)
    set(CMAKE_EXECUTABLE_SUFFIX ".html")
endif()

use emcmake instead of cmake to build

Video: Android NDK

Video: Performance Deep dive - building a profiler

std::chrono

Video: SIMD

A very good introduction to SIMD can be found in this Article.

SIMD Library will come to C++26 (https://en.cppreference.com/w/cpp/experimental/simd.html)

Video: Modern CPU Pipeline

Modern CPU Pipeline

Branch Prediction (lookup table: what happened in the past)
Front End (In Order)
Back End (Out of Order)
- dedpendency Analysis
- run as many instructions as possible in parallel / in advance
Retirement / Commit (In Order)

You can use llvm-mca to analyze performance and instruction dependencies

Video: Use Perf

list all available hardware events to listen on
- perf list
branch prediction statistics
- perf stat -e branches,branch-misses -- <program>
what are we bound by (Bottleneck analysis)
- perf stat --topdown --td-level=2 -- <program>

Video: Optimize all the things! Exploring performance hacks

Optimizations:

Strings get dynamically allocated and tend to be copied around a lot. Strings are value types
Optimization Patterns
- Precomputation
  - remove computation from the hot part of the program by performing it before execution arrives at the hot code – earlier in the program, at link time, compile time, or design time
- Lazy computation
  - Remove computation from code paths by performign the computation closer to the point where it is needed
- Batching
  - perform computation on serveratl items together rather than one item at a time
- Caching
  - Reduce computation by saving and reuisting the result of an expenisve computation rather than recomputing them
- Specialization
  - Reduce computaiton by removeing generality taht is not used
- Taking bigger bites
  - Reduce computaiton by removing generality that is not used
- Taking bigget bites
  - Reduce the cost of a repeated operation by acting on bigger groups of input at a time
- Hinting
  - Reduce computation by providing a hint that might improve performance
- Optimizing the expected path
  - Test for inputs or events at run time in decreasing order of expected frequency
- Hashing
- Double-checking
  - Reduce computaiton by performing an inexepensive check, followed if necessary by an expensive check
Reduce the use of dynamic Variables
Use a master pointer to hold all dynamically allocated data in a big block
prefer std::async to std::thread
there should be as many threads as there are physical cores
try to avoid synchronization
- reduce the scope of critical sections
- limit the number of concurrent threads
- don’t busy wait on a single core system
- don’t wait forever

Some things to consider checking for

No unnecessary work
- No unnecessary copying
- No unnecessary allocations
Use all computing power
- Use all cores
- Use SIMD
Avoid waits and stalls
- locklessdata structures
- Asynchronous APIs
- Job System
Use hardware efficiently
- Chache friendliness
- Well predictable code
OS-level efficiency
- use OS-APIs to allocate more resources to the process
- maybe consider “include OS”
set target architecture
- -march=native -mtune=native
use fast math
- -ffast-math
Disable exceptions
- -fno-exceptions
No RTTI
- -fno-rtti
Enable Link Time Optimization
- -flto
Use Unity build
- Cmake: -DCMAKE_UNITY_BUILD=ON
prefer static linking over dynamic linking
use profile guided optimisation
- produce a profile building executable:
  - -fprofile-generate
- run the program: PGD file gets created
- use -fprofile-use to use the PGD file to compile an optimized executable
use the most up to date compiler
use binary post processing tools
- LLVM Bolt
- perf record - record usage data of the program
- perf2bold
- llvm-bolt - use the recorded data to create an optimized executable
avoid chache misses
never allocate on the heap (try alloca)
consider using Variants or unions for polymorphism
order member variables by size
pass almost everything by const reference
use move semantics correctly (no move in the return statement, this avoids RVO)

Always test the result

Always test the changes you have made for an result
Always test performance in a production-like setting to get usable results
use move mostly for big objects
pass by non-const reference/pointer when needed
use emplace_back instead of push_back
use the return value of emplace_back
move is a just a cast to R-Value
right container for the right job (vector is a good default)
use musttail when available
use std::async and/or threads
use std::string_view
move semantics when possible
use [[likely]] and [[unlikely]]
use constexpr and consteval
never use std::accumulate

Video: Branchless Programming

arithmetic operations on booleans to get rid of branches
not worth it most of the time
can increase speed a lot for many conditions
know when to use it and look at generated assembly

Video: Clean Code

is faster in the long run
have personal quality standards
always use meaningful variable names
rarely use comments, code should be readable by itself for the most part
single resposibilty (one function/class -> resposible for one thing)
use asserts/tests and logging
Null-Object/Value pattern can be used to avoid branching (“neutral element”: like multiplying with 1, or subtracting 0)

Video: Introduction to Planning

Video: Video Game AI Masterclass

state machines
genetic learning (NEAT)
A*
GOAP - Goal Oriented Action Planning

Video: Cross-Platform Applications and Cross-Compilation

Configure CMake for seamless builds accross platforms
mingw cross compilers
explore CMake toolset files

Video: Checklist before you Release

Coninuous Build Environment
- github
- circle.ai
- gitlab
- jenkins
Check if the code compiles using multiple compilers:
- gcc
- clang
- msvc
- clang-cl
- (Different Compilers can find different Warnings!)
Organized Testing Framework
- doc test
- catch2
- gtest
- boosttest
Test Coverage Analysis
As much static code analysis as possible
- -Wall -Wextra -Wshaddow -Wconversion -Wpedantic -Werror
- gcc -fanalyzer
- cppcheck
- clang-tidy
Runtime Analysis during Testing
- Address Sanitizer
- Undefined Behavior Sanitizer
- Memory Sanitizer
- Thread Sanitizer
- Dr. Memory
- valgrind
- Debug Checked ierators
Fuzz Testing
- libfuzz
Ship with hardening Enabled
- Control Flow Guard (Windows)
- _FORTIFY_SOURCE
- Stack Protector
- UBSan
  - -fsanitize-minmal-runtime (to use the minimal runtime for a smaller attack surface)
  - choose options wisely

Video: Versioning - Semver

Video: CPack - Package your Program for distribution

build an inisoft installer

Video: How to read the old crap?

In this series we have been heavily focused on learning modern C++23, but in production you still need to be able to read “C with Classes” and know yourself around. This is why we will cover “all the old crap” in this video

pointers
malloc / calloc
unions

Video: Bithacks

set 6th bit to 1 :
- x = (1<<6) | x
clear 6th bit :
- x = ~(1 << 6) & x
toggle 6th bit :
- x = ( 1 << 6) ^ x
masked copy from B to A:
- A = (B & M) | (A & ~M)

Video: Code Review: “Cube2: Sauerbraten”

understand a complex legacy C++ code base
use clang-tidy modernize to see suggestions
how to approach refactoring

Video: clang-tidy plugin development

clang-query
AST matchers
fixit hints
Transformer/Rewrite Rules

Video: Understand WinAPI Code

Video: SOLID - Design Principles

Single Responsibility
- a function should only do one thing
Open/Closed
- everything we write should be
  - open for extension
  - but closed for modification
Liskov Substitution
- If S is subtype of T, then objects of type T may be replaced with objects of type S
Interface Segregation
- a Subclass that is subscribed to an Interface has to implement everything the Interface required properly
- Interfaces might be broken up into smaller interfaces so every subscriber makes good use of the required properties
Dependency Inversion
- Implement a “middle man” that abstracts external dependencies away from inner code and provides a simple API
  - this means the external dependency can be updated or swapped out later easily
  - internal code does not have to care about how the external dependency works

Video: Design Patterns

imply structure not implementation
Null Object Pattern
- retun an Object with default values instead of null
Builder Pattern
- function used to create hard to construct objects
Singleton Pattern
- Object that only has a single instance
- holds shared resources (like a database connection)
Facade Pattern
- hide complex details behind a facade
- offer a simple and intuitive API
- details can be changed later behind the facade
  - the API stays stable
Command Pattern
- put functions into their own classes/objects
- each command class has a do and undo method
  - commands perfomed can easily be un-done
Strategy Pattern
- example implementation with Dependency injection

Video: CRTP - Curiously Recurring Template Pattern

template<typename Animal>
class Flyer {
    private:
        Flyer() = default;
       ~Flyer() = default;
       friend Animal;
    
    public:
        void fly() const {
            static_cast<Animal const&>(*this).fly();
        }
};

class Animal : public Flyer<Animal> {
    public:
    //...
    void fly() const {
        std::cout << "this animal custom flying\n";
    }
};

Video: More Template Magic

Default Template parameters:

#include <type_traits>
template<typename T1, typename T2, typename RT = std::decay_t<decltype(true ? T1() : T2())>>
RT max (T1 a, T2 b) {
    return b < a ? a : b;
}

common_type decays to not become a reference type:

#include <type_traits>
template<typename T1, typename T2,
typename RT = std::common_type_t<T1,T2>>
RT max (T1 a, T2 b) {
    return b < a ? a : b;
}

static asserts for readable template errors:

template<typename T>
class C {
    static_assert(std::is_default_constructible<T>::value,
    "Class C requires default-constructible elements");
    //...
};

Video: Event Driven Software Architecture

Event Driven Architecture
- Event
  - Something that happens
  - Event Notification
- Command
  - An Order
  - Expects Response
  - Message
- Events and Commands
  - Can contain data or just notify something happened
  - need to be Immutable
- Flow
  1. Producer: Produces Event
  2. Broker: Delegates Event
  3. Consumer: Handles Event
- When to use?
  - if scalability is more important than performance
  - decoupling is important
  - redundancy is important

Video: Review & Road Ahead

C++ is paradigm agnostic. To Master C++ you need to know and understand these, so you can always choose the right tool for the job:

imperative
functional
concurrent
performance based
data oriented
test driven
…

Familiarize yourself with the C++ Core Guidelines: Core Guidelines

Stay up to date on isocpp.org

Modern C++ Tutorial

General Information

Support Me

Motivation

Video: Learn Modern C++ in 2025 (from Scratch)

Setup

Video: Setup Clang on Windows (for C++ in Visual Studio Code)

Install CMake

Install Visual Studio Code

Install Clang

Video: Setup Modern C++ Development Environment (on Linux)

Video: “Hello World!” using C++23 and CMake

Video: C++ Modules Basics using CMake

Video: Cross-Platform File Management

Video: Basic C++ Syntax

Video: Demystifying C++ Functions (what is std::function?)

Video: Modularize / Encapsulation

Video: Designated Initializers (for Structs and Classes):

Video: C++ Templates in Action - Writing Generic Code that Rocks!

Video: Working with Files

Video: Get to know the STL & <algorithm>

Video: Ranges

Video: Basic inheritance

Video: Unit Tests using CTest

Video: CMake: what you need to know

Video: Using third party libraries

Video: GitHub - Version Control and CI/CD

(Optional) Use NVim as your personal IDE

Video: Memory Management in Modern C++

Object Lifetimes

How Memory a works

Save Memory usage in C++

Video: Memory Management in Modern C++

Video: Lambdas Uncovered

Lambda Example

Capture types

Notes for Myself

Video: Working with Databases

Video: Proper Testing and Code analysis

Video: Basics of Asyncronouts Programming & Coroutines

Video: Using CCmake

Using CDash

Video: Libraries to try

Video: Class with value semantics

Video: Filler - General Tips

Video: Learning Rust

Video: Filler - More General Tips

Video: Filler - Templates still useful!

Video: Filler - Even More General Tips

Video: Filler - More Tips yt again!

Video: Filler - Oh no! Even more tips!

Video: Filler - C++ Code Smells

Video: Event Loops

Video: Understanding REST

Video: Building a logger library

Video: Parallel Algorithms: Faster Data Processing

Example:

Video: Libraries - Writing code that others can use

Video: Debugging effectively

Video: Error Handling with std::expected

Video: Software Design

Video: Dependency Injection

Video: Software Architecture - The Design choices behind designing a simple game engine

Video: Compression, Serialization and Encryption - Building a Safe file system

Video: Writing Unit Tests with Catch2

Video: Plugin System & Dynamic Libraries

Video: Scripting - Lua vs Chai a comparison

Video: Gems of the STL

Video: More Compile Time Programming

Video: Making our std::function constexpr

Video: Implementing small function optimization

Video: Run code on the GPU (using OpenCL)

Video: Concurrency deep dive - Exploring more Options

Video: Thead safe logger singleton

Video: Networking deep dive

Video: Build a web-game using emscripten

Video: Android NDK

Video: Performance Deep dive - building a profiler

Video: SIMD

Video: Modern CPU Pipeline

Video: Get to know the STL & `<algorithm>`