• Perspektive auf Software Engineering und Themen des Kurses
• Organisatorisches
• Entwicklung von C und C++
• Imperative Programmierung
• Kontrollfluss

Ziel: Erste C++ Programm auf dem Hub laufen lassen und hierin grundlegende Kontrollstrukturen anwenden können.

Malte Schilling

• seit Wintersemester 2022 an der Universität Münster
• Davor:
  • komme ursprünglich aus Münster
  • Studium in Informatik in Bielefeld (Schwerpunkt KI und Robotik) und Biologie (dezentrale Steuerung von laufenden Robotern)
  • Forschung zu Sprachmodellen in Berkeley, Kalifornien
  • und Forschungsaufenthalte zu Lernen in Neuronalen Netzen in visuellen Tasks mit Sony CSL, Tokyo

“To design a program properly, a student must:

1. analyze a problem statement, typically stated as a word problem;
2. express its essence, abstractly and with examples;
3. formulate statements and comments in a precise language;
4. evaluate and revise these activities in light of checks and tests; and
5. pay attention to details.

All of these are activities that are useful for a businessman, a lawyer, a journalist, a scientist, an engineer, and many others.“

• wenig spezifizierte Herangehensweise.
• Lokale, zeilenbasierte Arbeitsweise.
• Keine Verwendung von Planungs- und Testtechniken.

• Verfügbarkeit effizient organisierter und spezialisierter Wissensschemata.
• Wissensorganisation gemäß funktionaler Charakteristiken.
• Anwenden allgemeiner Problemlösungsmuster und spezieller Strategien.
• Anwendung spezialisierter Schemata für das Zerlegen und Verstehen von Programmen. Bereitschaft, mehrere Strategien zu erproben und Hypothesen zu verwerfen.
• Verfügbarkeit korrespondierender Test- und Fehlersuchstrategien.

Vorstellung verschiedener Paradigmen zur Modellierung und Programmierung.

• Einführung in datengetriebene Modellierung.
• Einführung in testgetriebene Programmierung.
• Formalisierung des Entwicklungsprozesses. Erlernen des Handwerkszeugs.
• (Programmiersprachen als konkrete Beispiele für die betrachteten Paradigmen.)
• Hilfe bei der Entwicklung hin zur Expertin/zum Experten.

In der Vorlesung wird die Sprache C++ anhand von praxisnahen Beispielen vorgestellt. Themen sind u.a.:

• Kontrollfluss und Kontrollstrukturen
• Funktionen, Template Funktionen
• Datentypen (eingebaute Typen, Aufzählungen, …)
• Pointer, Referenzen
• Strukturen (C), Klassen (C++), Vererbung, Polymorphismus
• Bibliotheken, Standard Template Library (STL)

• Webseite für Kurs: jupyter-book mit Inhalten
• darin auch link auf Folien (ebenfalls in html gesetzt)
• interaktive, fortlaufende Programmierbeispiele und Aufgaben zu jeder Einheit
• Anmeldung zum C/C++-Kurs im SlCM/QISPOS nicht vergessen!

Fragen während des Kurses dürfen sehr gerne direkt gestellt werden.

• Ebenfalls im Learnweb: Möglichkeit eines Austauschs untereinander (Forum).
• Hinweis: Board-Regeln/Netiquette beachten.
• Hinweis: Lehrende lesen mit ;-). Dies ist gewollt, da hier Fragen, die für alle von Interesse sind, gestellt und beantwortet werden.
• Verwendete bzw. weiterführende Literatur wird zu den einzelnen Kapiteln angegeben.

Bearbeitung in Kleingruppen von zwei oder drei Personen sinnvoll.

Lerneffekt tritt nur ein, wenn jede(r) an der Bearbeitung aller Aufgaben beteiligt ist.

Honor Code: Angeben von Quellen und von Zusammenarbeit.

Arbeitsaufwand

Vorlesung wird mit 2 LP kreditiert, dies entspricht 60 Arbeitsstunden (inkl. Arbeit für die Abgabe) über die gesamte Vorlesungszeit.

Mit C++ lernt man automatisch Informatik-Grundlagen

• C++ ist eine High-Level Programmiersprache, die eine höhere Abstraktion bietet als C.
• Dabei nutzt C++ Zeiger und manuelle Speicherverwaltung.
• Schwerpunkt liegt so auf Informatikkonzepten, Leistung und Flexibilität und nicht zuerst auf der Einfachheit der Entwicklung.

Flexible Programmiersprache

C++ ist eine multi-paradigmatische und vielseitige Programmiersprache.

Daher: kann für eigenen Programmierstil genutzt werden und eigenen Best Practices für das Schreiben von Code mit C++ können etabliert werden.

Vorteile:

• Unglaublich einfache Anweisungen
• Extrem schnell (wenn gut geschrieben)
• Vollständige Kontrolle über ein Programm

Warum verwenden wir nicht immer Assembly?

• C folgt einem imperativen Programmierparadigma.
• Hiermit beschäftigen wir uns die ersten zwei Einheiten.
• Standardisierung 1990 in ANSI-C, auf allen gängigen Systemen verfügbar
  • C99 = 1999 – Viele Detailverbesserungen, teilweise inspiriert durch C++.
  • C11 = 2011 – Detailverbesserungen und Features, z.B. multi-threading support.
  • C18 = 2018 – Aktualisierter Standard. Bug fixes.

• C war beliebt, weil es einfach war.
• Das war aber auch seine Schwäche:
  • Keine Objekte oder Klassen
  • Schwierig, generischen Code zu schreiben
  • Mühsam beim Schreiben großer Programme

• C++20 Aktuellster Standard, viele neue Features
• C++17 Erweiterungen zu Template Programmierung, und Typinferenz, UTF-8, …
• C++14 Kleine Korrekturen und Erweiterungen zu C++11.
• C++11 Umfangreiche Erweiterung der Sprache und der Standardbibliothek, u. a.: Lambda-Funktionen, Variadic Templates, Move-Semantik, Rvalue-Referenzen, Unterstützung von Threads, …
• C++98 Erster Standard – auf allen gängigen Systemen verfügbar.

• Eigenschaften werden nur zur Programmiersprache hinzugefügt, wenn sie ein echtes Problem lösen!
• Programmierer können ihren eigenen Stil wählen.
• Aufteilung des Codes in Unterheiten ist ein zentraler Gedanke.
• Der Programmierer hat die volle Kontrolle über Abläufe (wenn er will).
• Leistung und Effizienz werden zuallerletzt geopfert …
• Erzwinge Sicherheit schon zur Kompilierzeit (wann immer möglich).

Ziel der Modellbildung: Lösung eines Problems.

Festlegen (durch Spezifikation), welches Ziel gelöst werden soll.

Methoden zur Modellbildung: Logische Strukturen, Graphen, Grammatiken, Automatenmodelle, Petri-Netze, UML-Diagramme …

• Modell: Registermaschine für natürliche Zahlen mit Befehlen +1, −1, Test auf Null.
• Programm: Zusammenstellung von Befehlen und Anweisungen.
• Elementare Bestandteile: Zuweisung, Konkatenation, Alternative, Iteration.
• Variablenkonzept: Orientierung an von-Neumann-Architektur; Behälterprinzip.
• Start eines Programms: Ausführung der ersten Anweisung.

• Der Gültigkeitsbereich endet in C immer am Ende des Blocks (oder des Programms für statische Variablen), in dem die Variable deklariert wurde.
• Ein Block wird von geschweiften Klammern umschlossen.
• Ein Variablenname muss (in seinem Block) eindeutig sein.
• Die Werte von uninitialisierten Variablen sind undefiniert.

• Statische Variablen können in einer Datei deklariert werden und sind in der Datei zugreifbar.
• Das Schlüsselwort static erlaubt es statische Variablen innerhalb von Funktionen zu deklarieren (analog zu Java).
• Statische und Datei-weite Variablen werden automatisch mit einem Null-Wert initialisiert.

Vorsicht: Die Verwendung solcher Variablen sollte vermieden werden, da sie zu schwierig zu entdeckenden Fehlern führen kann!

In C gibt es eine Reihe von Basisdatentypen:

• Für Buchstaben: char → char c = ’a’;
• Für ganze Zahlen (Integer-Typen): char, short, int, long, long long → int i = 42;
• Für Gleitkommazahlen: float, double, long double → double d = 42.23;

Die Größe der Basisdatentypen ist systemabhängig. Abfrage über sizeof-Operator, z.B. sizeof(int). Der Datentyp char ist jedoch immer auf 1 Byte festgelegt.

• Alle Integer-Typen sind standardmäßig vorzeichenbehaftet.
• Integer-Typen ohne Vorzeichen: unsigned

Beispiele:

• char c; //-128 .. 127 = signed char c; //-128 .. 127
• unsigned char c; //0 .. 255

Mit dem Typqualifizierer const können Konstanten definiert werden.

Beispiel: const double PI = 3.1415927;

• Mit einer typedef-Deklaration kann ein neuer Name für einen Typ vereinbart werden.

Beispiel: typedef unsigned int uint; → uint wird damit als weiterer Name für den Typ unsigned int deklariert und kann anschließend überall dort verwendet werden, wo auch der ursprüngliche Typname verwendet werden kann.

Im Header <stdint.h> sind Integer-Typen mit fester, systemunabhängiger Größe nach folgendem Muster vordefiniert: [u]intx_t mit \(x=8, 16, 32 \lor 64\). Beispiele:

• int8_t = int mit einer Größe von 1 Byte (entspricht char).
• uint64_t - unsigned int mit einer Größe von 8 Byte.

Wie gibt man den Wert einer Zahl n aus?

int n = 42;
printf("n hat den Wert ...");

• Der Ausgabe-String der printf-Funktion darf Platzhalter enthalten, z. B. %i für Integer-Typen und %f für Fließkommazahlen.
• Die Platzhalter werden durch zusätzliche Argumente von printf ersetzt.

Input: printf("Ein Integer: %i. Eine Fließkommazahl: %f.", 10, 5.2);
Output: Ein Integer: 10. Eine Fließkommazahl: 5.2.

In C++ wird std::cout << genutzt (dafür muss iostream eingebunden werden: include <iostream>).

Im jupyter-book sind verschiedene Aufgaben angegeben:

Jupyter-Book Link

Hierüber kann dann direkt auf dem Hub eine Umgebung gestartet werden, in der C++ interpretiert wird (wird die ersten Termine genutzt):

JupyterHub Link

In C gibt es erst seit dem C99-Standard einen Boolean-Datentyp (_Bool, durch inbinden von stdbool.h lässt sich _Bool als bool schreiben).

Definition eines Arrays: int data1[42];

• Statt der expliziten Größenangabe kann ein Array auch implizit mit einer Initialisierungsliste definiert werden: int data2[] = {1, 2, 3, 44, 55, 110};

Zugriff auf Elemente:

int a = data2[0]; // a == 1
data2 [1] = a;

Erstellen Sie ein Array mit 1000 Zufallszahlen vom Typ int und geben Sie anschließend die Anzahl der Elemente aus, die größer als RAND_MAX/2 sind.

Hinweise:

• Beachten Sie die Dokumentation der Funktion rand() unter http://en.cppreference.com/w/c/numeric/random/rand.
• Nutzen Sie eine for-Schleife, um über die Elemente des Arrays zu iterieren.

Beispiel for-Schleife in C

for(int i = 0; i < grenze; ++i) 
{
  // ...
}

• Strings werden als Arrays vom Typ char realisiert.
• Das Ende eines Strings wird durch das (Steuer-)Zeichen ’\0’ angegeben.

Beispiel: Der String "hello" entspricht {’h’, ’e’, ’l’, ’l’, ’o’, ’\0’}

Umständlich! → Kurzschreibweise:

char s[] = "hello"; // statt ...
char s[] = {’h’, ’e’, ’l’, ’l’, ’o’, ’\0’};

• Beliebte Fehlerquelle: \0 am Ende vergessen.

Ersetzen Sie jedes Vorkommen eines Leerzeichens im String s durch einen Unterstrich. Nutzen Sie hierfür eine while-Schleife (Hilfe Kontrollstrukturen).

#include <iostream>

int main () {
    char s[] = "In C, string literals are of type char[], and can be assigned directly to a (non-const) char*.";
    
    // Ersetzen Sie in s jedes Leerzeichen durch ’_’
    // TODO

    std::cout << s << std::endl; 
}