C++ Programming Slides

Crash course docker and development containers. Problem statement and how to create a reproducible development environment. Getting started with docker and development containers.

Hello, world! Why C++? A brief history. Compilation model. Core guidelines and static analysis.

Working with a devcontainer. Manually compiling using clang. Old style includes vs modern style modules. Using buildsystem CMake. Compiler warnings and clang-tidy.

User input. Variables and Types. Initialization and Conversion. While, for, if, switch. Functions. Const and constexpr. Vector as a general purpose list.

How to use the labo 2 devcontainer. See digitap for exercise assignments.

STL containers: std::array, std::unordered_map, std::span. Compile-time, link-time and run-time errors. Exceptions. Avoiding and finding errors. Design by contract.

How to use the vscode debugger? See digitap for exercise assignments.

Some C++ technicalities. References, function overloading and value categories. Object Oriented Programming. Classes, enums, RAII, operator overloading. The rule-of-5.

Designing the Date class. Operator overloading. Making it possible to create dates at compile time. std::chrono. See digitap for exercise assignments.

Abstract base classes and interfaces. Pure virtual functions. Virtual destructors. Overriding functions. Copy and Move in polymorphic inheritance hierarchies.

Solutions Labo 1-4. Static constexpr, std::size_t, static_cast, std::optional, designated initializers. Exercises runtime polymorphisms. See digitap for exercise assignments.

Creating a vector of references to store polymorphic objects. What are the call stack and the heap? Memory fragmentation. Working safely with dynamic memory by using std::unique_ptr.

Using the heap to dynamically create polymorphic objects. See digitap for exercise assignments.

Function objects: overloading operator() to create functions with state. Lambdas: concise function objects. The capture list. Mutability. Algorithms, ranges and views.

Creating lambdas. Using standard algorithms, ranges and views. See digitap for exercise assignments.

Preventing name collisions and ODR violations by using namespaces. The unnamed namespace. Modules and module fragments. Global scope, translation unit scope and module scope.

How to use the labo 8 devcontainer. The Catch2 testing framework and how to run tests in vscode. Writing modules and unit tests. See digitap for exercise assignments.

Meta-programming to avoid code duplication. Class and function templates. Non-type template arguments. Using auto for function arguments. Restricting template arguments using concepts.

Class templates, function templates and concepts. See digitap for exercise assignments.

Smart pointers and raw pointers. Manual memory management and the ownership problem. Making custom containers work with STL algorithms using iterators. Dynamic array as an example.

Working with pointers and raw new and delete. See digitap for exercise assignments.

Hello, world! Why C? A brief history. Comparing C to C++. Standard input and output

How to use the labo 11 devcontainer. No exercises, work on project.

Naming mangling. Creating C++ functions that can be used in C code. How to make C header files compatible with C++. Inline assembly. Memory mapped devices as objects.

No exercises, work on project.