The C++ Programming Language (2021-07-12 - 2021-07-16)

Training Information

Course Description

tecTrain

Material

	Slides	OpenTraining
C	C	The C Programming Language
C++03	C++03	C++
C++11	C++11	The New C++ (11-…)
CMake	CMake
Make	Make
Design Patterns	Design Patterns

Code

Github Repository

Day 1

Setup for the new kids

• C/C++ for Visual Studio Code

• Get started with CMake Tools on Linux

• CMake download

Recapitulate some C

• struct: Basics

• struct: Functions

• Discrete Values - enum

• Pointers and Addresses

  • Daniel:

    • Question: so I could store the address of an integer in an integer?

    • Answer: the C compiler would let you (if he’s nice he can issue a warning), but this is not what you want. Because you’d lose half of the 64-bit pointer value when you store it in a (32-bit) integer.

    daniels-frage.c

• Pointers as Function Parameters

• Pointers and Arrays

Group project review

• Basis: db.h

• External (non-builtin) functionality: CSV export

  • csv.h

  • Program: csv-export.c

• Bleeding edge base functionality: Search by lastname

Jump into C++

• Introduction

• Classes and Objects

• More Constructors, Destructors

Exercise

On Github, there is a directory OO-Point. Starting from the point implementation, write comparable classes

• circle, containing a method circle::area()

• rect, also containing a method circle::area()

• sphere (in 2D :-) ), also containing a method circle::area()

Make the associated test programs run:

• circle-test.cpp

• rect-test.cpp

• sphere-test.cpp

run.

Day 2

Regular Topics

• Preprocessor, to clear up Julia’s include guard question. Sigh.

  • C Preprocessor: Basics

  • Only as a reference in case somebody needs token pasting and such: C Preprocessor: More

  • Header Files

• Constructor, Destructor, Copy

  • More Constructors, Destructors

    The rest of it. Yesterday we only got to the plain point stuff where no resource management is necessary.

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

• Functions and Methods

  • Overloading

  • Methods

  • this

  • References

  • static Methods

  • Operator Overloading

Exercises

• point::operator==()

• rect::operator+=()

• static double point::distance(const point&, const point&)

Day 3

Exercises

Finish exercises from day 2

Regular Topics

• Templates

  • Function Templates

  • Class Templates

• Standard Template Library: Container Templates

  • Standard Template Library: Basics

  • sort<>

  • find<>: Sequential Search, by Equality

  • binary_search<>: On Sorted Sequence

  • Sequential Containers

  • Associative Containers

Toolchain: C/C++ Build (How Complicated Can Things Be?)

	Trying to get #include dependencies right. Respectively, what you’re up to when you want to write a Makefile (or more of those) by hand.
	Using CMake to do manage the build. What is still left to the developer is to define “module” dependencies.

Exercises: Using the C++ Toolbox

• Starting to morph the “user database” from the C course (a month ago) into something more object oriented.

Day 4

Finish First “User Database” Functionality

• UserDB::has_lastname(), using std::find_if()

Unit Testing

Current state is, we’re writing one program to test one aspect/requirement. This is something that can be formalized (/me big fan of things that are so simple).

Install Google’s unittesting framework (on Doze, sadly), and start to use it.

GTest Installation

Clone GitHub repository:

$ git clone https://github.com/google/googletest.git

Build

• Build with VS Code: open directory, and hit CMake build botton

• Build by hand

$ cd googletest
$ cmake .

Install

• Copy lib/*.a to MinGW installation ..../lib directory

• Copy include/gtest/ to MinGW installation ..../include directory

Git Workflows

Central workflow. Much like SVN’s, except that local commits are possible.

Distributed workflow. (At least, one possibility). Resembles Github “pull requests”.

Exercises

• Torture them with even more requirements that they need to implement

Regular Topics

• Functors

• Exceptions

  • Basics

  • try - catch

  Live-hacked, rudimentarily, into our project. See here for the exception handling part.

Day 5

• References recap (References)

• explicit: another C++ trap/bug (automatic conversion), fixed by an ad-hoc solution - the explicit keyword, bolted onto what’s there. Here’s a live-hacked explanation of it.

  It has gotten a bit larger becauser I used it as an introduction to recource management and smart pointers.

• Pointer classes (“smart pointers”)

  • std::unique_ptr

    Although std::unique_ptr<> is the simpler of the two in what it does, its usage is more involved. Ownership transfer (this is what I like about it) is implemented using the outright genius “move” mechanism (since C++11), and one needs to know a bit when the compiler fails to enforce the ownership transfer contract.

    Live-hacked that here.

  • std::shared_ptr

    Didn’t go through it in great detail (time was over anyway). Shared ownership, though, is easier explained than unique ownership: “just don’t think about it”. (Should have mentioned reference cycles, to make things more complicated :-) ).

Day X

Smart Pointers, Recap

• std::unique_ptr

  

• std::shared_ptr

  

std::map

• Associative Containers. Livehackingly building an index into our user database

OO, and Polymorphism

• Interface class shape, shape.h

• Concrete implementation of that, rect.h, circle.h

• Composite pattern: sketch.h