• IDE
• Wiederholung zu Pointern,
• Dynamischer Speicherverwaltung,
• Template Funktionen,
• Container und Iteratoren als Zugriff,
• Einführung von Klassen.

Eine IDE ist eine Software-Anwendung, die Software-Entwicklern eine umfassende Reihe von Tools zur Verfügung stellt, um die Softwareentwicklung zu erleichtern.

Sie integriert normalerweise einen Quellcode-Editor, Build-Automatisierungstools und einen Debugger.

• Intellisense und Codevervollständigung – helfen Tippfehler zu vermeiden, Code schneller zu schreiben und benötigte Funktionen / Klassen leicht zu finden.
• Produktivitätssteigerung – durch die Integration der Tools in einem System.
• Debugging-Unterstützung: IDEs bieten oft eingebaute Debugging-Tools, die das Auffinden und Beheben von Fehlern erleichtern.
• Codeverwaltung – viele IDEs integrieren Versionskontrolle, um das Management und die Zusammenarbeit von Code zu erleichtern.

• Visual Studio Code ist eine kostenlose, Open-Source-IDE, die von Microsoft entwickelt wurde.
• Sie ist plattformübergreifend und unterstützt viele verschiedene Programmiersprachen, einschließlich C++.

• Hohe Anpassungsfähigkeit: Vielzahl von Erweiterungen für Entwickler
• Leichtgewichtig und performant: VS Code ist bekannt für seine hohe Leistung im Vergleich zu anderen, schwereren IDEs.
• Große Entwickler-Community: Durch die große Anzahl von Entwicklern, die VS Code nutzen, gibt es viele verfügbare Ressourcen und Unterstützung für Entwickler.

Einführung und Tutorial

• Allgemeine Einführung und Tutorial zu VS Code
• und Übersicht zu Vertiefungen mit Hinweisen z.B. für den Einsatz in C++

• Ein Zeiger (engl. Pointer) enthält die Adresse einer Variable im Speicher.
• Die Speicheradresse einer Variable liefert der Adressoperator &.
• Spezielle Adresse: NULL – „Zeiger ins Nichts“.
• Die Variable zu einem Pointer liefert der Dereferenzierungsoperator *.
• Der Typ eines Pointers auf eine Variable vom Typ T ist T*.

int a = 42;
int* b = &a; // Adressoperator angewendet auf a
*b = 12; // Dereferenzierungsoperator angewendet auf b; a == 12

• Eine Array-Variable verhält sich wie ein Pointer, der auf das erste Element des Arrays zeigt.
• Auf einen Pointer kann – wie auf ein Array – mit dem []-Operator zugegriffen werden. Dabei gilt: ptr[i] == *(ptr+i)
• Übergibt man einen Array-Typ T[] als Parameter an eine Funktion, „verfällt“ der Typ zum entsprechenden Pointer T* (Array Decaying).

• Der Umgang mit Pointern ist besonders am Anfang schwierig.
• C++ führt mit Referenzen ein ähnliches Sprachmittel ein.
• Wie Pointer sind Referenzen Variablen, die Verweise auf andere Variablen speichern.
• Der Typ einer Referenz auf eine Variable vom Typ T ist T&.

• Referenzen müssen immer sofort initialisiert werden:
• Eine Referenz kann nicht neu zugewiesen werden!
• Bei einer Zuweisung wird der referenzierte Wert überschrieben!

int i1 = 5;
int i2 = 6;
int& ir = i1; // ir zeigt auf i1
ir = i2; // ir zeigt immer noch auf i1 // i1 == i2

• Mithilfe der dynamischen Speicherverwaltung kann zur Laufzeit eines Programms Speicher angefordert werden.
• Die Verwaltung dieses Speichers geschieht dabei in C und C++ explizit durch den Programmierer.

• Wenn Datenmenge, die zu verarbeiten ist, erst zur Laufzeit bestimmt ist:
• Um viel Speicher zu “reservieren” - dies ist aber allgemein problematisch, da:
  • Speicher eine “rare” Resource ist
  • Der Speicher vielleicht trotzdem nicht ausreicht

C bietet die Bibliotheksfunktion malloc (stdlib.h) zur Allokation von Speicher auf dem Heap:

void* malloc( size_t size );

• Parametersize: Größe in Bytes.
• Rückgabe: void* auf reservierten Speicherbereich (NULL, falls kein Speicher reserviert werden konnte).

Erinnerung: Der Operator sizeof liefert die Größe eines Datentyps bzw. des Datentyps eines Ausdrucks:

// int* ip = malloc( sizeof(int) * 10 );
int* ip = malloc( sizeof (*ip) * 10 );
for ( int i = 0; i < 10; ++i )
	ip[i] = i;

Im Vergleich dazu: In Java wird mit new Speicher auf dem Heap alloziert.

Wichtig: C bietet keine automatische Speicherverwaltung.

• Reservierter Speicher muss “von Hand” freigegeben werden!
• Hierfür wird die Funktion free verwendet:

void free( void* ptr );

Der Zugriff auf die erstellten Objekte erfolgt mithilfe des Dereferenzierungsoperators * (genau, wie bei Zeigern, auf Elemente von Arrays):

int *i = new int;
std::cout << *i << std::endl; 
*i = 1;
std::cout << *i << std::endl;

• Um in C++ Speicher für ein Array anzufordern, gibt es den Operator new[].
• Entsprechend muss der Speicherbereich mit dem Operator delete[] freigegeben werden: Widget* widgets = new Widget[10]; ... delete[] widgets;

Bei Standarddatentypen (wie z.B. int und char) macht der Standardkonstruktor nichts!

• Speicher bleibt un-initialisiert
• Um mit new [] initialisierten Speicher mit 0 zu initialisieren:
  • Konstruktorklammern mit angeben
  • Dies gilt nur für Standarddatentypen!

int *as = new int[1000]; // uninitialisierter Speicher (meist zufaellig schon viel 0) 
int *bs = new int[1000](); // definitiv komplett 0

Aufgabe zum expliziten erzeugen und nutzen der dynamischen Speicherverwaltung.

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

Explizite Speicherverwaltung ist fehleranfällig

Dies hat mehrere Gründe:

Das folgende Beispiel illustriert einige Probleme mit der manuellen Speicherverwaltung. Frage: Wird wp korrekt freigegeben?

void foo() 
{
  auto wp = new Widget; 
  if( cond1 ) {
    while( !cond2 ) {
      if( cond3 && cond4 || cond5 ) {
        bar();
      } else { return; }
    }
  delete wp;
}

Template-Funktionen können entweder wie normale Funktionen aufgerufen werden, oder der zu verwendende Datentyp wird explizit angegeben:

int i = -5; 
double f = 7.5;
int j = abs(i); 
double g = abs(f);
int k = abs<int>(i); 
double h = abs<double>(f);

In der folgenden Aufgabe (später zu bearbeiten): Implementieren und testen Sie eine Template-Funktion printMaxReturnMin welche zwei Argumente erwartet und das größere auf der Konsole ausgibt und das kleinere als Rückgabewert zurück gibt.

#include <iostream>

// printMaxReturnMin definition

int main () {
  int i = 39;
  int j = 20;
  auto k = printMaxReturnMin(i,j);

  double a = 13.5;
  double b = 20.7;
  auto c = printMaxReturnMin(a,b);
}

Beispiele: Vektoren, Stapel oder Warteschlangen!

Was ist der Zweck von Containertypen für Programmierungsprachen?

Normalerweise bieten Container einige grundlegende Standard-Funktionen an.

Array

Ein array ist die primitive Form eines vectors: Feste Größe in einer strengen Reihenfolge

Wie funktioniert vector eigentlich?

Auf einer hohen Ebene ist ein Vektor eine geordnete Sammlung von Elementen des gleichen Typs, die wachsen und schrumpfen kann.

• Intern sind Vektoren als Array implementiert.

Im jupyter-book sind verschiedene Aufgaben angegeben – den letzten Teil müssen sie jedoch im Terminal ausführen.

Jupyter-Book Link

Hierüber kann dann direkt auf dem Hub eine Umgebung gestartet werden – dies lädt das gitlab und sie können hier ein Terminal starten, in dem sie den Code kompilieren und ihr Programm dann ausführen können.

JupyterHub Link

• std::vector ist der (mit Abstand) am meisten verwendete Container.
• std::vector modelliert ein dynamisches Array von Werten desselben Typs, der durch einen Template-Parameter angegeben wird (z. B.: std::vector<int>).
• Jeder kopierbare (oder verschiebbare) Datentyp kann als Elementtyp verwendet werden.
• Werte können zur Laufzeit hinzugefügt oder entfernt werden:

#include <iostream>
#include <vector > 
int main() {
  std::vector<int> v( 42 ); // erzeuge Vektor der Länge 42 
  for( unsigned int i = 0; i < v.size(); ++i ) {
    std::cout << v[i] << " "; }
  v.push_back( 23 ); // v.size() == 43; v.back() == 23
  v.pop_back(); // v.size() == 42 
}

• Vektoren können auf unterschiedliche Art und Weise erzeugt werden.
• Es kann die initiale Größe angegeben werden: std::vector<float> vf( 1024 ); //1024 float Werte
• Alternativ können die initialen Elemente des Vektors als eine Initializer List angegeben werden: std::vector<float> vf{ 1.1f, 2.2f, 3.3f, 4.4f, 5.5f }; //5 float Werte
• Erinnerung: Aufpassen bei Vektoren von Datentypen, die mit einem int Wert initialisiert werden können: std::vector<int> vi1{ 1, 2, 3, 4, 5 }; //5 int Werte std::vector<int> vi2{ 1024 }; // 1 int Wert (1024)
• Die Initializer List „gewinnt“ gegenüber den anderen Konstruktoren. Um einen Vektor der Größe 1024 zu erzeugen, müssen runde Klammern verwendet werden: std::vector<int> vi3( 1024 ); //1024 int Werte

Jede Funktion hat eine fest definierte Komplexität, z. B.:

• Zugriff auf Elemente mit [] oder at: $O(1)$, vi[42] = 23; vi.at( 23 )= 42;
• Einfügen am Ende des Vektors mit push_back: $O(1)$, vi.push_back( 42 );
• Einfügen an einer anderen Position mit insert: $O(n)$, vi.insert( vi.begin(), 23 );
• Vergrößern des Vektors mit resize: $O(n)$, vi.resize( 23 );

Vorsicht mit Zeigern und Referenzen auf Elemente eines Vektors!

#include <vector> 
#include <iostream>

struct A{ int i = 24; };

int main () 
{
  std::vector <A> v{}; 
  v.push_back( A{} ); 
  v[0].i = 24;

  A* ap = &(v[0]); // ap ist ein A-Zeiger auf das erste Element in v 
  std::cout << ap->i << std::endl; // 24

  for( int i = 0; i < 100; ++i ) 
    v.push_back( A{} );
  
  std::cout << ap->i << std::endl; // 17005616
}

Seit C++11 gibt es eine weitere Möglichkeit einen Container vollständig zu durchlaufen:

#include <vector>
#include <iostream> 

int main() {
  std::vector<int> vi{ 4, 8, 15, 16, 23, 42 };
  for( int i : vi ) // wie for each in Java 
  {
    std::cout << i << " "; 
  }
}

• Diese for-Schleife nennt man range-based for loop.
• Sie kann mit Objekten jeder Klasse verwendet werden, die begin und end Funktionen implementiert, die Iteratoren zurückgeben.
• Alle Container der C++-Standardbibliothek können derart durchlaufen werden.

• Bei der range-based for loop bietet es sich an, auto zu verwenden: for( auto i : vi ){ std::cout << i << ""; }

Achtung: Die linke Schleife ist wirkungslos, da die Zuweisung an eine Kopie und nicht das Original geschieht. Stattdessen Referenzen (auto&) verwenden!

std::vector<int> vi{ 4, 8, 15, 16, 23, 42 };
/* falsch: */
for( auto i : vi ) {
  i = 0; /*Zuweisung an Kopie*/
}

std::vector<int> vi{ 4, 8, 15, 16, 23, 42 };
/* richtig: */
for( auto& i : vi ) {
  i = 0; /*Zuweisung an Referenz*/
}

• Sequenz-Container sind dafür da, wenn du eine Ordnung in deine Informationen bringen musst!
• Normalerweise kann man einen std::vector für fast alles verwenden
• Wenn du besonders schnell Elemente vorne einfügen möchtest, solltest du eine std::deque nutzen
• Wenn du mehrere Listen zusammenfügen oder mit ihnen arbeiten willst, solltest du eine std::list verwenden

Karten werden als pair implementiert: std::pair<const key, value>

• Beachte das const! Schlüssel müssen unveränderlich sein.
• Die Indizierung in der Map ( myMap[key] ) durchsucht die zugrunde liegende Sammlung von Paaren nach dem ersten Auftreten des Schlüsselattributs und gibt dessen zweites Attribut zurück.

• std::map speichert Werte anhand eines Schlüssels ab: std::map<std::string, std::string> m; m["key"] = "value";
• Hierfür wird std::map mit zwei Template-Parametern spezifiziert, dem Datentyp des Schlüssels (Key) und des Wertes (Value): std::map<KeyDatatype, ValueDatatype> m;

int main() {
  std::map<std::string, int> word_map{};
  std::vector <std::string>  words{"this", "and", "that", "and", "more" };

  for( auto& w : words ) {
    word_map[w]++; 
  }
}

• Maps werden in der Regel leer erzeugt und dann mit Werten gefüllt: std::map<std::string, unsigned int> m; m["test"] = 4;
• Mithilfe des []-Operators können sowohl Werte aus der Map gelesen als auch in die Map geschrieben werden: unsigned int length_of_test = m["test"]; m["c++"] = 3;

• Um herauszufinden, ob zu einem Schlüssel ein Wert existiert, wird find verwendet: auto pos = m.find("not_in_map"); if(pos == m.end()){...}
• Mit erase können Schlüssel-Wert-Paare aus der Map entfernt werden: m.erase("test");

• Wie bei std::vector hat jede Funktion eine definierte Komplexität, z. B. :
  • Einfügen oder Zugreifen auf Elemente: $O(\log n)$, m["key"] = "value"; auto v = m["key"];
  • Suchen nach Elementen: $O(\log n)$, auto pos = m.find("needle");
  • Löschen von Elementen. Wenn Position bekannt: $O(1)$, sonst $O(\log n)$, m.erase(m.begin()); /*O(1)*/ m.erase("to_be_erased")/*O(log n)*/
• Als Schlüssel können Objekte jeder Klasse verwendet werden, die den Vergleichsoperator < überladen.
• Als Werte können Objekte jeder Klasse verwendet werden, die kopierbar (oder verschiebbar) ist.

Auch eine Map kann vollständig durchlaufen werden:

std::map<std::string, int> m; 
m["c++"] = 3; m["test"] = 4; m["needle"] = 6;

for( auto& p : m ) // type of p: std::pair<const std::string, int>& 
{
  std::cout << "key: " << p.first << " value: " << p.second << "\n"; 
}

• Dabei erhält man Zugriff auf das Paar aus Schlüssel und Wert.
• Mit p.first greift man auf den Schlüssel zu.
• Mit p.second greift man auf den Wert zu.
• first und second sind keine Funktionen, sondern einfache public Attribute.
• Da die Map nach den Schlüsseln sortiert ist, ist auch die Ausgabe im Beispiel entsprechend sortiert.

Sowohl Maps als auch Sets in der STL haben eine ungeordnete Version!

• Für geordnete Maps/Sets muss ein Vergleichsoperator definiert sein.
• Ungeordnete Maps/Sets erfordern die Definition einer Hash-Funktion.
• Ungeordnete Maps/Sets sind in der Regel schneller als geordnete Maps/Sets!

Es gibt viele Ähnlichkeiten zwischen Maps/Sets. Allgemeine Tipps zur Wahl:

• Ungeordnete Container sind schneller, aber es kann schwierig sein mit verschachtelten Containern/Sammlungen zu arbeiten.
• Wenn du komplexe Datentypen verwendest / mit Hash-Funktionen nicht vertraut bist, verwende einen geordneten Container

• Container sind eine Möglichkeit, zusammengehörige Daten zu sammeln und in einer standardisierten Weise mit ihnen zu arbeiten
• Zwei Arten von Containern: sequenziell und assoziativ
• Container-Adapter umhüllen bestehende Container, um den neuen/ eingeschränkten Zugriff auf die Schnittstelle für die Clients zu ermöglichen.

• Member können nur innerhalb der Klasse deklariert werden.
• Definitionen können sowohl innerhalb als auch außerhalb der Klasse stehen:

class Widget { 
  int _i;
public:
  void setI(int i) { _i = i; } // Deklaration & Definition 
  int getI(); // Deklaration
};
// Definition
int Widget::getI() { // Achtung: Namen der Klasse nicht vergessen!
  return _i; 
}

• Oft steht die Klasse mit allen Deklarationen in einer Header-Datei (.h oder .hpp) und die Definitionen in einer Source-Datei (.cpp).

Bei größeren Projekten trennt man meist Deklarationen und Definitionen in - Header-Dateien und - Implementierungs-Dateien

→ Erlaubt separate Kompilierung/Verwendung von Prebuilt-Libraries.

// max.h
// Deklaration
int max( int , int );

// max.c
// Definition
int max( int a, int b ) {
	return a>b? a : b; }

// foo.c
#include <stdio.h>
#include "max.h"

int main( void ) {
	printf( "%i\n" , max( 37, 91 ) );
}

Beim Kompilieren müssen alle Implementierungsdateien angegeben werden: gcc -Wall -o foo max.c foo.c

• Das Schlüsselwort const kann bei Member-Funktionen angegeben werden.
• Objekte, welche const sind (z. B. die Referenz wr), können nur konstante Member-Funktionen ausführen.
• Innerhalb einer konstanten Member-Funktion können keine Attribute des Objektes verändert werden.

• Bei der Instanziierung eines Objektes wird der Konstruktor aufgerufen.
• Wird ein Objekt zerstört, so wird der Destruktor aufgerufen (wenn: Objekt verlässt den Scope, delete auf dem Objekt, Objekt ist statisch und Programm terminiert).

class Widget { 
  int _i;
  int _j;

public:
  Widget(int i, int j) : _i(i), _j(j) { // Konstruktor
    std::cout << "Widget created\n"; } 
    
  Widget(int i) : Widget(i, 42) { // Konstruktor
    std::cout << "Delegating constructor\n"; } 

  ~Widget() { // Destruktor
    std::cout << "Widget destroyed\n"; }
};

• Es kann mehrere Konstruktoren mit unterschiedlichen Parametern geben.
• Es gibt immer nur einen Destruktor (ohne Parameter).
• Konstrukten und Destruktoren werden wie Funktionen definiert, jedoch haben sie keinen Rückgabetyp.
• Im Konstruktor können/müssen die Attribute der Klasse direkt mit einer sogenannten member initialization list initialisiert werden (rot markiert im Beispielcode).

• Falls die Entwickelnden keinen Konstruktor angeben, wird automatisch ein parameterloser Standardkonstruktor (default constructor) erzeugt.
• Dies funktioniert nur dann, wenn alle Attribute der Klasse ebenfalls über einen Standardkonstruktor verfügen.

class A { 
  int _i;

public:
  A(int i) : _i(i) {}
};

class B {
  A a; // compile error: no matching function for call to ’A::A()’
};

• Auch der Destruktor und einige andere sogenannte special member functions werden bei Bedarf vom Compiler erzeugt.

• Legen Sie eine Datei customer.cpp an.
• Implementieren Sie die Klasse Account in der Datei customer.cpp gemäß dem UML-Diagramm.

• Überlegen Sie sich dabei sinnvolle Parameter für die Funktionen deposit, withdraw und transfer.
• Beachten Sie, dass Überweisungen ausschließlich auf andere Konten durchgeführt werden können.
• Fügen Sie einen Konstruktor hinzu, mit dem ein Account mit Startguthaben angelegt werden kann.
• Implementieren Sie in der Datei customer.cpp eine main-Funktion und testen Sie die Klasse Account.

Hinweis: Kompilieren Sie Ihr Programm mit g++ -std=c++20 -Wall -Wextra -o customer customer.cpp

Aufgabe zum Anlegen einer Klasse und von Beispielinstanzen

Im jupyter-book ist die 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