Lecture script

• First keywords
• What brackets mean
• What do different signs mean
• Intro to "scopes"
• Intro to functions
• Intro to includes

Homework script

• Write a simple program that prints Hello World!
• Learn to compile and run simple programs

Lecture script

• How to create variables of fundamental types
• Naming variables
• Using const, constexpr with variables
• References to variables

Lecture script

• Namespaces with variables
• The word using with variables

Lecture script

• std::cout, std::cerr, std::cin

Lecture script

• Sequence containers: std::array, std::vector, their usage and some caveats
• Pair container: std::pair
• Strings from STL: std::string
• Conversion to/from strings: to_string, stoi, stod, stof, etc.
• Aggregate initialization

Lecture script

• std::map and std::unordered_map
• Touch up on std::set and std::unordered_set

Homework script

• Write a program that tells your C++ fortune
• It reads and writes data from and to terminal
• Stores and accesses these data in containers

Lecture script

• if, switch and ternary operator
• for, while and do ... while

Lecture script

• What are random numbers
• How to generate them in modern C++
• Why not to use rand()

Homework script

• A program that generates a number
• The user guesses this number
• The program tells the user if they are above or below with their guess (or if they've won)

Lecture script

• Useful compilation flags
• Debugging a program with:
  • Print statements
  • lldb debugger

Lecture script

• What is a function
• Declaration and definition
• Passing by reference
• Overloading
• Using default arguments

Lecture script

• What are enums
• How to use them?
• Why not to use old style enums

Lecture script

• Different types of libraries
  • Header-only
  • Static
  • Dynamic
• What is linking
• When to use the keyword inline
• Some common best practices

Lecture script

• Intro to build systems
• Build commands as a script
• Build commands in a Makefile

Lecture script

• Build process with CMake
• CMake Variables
• Targets and their properties
• Example CMake project

Lecture script

• Explain what testing is for
• Explain what testing is
• Show how to download and setup googletest
• Show how to write a simple test

• Disclaimer
• What does find_package do?
  • Search modes
    • Module mode
    • Config mode
  • How do the config files look like?
  • What are the export files?
  • Summary of reusing targets
• How to make core_project available to dependent_project
  • Project skeleton for core_project
  • Installing a package
    • 1. Copying headers
    • 2. Copying binaries
    • 3. Creating export files
    • 4. Creating config files
• How to use the installed package
• Summary

Homework script

• You will write library that allows to split and trim strings
• You will learn how to:
  • Write a CMake project from scratch
  • Write your own libraries
  • Test them with googletest
  • Link them to binaries

Lecture script

• Explain why the classes are needed
• Implement an example game about a car
• Define classes and structs more formally

Lecture script

• The pointer type
• Pointers = variables of pointer types
• How to get the data?
• Initialization and assignment
• Using const with pointers
• Non-const pointer to const data
• Constant pointer to non-const data
• Constant pointer to constant data

Lecture script

• Creating a new object
• What happens when an object dies
• Full class lifecycle explained

Lecture script

• Why we care about move semantics
• Let’s re-design move semantics from scratch
• How is it actually designed and called in Modern C++?

Lecture script

• “Good style” as our guide
• What is “good style”
• Setting up the example
• Rule 1: destructor
• Rule 2: copy constructor
• Rule 3: copy assignment operator
• Rule 4: move constructor
• Rule 5: move assignment operator
• Now we (mostly) follow best practices
• Rule of 5 (and 3)
• The rule of “all or nothing”

Lecture script

• What stays the same
• What is different
• Example to show it all

Lecture script

• What is const correctness
• Some rules and examples to follow in order to work with const correctly

Homework script

• You will write a library that allows to pixelate an image
• You will learn how to:
  • Work with classes
  • Use external libraries
    • Read images from disk using stb_image.h
    • Draw stuff in the terminal using FTXUI library
  • Manage memory allocated elsewhere correctly
  • Writing multiple libraries and binaries and linking them together
  • Manage a larger CMake project

Lecture script

• Why we should not use static outside of classes
• Relation to storage duration
• Relation to linkage
• Why we should use inline instead

Lecture script

• Using static class methods
• Using static class data
• What is static in classes useful for?

Lecture script

• Templates provide abstraction and separation of concerns
• Function templates
• Class and struct templates
• Generic algorithms and design patterns
• Zero runtime cost (almost)
• Compile-time meta-programming
• Summary

Lecture script

• Compilation process recap
• Compiler uses templates to generate code
• Hands-on example
• Compiler is lazy

Lecture script

• The basics of writing a function template
• Explicit template parameters
• Implicit template parameters
• Using both explicit and implicit template parameters at the same time
• Function overloading and templates
• Full function template specialization and why function overloading is better

• How to use templates with classes in C++
• Class method templates
  • Prefer overloading to specialization of class method templates
  • Sometimes overloading is not possible --- specialize in this case
• Class templates
• Class template argument deduction (min. C++17)
  • Class template specialization: implicit and explicit
  • Full explicit template specialization
    • How to fully specialize class templates
    • Make sure a specialization follows the expected interface
    • Historical reference for std::vector<bool>
    • Specialize just one method of a class
    • Specialize method templates of class templates
    • Type traits and how to implement them using template specialization
    • More generic traits using partial specialization
  • Difference between partial and full specializations
    • How to tell partial template specialization apart from a new template class definition?
    • How to tell a partial template specialization apart from a full class template specialization?
  • Partial template specialization with more types
• Summary

• The forwarding reference
• Why use forwarding references
  • Example setup
  • How forwarding references simplify things
  • When to prefer forwarding references
• How forwarding references work
  • Reference collapsing
  • Remove reference using std::remove_reference_t
  • How std::forward works
    • Passing an lvalue
    • Passing by rvalue
• Summary

• Why linker fails
  • Compilation process for single main.cpp file
  • Compilation process for multiple files
• How to fix the linker error
• More complex explicit instantiations
• Summary

• Inheritance enables dependency inversion
• The idea behind dependency inversion
• Similarity to static polymorphism with templates
• How inheritance looks in C++
  • Implementation inheritance
    • Access control with inheritance
    • Implicit upcasting
    • Real-world example of implementation inheritance
  • Using virtual for interface inheritance and proper polymorphism
  • How interface inheritance works
  • Runtime and memory overhead of using virtual
  • Things to know about classes with virtual methods
    • A virtual destructor
    • Delete other special methods for polymorphic classes
  • Downcasting using the dynamic_cast
  • Don't mix implementation and interface inheritance
  • Implement pure interfaces
  • Keyword final
• Simple polymorphic class example following best practices
• Multiple inheritance
• Detailed Image example following best practices

• Memory management and smart pointers
• Memory management in C++
  • Automatic memory management in other programming languages
  • The C++ way
• Memory allocation under the hood
  • The stack
  • Why not keep persistent data on the stack
  • The heap
    • Operators new and delete
• Typical pitfalls with data allocated on the heap
  • Forgetting to call delete
  • Performing shallow copy by mistake
  • Performing shallow assignment by mistake
  • Calling a wrong delete
  • Returning owning pointers from functions
• RAII for memory safety
  • STL classes use RAII
  • Smart pointers to the rescue!
    • std::unique_ptr
    • std::shared_ptr
      • Prefer std::unique_ptr
  • Smart pointers are polymorphic
• Summary

• Lambdas
• Overview
• What is a "callable"
• A function pointer is sometimes enough
• Before lambdas we had function objects (or functors)
• How to implement generic algorithms like std::sort
• Enter lambdas
• Lambda syntax
• When to use lambdas
• Summary

• Disclaimer
• What Do We Mean by “Error”?
• Setting up the example: a comparison game
  • Rules of the game
  • Initial code of the game
• Unrecoverable errors: fail early
  • Our first unrecoverable error encounter
  • How to deal with unrecoverable errors
    • Catch them as early as possible
    • Use CHECK macro to fail early
    • Don't use assert
    • Complete the Game class yourself
  • How to minimize number of unrecoverable errors
• Recoverable errors: handle and proceed
  • Exceptions
    • How to use exceptions
    • A case for exceptions for both "recoverable" and "unrecoverable" errors
    • Why we might not want to use exceptions
      • Exceptions are (sometimes) expensive
      • Exceptions hide the error path
      • Exceptions are banned in many code bases
  • Returning errors explicitly can work better if done well
    • Returning a value indicating error does not always work 😱
    • Returning an error code breaks "pure functions" 😱
    • Using std::optional: a better way
    • Using std::expected: add context
  • Performance Considerations for std::optional and std::expected
    • Error type size matters
    • Return value optimization with std::optional and std::expected
  • Summary
  • Other use of std::optional

• std::variant in Modern C++
• Templates (and concepts) allow static polymorphism
• Until now dynamic polymorphism required reference semantics
• Use std::variant for dynamic polymorphism with value semantics
  • Basics of std::variant
  • Memory used by std::variant
  • Use std::monostate to allow for "empty" variants
  • Storing values in a std::variant
  • Using std::variant with std::visit
  • How std::visit selects the correct function
  • Visitor must cover all variant types
• Back to the original example
• Summary

• std::function
• Overview
• The problem: storing callables
• Enter std::function
• Performance considerations
• Type erasure (how it works under the hood)
• Summary

• Parallelism in modern C++
• Disclaimer
• What is parallelism anyway?
  • No parallelism is always safer and often faster
  • High-level Task-Based Parallelism
  • Execution Strategies (std::launch)
  • Parallel Algorithms
  • Execution Policies (std::execution)
  • Raw TBB Parallelism
  • Worker threads and thread pools
    • Step 1: How to create a thread
    • Stopping threads cooperatively with std::stop_token
    • Step 2: Adding another thread and a Mutex
    • Step 3: Sleeping with Condition Variables
      • Optimizing by Swapping the Queue
    • Step 4: Putting it all together into a Generic Thread Pool
  • What if I don't have C++20?
  • Deadlocks
• Summary