Hide menu

TDDD38 Advanced Programming in C++

Seminars

To find the slides for previous format of the course, see this page.

Due to administrative reasons we had to rescale the total number of points for module #2 and module #3 (DAK2 and DAK3). This leads to a rescaling of the grading thresholds. Note that this does not effect the results from DAK1 what-so-ever.

The rescaling means that DAK1, DAK2 and DAK3 are all worth 10 points (so the course total is 30, not 25). This does not change the planned organization of the exams, all that really has changed is how many points each assignment is worth during the exam and it rebalances the modules so they all contribute equally to your final grade.

See the examination information page for the new grade thresholds.

This page serves as the main page for all the relevant course material. The slides for each seminar is given together with relevant reading material, exercises, tools and other relevant things.

Note that the published slides have extra material compared to the lectures.

Intro lecture 

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

Reading material:

  • Guide for studying
    This page discusses in depth how to succeed in this course and its examination. Please read through it and take it seriously. This course is a self-study course so you will have to practice discipline to actually learn the contents and this guide give suggestions and insights into how this can be done.

  • Lecture slides on pointers from TDDE18
    If you are new to C++ or C you can read through these slides to get a basic grasp of memory and pointers before moving on to the more advanced document below.

  • 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 (see slides linked above), but if you are not then this document is a great starting point for learning how it works.

Exercises:

Recommended reading:

Seminar 1 

Fundamentals I: slides (lecture version)
Data types, implementation-defined behaviour, function overloading, implicit type conversion and IO.

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:

Seminar 2 

Fundamentals II: slides (lecture version)
Compound types (struct and class), memory layout of objects, constructors, operator overloading and value categories.

Exercises:

Seminar 3 

Templates I: slides (lecture version)
References, function templates, nontype template parameters, explicit template specialization, template argument deduction, overload resolution, compilation and linking.

Exercises:

C++-20 info:

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).
Seminar 4 

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

Exercises:

Recommended exam assignments:

Seminar 5 

Templates III: slides (lecture version)
dependent names, SFINAE, decltype, trailing return types, expression SFINAE, concepts, requires cluases, requires expressions

Exercises:

Recommended exam assignments:
Solve using both SFINAE and concepts.

Extra 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.

Seminar 6 

Optimizations & restrictions: slides (lecture version)
As-if rule, copy elison, (named) return value optimization, destructors, copy- and move semantics, five special member functions, rule of five and rule of zero

Exercises:

Seminar 7 

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:

Seminar 8 

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

Exercises:

Recommended exam assignments:

Useful tools:

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

STL III: slides (lecture version)
STL algorithms and STL ranges

Exercises:

Recommended exam assignments:

Every previous exam has at least one assignment with the keyword "STL algorithm" in it. All of those are appropriate, solve them using both STL algorithms and STL ranges.

Seminar 10 

Advanced memory I: slides (lecture version)
Dynamic and static memory, one definition rule

Exercises:

Seminar 11 

Advanced memory II: slides (lecture version)
Unions, non-trivial union members, placement new, strict aliasing, variant, general-purpose storage, std::launder
Bonus: operator new and operator delete as member functions, STL allocators

Exercises:

Recommended exam assignments:

Seminar 12 

Advanced constructs I: slides (lecture version)
forwarding references, reference collapsing, smart pointers, ownership models, std::unique_ptr and std::shared_ptr

Recommended exam assignments:


Page responsible: Christoffer Holm
Last updated: 2026-04-26