C++: A New Language Starting In 2011 (2022-10-11 - 2022-10-13)

Metadata

• Live-Hacking, and exercise material on Github: 2022-10-11

• Also on Github: entire homepage

Course Preparation

We will be doing a number of exercises and trainer livehacking sessions. All this is done starting from a skeleton Github project.

Please try and get the skeleton project, create an environment that works for you, and test-build that project.

Work Environment

I suggest you use the Windows Subsystem For Linux (WSL2) (Microsoft documentation here). This sets up a virtualized Ubuntu insode Windows, together with all interoperability wazoo.

It is also possible to setup a Linux-like environment on native Windows, using the following emulation layers

• Cygwin

• MinGW (known to have problems when it comes to threading)

Skeleton Project

The project uses CMake and googletest. Ideal work anvironment is Linux(-like). If you have such an environment, then the steps to build the project are,

• Clone and massage the project source

  $ pwd
  $ /home/jfasch/src       # <--- your mileage will vary
  $ git clone https://github.com/jfasch/2022-10-11.git
  $ cd 2022-10-11/
  $ git submodule init
  $ git submodule update
  

• Create build directory, and chdir there

  $ mkdir /tmp/2022-10-11-build
  $ cd /tmp/2022-10-11-build
  

• Use CMake to create makefiles

  $ pwd
  /tmp/2022-10-11-build
  $ cmake /home/jfasch/src/2022-10-11
  

• Build

  $ pwd
  /tmp/2022-10-11-build
  $ make
  

Introduction

• A Live-Hacked Tour Around The New C++

Pythonicity (Thank You: Readablility and Writability)

Range Based for Loops

• Range Based for Loops: Introduction

• Case Study: Range Based for On std::map

Tuple Unpacking (err, Structured Binding)

• Tuple Unpacking (Err, Structured Binding)

Duck Typing (err, auto) Without A Duck

• Duck Typing (Err, auto) Without A Duck

Exercise

• Exercise: Bag Of Items, By Copy

Things That Simply Deserved Fixing Since Ages

Brace Initialization

From Brace Initialization (Uniform Initialization)

• Brace Initialization: Introduction

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

• Brace Initialization: A Mess

New OO keywords: override, final, default, delete

• override

• final

• = delete

• = default

Strongly Typed enum

• Strongly Typed enum

Delegating Constructor

• Delegating Constructor

nullptr

• Miscellaneous

Smart Pointers

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

• Introduction

• (Trying To) Handwrite A Smart Pointer Class in C++ Before C++11

• std::unique_ptr

• Exercise: Bag Of Items, By Unique Reference

• std::shared_ptr

• std::weak_ptr

• Exercise: Bag Of Items, By Shared Reference

• Smart Pointers: Closing Words

Moving, “RValue References”, 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

Perfect forwarding ain’t moving:

• Perfect Forwarding

Functions (std::bind<>, std::function<>, Lambdas)

From Functions, Functions:

• std::bind

• std::function

From Lambda

• Lambda

• Live Hacking: Handwritten Functors (Too Much Boilerplate)

• Live Hacking: Handwritten Functors, And Capturing By Reference (Pitfalls)

• Lambda: More Capturing

Multithreading

From Multithreading:

• Threads Introduction

• Threads in C++

• Race Conditions

• std::mutex And Friends

• Scoped Locking

• std::atomic

• std::promise and std::future (And Some std::chrono) (Some Live Hacking)

• std::condition_variable (Live Hacking Multithreaded Queue)

News in C++20 (2023-06-13)

Coroutines and C++23 Generators

From Coroutines

• Coroutines: An Overview

Ranges And Views

From Ranges

• Ranges: Overview

• Ranges And Views: Good Or Bad?

• Ranges And Views: Links

Concepts

From Concepts

• Concepts: Overview

• Writing Your Own Concepts

• Concepts: Links