C++: A Wild Ride (2024-09-30 - 2024-10-04)

“New” vs. “Old” C++: An Overview

C++ is a huge pile of language constructs built on top of each other, always backwards compatible with its origins. In 2011, C++ got a major overhaul which is still ongoing. It is not always easy for someone who is new to C++ to understand why things are how they are.

A Live-Hacked Tour Around The New C++ tries to draw the boundary between the old and new C++.

“New” C++: Syntactic Goodies (Pythonicity)

From New Language Features:

• Range Based for Loops: Introduction

• Duck Typing (Err, auto) Without A Duck

• Tuple Unpacking (Err, Structured Binding)

• Brace Initialization (Uniform Initialization)

  • Brace Initialization: Introduction

  • std::initializer_list: Brace Initialization, Implementor’s View

  • Brace Initialization: A Mess

• Strongly Typed enum

• Delegating Constructor

Back To The Beginnings Of C++: What Everybody Has To Know

From C To C++

From Data Encapsulation

• Object Oriented Programming In Good Ol’ C

• Classes and Objects

• Custom Constructor

• Constructors: Member Initialization

• Default Constructor

• = default

• Copy Constructor, Assignment Operator

• = delete

• More Constructors, Destructors

• Object Copy (And Resource Management): There Be Dragons

Classes And Methods (And Functions)

From Functions and Methods

• Overloading

• Methods

• this

• References

• static Methods

• static Member Variables

• Operator Overloading

Templates

From C++ Template Basics

• Function Templates

• Class Templates

Exercises

• Sensor classes, independent types

• A (template) function to calculate the average of a number of sensor instances

• Sensor “configuration”: a std::map (see “New” vs. “Old” C++: An Overview how this is done) of shape sensor-name -> sensor*, encapsulated in a class

  ⟶ Unit Testing With googletest

Inheritance, And Interfaces

From Inheritance And Object Oriented Design

• Inheritance Basics

• Inheritance: private, protected (Implementation Inheritance)

• Virtual Methods

• Polymorphic Usage Of Objects

• Destructors And Inheritance

• Virtual Destructors

• C++ “Interfaces”

Exercises

• Refactoring

  • Sensor classes, being-an interface type

  • Funtion average() accepts different kinds of sensors

  • Sensor config, ditto

• Data logger, initial version.

  Everybody has understood how average() works (using the sensor interface). Write a program that take a sensor configuration, and repeatedly writes measured values to std::cout.

Overengineering (Err, OO Design)

Exercises

What’s bad about logging to std::cout? (Answer: not easily replaced with different logging targets.)

Dependency Injection and Dependency Inversion (and the Strategy Pattern) are different words for one things: software structure.

Idea …

• Define another interface: logging target (and make std::cout logging its first concrete implementation)

  Discuss MQTT, or SQLite3, …

• Define a data logger main loop class

More Design Patterns

From Design Patterns With C++:

• Singleton

• Adapter

• Proxy

• Composite

• Builder

More C++ >= 11

OO Features

• override

• final

• = delete

• = default

Memory Management

From Smart Pointers (std::unique_ptr, std::shared_ptr):

• Introduction

• std::shared_ptr, and std::weak_ptr

• std::unique_ptr

• Smart Pointers: Closing Words

Exercise

Convert all interface usage to std::shared_ptr<> (Sensor*, LoggingTarget*)

Move Semantics, And Perfect Forwarding

From Move Semantics, Rvalue References:

• Lvalues, Rvalues, And Moving

• Implementing Move Semantics (class String, Live Hacked)

• Using Move Semantics In Own Code

• Afterword, Further Reading

Same syntax, different meaning …

• Perfect Forwarding

Exercise

Convert all interface usage to std::unique_ptr<> (Sensor*, LoggingTarget*)

Functional: An Alternative To Full Polymorphism

• std::function

• Lambda

Going Embedded

• Embedded Problems? Code Bloat? Type Erasure? Solutions?

• CRTP

Optional Topics

• constexpr

• Standard Template Library

• Excerpts from CMake: Introduction and CMake: Advanced Topics

• Multithreading

• From Performance

  • Optimization

  • Optimizations: Compute Bound Code

  • Optimizations: Memory Optimizations

• Warum sollen c-casts vermieden werden?

• Projektaufbau

• Verwendung von statischen Libraries? -> CMake

• Projekt review