Introduction and course information: slides (lecture version)
Introduction to the course and some basics.

Reading material:

• Pointers and dynamic memory
  This document serves as a thorough introduction to pointers and dynamic memory conceptually. Generally it is assumed that students are familiar with these concepts from before, but if you are not then this document is a great starting point for learning how it works.

Exercises:

• Introductory labs from TDDE18:
  • Basic IO
  • Tax Table (requires you to learn IO manipulators)
  • Word Length (requires you to learn filestreams)

Recommended reading:

• UNIX terminal guide

Fundamentals I: slides (lecture version)
Fundamental concepts in C++ that are needed during the course.

Reading material:

• Explicit type conversions
  During the seminar we cover implicit type conversion, but not its counter-part: explicit type conversion. Instead I will refer to this document for an introduction to the various ways we can do explicit type conversion.

Exercises:

• Post seminar quiz
• Basic language construct exercises (question #6 and beyond)

Fundamentals II: slides (lecture version)
Pointers, References, value categories, classes/structs and operator overloading.

Exercises:

• Post seminar quiz
• Basic language construct exercises (question #2 to #5)
• Vector
• Time (lab from the course TDDE18)
• Linked List (lab from the course TDDE18)

Recommended reading:

• Slides on pointers
• Clockwise/Spiral rule (original explanation)
• Clockwise/Spiral rule (more detailed explanation)

Useful tools:

• cdecl.org - a tool that translates complicated type declarations into english!

Fundamentals III: slides (lecture version)
Lifetime, special member functions, value categories, inheritance, polymorphism, virtual functions, real-time type information (RTTI)

Exercises:

• Post seminar quiz
• Basic language construct exercises (question #1)
• Calculator
• Circuit Simulator (lab from the course TDDE18) (requires you to learn std::vector)

Templates I: slides (lecture version)
Function templates, nontype template parameters, explicit template specialization, template argument deduction, name lookup, overload resolution, compilation and linking, constexpr and auto.

Exercises:

• Post seminar quiz
• Mixed function templates exercises

C++-20 info:

• Non-type template parameters

Useful tools:

• Compiler Explorer - a tool that lets you see the generated assembler of your code, useful to see what is actually generated from your templates (remember to add the -O2 flag).

Templates II: slides (lecture version)
Class templates, partial specializations, member function templates, variadic templates, variadic recursion, static_assert, type_traits, fold expressions, namespaces.

Exercises:

• Post seminar quiz
• Static Queue
• Specialization & Type Traits
• Variadic templates

Templates III: slides (lecture version)
dependent names, template-template parameters, forwarding references, SFINAE, decltype, trailing return types, expression SFINAE

Examples:

• sum.cc (SFINAE techniques with comments)

Reading material

• Expression templates (Files: vector.cc, vector_crtp.cc)
  Templates can be used for many interesting things. In particular are they useful when writing libraries or general purpose code. But there can be some performance problems if we are not careful when designing objects that heavily rely on chaining operations together. In this document a very interesting design pattern/technique is introduced for dealing with these issues.

Exercises:

• Post seminar quiz
• Mixed Templates
• SFINAE and overload priority

STL I: slides (lecture version)
Design principles of the standard template library, streams, stream flags, std::array, std::vector, std::list, std::forward_list and std::deque, cache locality, pointer invalidation

Exercises:

• Post seminar quiz
• Custom Deque

STL II: slides (lecture version)
Iterators, iterator categories, output iterators, associative containers, container adaptors, function objects, lambda expressions

Exercises:

• Post seminar quiz
• Print all the things!

Useful tools:

• C++ Insights - a tool that reveals things that happen behind the scenes (demonstrates compiler magic).

STL III: slides (lecture version)
std::function, std::bind, std::mem_fn, iterator utility functions, reverse and const interators, stream iterators, algorithms, usages of std::copy, modifying algorithms, std::accumulate

Exercises:

• Post seminar quiz
• Mixed algorithm exercises

Sum Types in C++: slides (lecture version)
unions, std::optional, std::variant, std::any, union-like structs, placement new, basic variant implementation, aliasing, strict aliasing rules, std::launder

On launder() - Nicolai Josuttis

Formal explanation of why std::launder is needed.

Exercises:

• Custom variant

Introduction to C++20: slides (lecture version)
Introduction to the big four of C++20: Concepts, Ranges, Modules and Coroutines. This seminar primarily focuses on concepts and ranges.

Highly recommended links:

• (Video) C++20: An (Almost) Complete Overview - Marc Gregoire - CppCon 2020
• (Video) How C++20 Changes the Way We Write Code - Timur Doumler - CppCon 2020
• CppCoro - A coroutine library for C++, a library which makes coroutines useful

Learn more:

• Ranges
  • (Video) C++20 Ranges in Practice - Tristan Brindle - CppCon 2020
  • A beginner's guide to C++ Ranges and Views. - Hannes Hauswedell
• Concepts
  • C++ Concepts: More than Syntactic Requirements - Jonathan Boccara
  • C++20: Concepts, the Details - Rainer Grimm
• Modules
  • Modules in Clang 11 - Marius Bancila
  • Understanding C++ Modules: Part 1: Hello Modules, and Module Units, Part 2: export, import, visible, and reachable, Part 3: Linkage and Fragments
  • Overview of modules in C++ - Microsoft
  • Standard C++20 Modules support with MSVC in Visual Studio 2019 version 16.8 - Microsoft
• Coroutines
  • Example using CppCoro: A C++20 coroutine example - Marius Bancila
  • My tutorial and take on C++20 coroutines - David Maziéres

Threading in C++: slides (lecture version)
threading, concurrency, synchronization, deadlocks, parallelization, std::thread, std::mutex, std::jthread, std::promise + std::future, execution policies

Example code can be found here: code examples

Recommended courses: TDDE65 and TDDD56

Latest exam
Walkthrough of the new exam format. General tips for the exam and discussion on how the exam is assessed.

Reading material:

• How to study for TDDD38
  This guide closely follows what is discussed during the lecture.

Resources:

• Previous exams
• Local mirror of cppreference.com used during the exam.
  This mirror has all the language pages removed, and the search function doesn't go through DuckDuckGo or Google.com, instead it is done locally. This exact page will be available during the exam.
  Pages removed will result in any links leading to them turning red, and removed pages will not show up in the search results.

Template Design Patterns
Static polymorphism, Bridge Pattern, Generic programming, Policy pattern, allocators, Multiple inheritance, diamond problem, virtual inheritance, mixins, traits, type_traits, iterator_traits, tag dispatching, constexpr if

Exercises:

• Items (mixins)

Reading material:

• Expression templates (Files: vector.cc, vector_crtp.cc)

Dynamic Linking (Given by Filip Strömbäck)
What is dynamic linking? How does it work? What are the advantages and disadvantages with using dynamic linking?

Material
The code and all other material related to this lecture can be found here. This material cover the code that was used during the lecture, notes and also some slides for reference. If you have any questions you can E-mail filip.stromback@liu.se and he will happily answer your questions.

The C++ ABI (Given by Filip Strömbäck)
What is an ABI, System V ABI, Microsoft ABI, different implementations of: object layout, function calls, parameter passing, return values, virtual function calls, vtables, exceptions

Material
The code and all other material related to this lecture can be found here. This material cover the code that will be used during the lecture, notes and also some slides for reference. If you have any questions you can E-mail filip.stromback@liu.se and he will happily answer your questions.

Multithreading in C++ (updated with file references 2021-05-21 at 16:15, refresh the PDF-file)) (Given by Klas Arvidsson)
std::thread, std::mutex, promise and future, condition variables, packaged task, async, execution policy (multithreaded STL algorithms)

Examples:

• The examples from the lecture can be found here.