Course contents (draft)

Week 1

Session 1: Introduction to the command-line, first steps

• what is C++, relationship with C
• the command-line
• navigating the filesystem
• invoking the compiler
• using an editor: micro (or notepad++)
• writing our first hello_world.cpp
• including standard headers
• Basic data types: bool, int, float, double
• the std::string class
• command-line arguments
• the std::vector class
• range-based for loop
• regular for loop
• type inference: the auto keyword
• conditional execution: the if statement
• statements and compound statements
• basic error handling

Exercises TODO

Session 2: first project, input/output, functions

• Introduce DNA shotgun sequencing project
• std::cin, std::cout, std::cerr and their use
• reading data from file: std::iftream
• (const) references
• Using algorithms from the C++ Standard Template Library: std::min(), std::max()
• writing data to file: std::ofstream
• Using and defining functions
• returning values from functions

Exercises TODO

---

Week 2

Session 1: multi-file project, error handling

• type aliasing
• defining separate header and cpp files
  • compiling and linking
  • what is a translation (compilation) unit
  • header guards and #pragma once
  • difference between using inverted commas "" and angled brackets <> in #include directive
• the role of the preprocessor
• automated build systems
  • what they are and why we need one
  • Make, CMake, Ninja, ...
  • introduce our custom oop_build script
• Error handling using C++ exceptions
• More practice with functions and string handling
• More on using STL algorithms: iterators
• the while loop
• do-while loop

Exercises TODO

Session 2: debugging, advanced string formatting

• adding debugging functionality to our project
  • More command-line handling: options
  • variable scope: global, block, function
  • namespaces
  • the inline keyword and the One Definition Rule
• advanced string formatting using std::format()
• grouping data into a struct
• returning multiple values from functions using C++17 structured binding
• using std::string_view to avoid copies

Exercises TODO

---

Week 3

Session 1: classes

• Introducing classes
  • methods
  • class constructor
  • access specifiers
  • initialiser list
• Default function arguments
• Constructor delegation (aka constructor chaining)
• the const keyword:
• for variables
• for function arguments
• for methods
• why pass by const reference
• OOP features:
  • encapsulation
  • abstraction

Session 2: fMRI project

• more practice with:
  • basic program structure and command-line argument handling
  • file handling and loading data
  • error handling and debugging
  • creating a class
• handling multidimensional data arrays
• new concepts:
  • list (uniform) initialisation
  • casting operators
  • getters and setters
  • command-line globbing and wildcards

Exercises TODO

---

Week 4

Session 1: introduction to operator overloading and templates

• more practice with:
  • handling command-line arguments and options
  • file handling
  • writing functions
• using external libraries
  • simple example of using an external header-only library: Donald's terminal_graphics project
• function overloading
• overloading the subscript or array indexing operator
• overloading the function call operator
• overloading the stream insertion operator
• class templates
• the <cmath> header and associated functions

Session 2: lambda expressions

• lambda expressions
• use of lambda expressions with the C++ Standard Template Library (STL)
• the C++20 std::ranges library
• function templates
• finishing touches to fMRI project

Exercises TODO

---

Week 5

Session 1:

• inheritance
• virtual functions
• difference between virtual and overloaded functions
• static / dynamic binding
• pure virtual functions
• abstract and concrete classes
• class vs. object vs. instance

Session 2:

Exercises TODO

---

Week 6

Session 1: Object-oriented design

• aggregation, composition, inheritance
• object lifetime & ownership
• OOP design principles (SOLID):
  • DRY (Don’t repeat yourself)
  • Encapsulate What Changes
  • Open Closed Design Principle
  • Single Responsibility Principle
  • Dependency Injection or Inversion principle
  • Favor Composition over Inheritance
  • Liskoff substitution principle
  • Interface Segregation Principle
  • Programming for Interface not implementation
  • Delegation principles
• UML overview
• UML class diagrams
• typical workflow for the OOP design
  • blog abour OOP design process

Session 2: Peer marking

• Peer marking
• go through solution and marking scheme
• ...?

---

Week 7

Session 1:

Session 2:

Exercises TODO

---

Week 8

Session 1:

Session 2:

Exercises TODO

---

Week 9

Session 1:

Session 2:

Exercises TODO

---

Week 10

Session 1: pointers and manual memory management

• pointers
• C-style arrays
• C-style string handling
• new / delete
• memory leaks
• double free
• array new[] & delete[]
• using constructor / destructor / copy constructor / assignment operator to manage memory

Session 2:

Exercises TODO

---

---

Topics not yet covered:

• switch statement
• jump statements: break and continue
• conditional (ternary) operator (?:)
• Resource Acquisition Is Initialization (RAII)
• the function stack
• recursion
• categories using enumerated types (enums)
• class destructor
• multi-line comments and why they're usually best avoided
• dynamic vs. static type checking
• std::array
• difference between std::vector::operator[] and std::vector::at() in terms of bounds checking
• expressions with mixed types, implicit type casting, integer promotion, ...
• destructors
• static data members
• copy constructor
• virtual functions
• pure virtual functions
• abstract and concrete classes
• inheritance vs. composition
• member function overloading
• difference between virtual and overloaded functions
• static / dynamic binding
• OOP design - REQUIRES A LOT OF THOUGHT!
• UML
• composition / aggregation / inheritance
• operator overloading
• friend functions
• operator overloading: global or member?
• this pointer
• overloading the assignment operator
• runtime vs. compile-time/static polymorphism
• object lifetime & ownership
  • relationship to composition & aggregation, etc.
• OOP principles: encapsulation, polymorphism, inheritance, abstraction
• OOP design principles (SOLID):
  • DRY (Don’t repeat yourself)
  • Encapsulate What Changes
  • Open Closed Design Principle
  • Single Responsibility Principle
  • Dependency Injection or Inversion principle
  • Favor Composition over Inheritance
  • Liskoff substitution principle
  • Interface Segregation Principle
  • Programming for Interface not implementation
  • Delegation principles

---

Open questions:

• how use inheritance in a meaningful way without pointers?
  • should be fine using references instead
• how to demonstrate aggregation without pointers?
  • can demonstrate construction of member (const) reference
  • note that non-const references are not recommended in the C++ Core Guidelines
    • but only because this makes the class copy-constructable, but not copy-assignable
    • if anything, highlights issues of ownership and lifetime, which are a serious problem with aggregation
• blog abour OOP design process
  • how to teach design?
  • how to assess design?

---

NOT covered in course:

• Why not use pointers and manual memory management? See recommendations in this video:
  • Kate Gregory: Stop Teaching C
  • and these blog posts:
    • C++ Will No Longer Have Pointers
    • Raw Pointers Are Gone!
    • No New New: Raw Pointers Removed from C++
    • Deprecating Raw Pointers in C++20
    • No more pointers