C++

: Sie soll die Programmierung einfacher und verständlicher machen, indem sie Befehle bietet, die näher an der menschlichen Sprache sind.

Zu lernen, wie man grafische Oberflächen in Qt ohne Designer, nur durch Code-Anweisungen, erstellt.

Ein Label (QLabel) für Textausgabe und eine Schaltfläche (QPushButton) für Benutzerinteraktion.

#include <QApplication>#include

<QMainWindow>

#include <QLabel>

#include <QPushButton>

Für die eigentliche Anwendung – sie verwaltet Ereignisse und die Programmsteuerung.

Für das Hauptfenster der Anwendung (das Haupt-Widget).

QLabel *helloWorldLabel = new QLabel(hauptfenster);

helloWorldLabel->setText("Hallo Welt");

Weil auf das Objekt über einen Zeiger zugegriffen wird.

Beim Konstruktor angeben, z. B.:new QLabel("Hallo Welt", hauptfenster);odernew QPushButton("Beenden", hauptfenster);

QObject::connect(beendenButton, SIGNAL(clicked()), &a, SLOT(quit()));

Wenn der Button „Beenden“ angeklickt wird, ruft das Signal clicked() den Slot quit() der Anwendung auf und beendet sie.

Weil die connect-Funktion die Adresse von Sender und Empfänger erwartet.

setGeometry()

1. x-Position (Abstand von links)

2. y-Position (Abstand von oben)

3. Breite

4. Höhe

helloWorldLabel->setGeometry(20, 10, 100, 20);

beendenButton->setGeometry(20, 30, 100, 25);

Widgets werden standardmäßig links oben im Eltern-Widget platziert und können sich überlappen.

Im Konstruktor

helloWorldLabel = new QLabel(this);

beendenButton = new QPushButton(this);

Weil this auf die aktuelle Instanz von MainWindow verweist – also auf das Haupt-Widget.

QObject::connect(beendenButton, SIGNAL(clicked()), qApp, SLOT(quit()));

Sie werden automatisch freigegeben, ein delete ist nicht nötig.

Rechtsklick auf den Widget-Typ → Refactoring → Header-Dateien werden vorgeschlagen.

Ein globaler Zeiger auf das aktuelle QApplication-Objekt – nützlich für Verbindungen innerhalb von Klassen.

Durch Linien zwischen den Objekten und im „Signals and Slots Editor“ unten im Fenster.

Direkt im „Signals and Slots Editor“, indem man Sender, Empfänger, Signal und Slot aus Listen auswählt.

1. Signal: Wird beim Eintreten eines Ereignisses gesendet.

2. Slot: Reagiert auf das Signal.

3. connect(): Verbindet Signal und Slot.

Es ermöglicht lose gekoppelte, flexible und ereignisgesteuerte Kommunikation zwischen Objekten.

QObject::connect(beendenButton, QPushButton::clicked, &a, QApplication::quit);

clicked(), pressed() und released().

close() und showMaximized().

Ein Senderobjekt sendet eine Nachricht (z. B. ein Signal), und ein Empfängerobjekt reagiert darauf über eine spezielle Methode (Slot).

Ja, ein Signal kann an mehrere Slots gesendet werden – die Reihenfolge der Ausführung ist dabei jedoch nicht festgelegt.

Weil die Ausführungsreihenfolge der Slots nicht garantiert ist – stattdessen sollte man die Aktionen in einem Slot zusammenfassen.

Über den Modus „Signals und Slots bearbeiten“, indem man per Maus vom Senderobjekt zum Empfängerobjekt zieht.

Qt erstellt automatisch die entsprechende connect()-Verbindung im Hintergrund.

in Ereignis ist eine Aktion, die in einem Programm eine Reaktion auslösen kann – z. B. ein Mausklick, Tastendruck oder Doppelklick.

Bei sequenzieller Programmierung läuft der Code strikt der Reihe nach ab, während ereignisorientierte Programmierung flexibel auf externe Aktionen reagiert.

Aktionen werden nur ausgeführt, wenn ein Ereignis tatsächlich eintritt – so werden unerwartete Situationen (z. B. Verbindungsverlust) besser abgefangen.

Es ist ein Mechanismus, mit dem Objekte in Qt auf Ereignisse reagieren, indem Signale gesendet und Slots (Reaktionen) ausgeführt werden.

Ein Signal ist eine Nachricht, die ein Objekt aussendet, wenn ein bestimmtes Ereignis eintritt (z. B. clicked() bei einem Button).

„Emittieren“ ist der Fachausdruck für das Aussenden eines Signals.

Ein Slot ist eine normale Methode einer Klasse, die auf ein bestimmtes Signal reagiert.

Durch die Methode QObject::connect().

Wenn der Button beendenButton angeklickt wird, führt das Objekt a die Slot-Methode quit() aus

Polymorphismus stammt aus dem Griechischen und bedeutet „vielgestaltig“.

Polymorphismus beschreibt die Fähigkeit, dass dieselbe Methode oder derselbe Begriff in unterschiedlichen Kontexten unterschiedliche Bedeutungen bzw. Wirkungen haben kann.

Dass Begriffe kontextabhängig unterschiedliche Bedeutungen haben können.

Das Wort „Bedienung“ kann im Restaurant den Service und bei einem Computerprogramm die Handhabung bezeichnen.

Eine Methode addieren(), die bei Zahlen eine Summe bildet (5 + 4 = 9) und bei Zeichenketten eine Verkettung durchführt („Auto“ + „haus“ = „Autohaus“).

Eine Methode mit gleichem Namen und gleicher Parameterliste wird in einer abgeleiteten Klasse neu definiert und ersetzt die geerbte Version.

Weil abgeleitete Klassen ein unterschiedliches Verhalten benötigen, z. B. bewegen() für Känguru, Bär und Wal.

• Überladen (Overloading): Mehrere Methoden mit gleichem Namen, aber unterschiedlichen Parameterlisten in derselben Klasse.

• Überschreiben (Overriding): Gleicher Methodenname und gleiche Parameterliste in verschiedenen Klassen (Vererbung).

Weil der Compiler bei der Übersetzung die Methode fest einer Klasse zuordnet (statische Bindung).

Der Compiler entscheidet schon beim Übersetzen, welche Methode ausgeführt wird – nicht zur Laufzeit. Dadurch kann falsches Verhalten entstehen, wenn über einen Basisklassenzeiger auf ein Objekt der abgeleiteten Klasse zugegriffen wird.

Durch Deklaration einer Methode mit dem Schlüsselwort virtual.

Es ermöglicht, dass die Methode zur Laufzeit (dynamisch) anhand des tatsächlichen Objekttyps aufgerufen wird.

Es kennzeichnet in einer abgeleiteten Klasse ausdrücklich, dass eine virtuelle Methode der Basisklasse überschrieben wird.

Dynamische oder späte Bindung (late binding).

Einen virtuellen Destruktor, damit beim Löschen eines Objekts über einen Basisklassenzeiger auch der Destruktor der abgeleiteten Klasse ausgeführt wird.

Um Flexibilität zu erhalten und Fehler zu vermeiden, wenn eine Methode überschrieben werden soll, aber nicht als virtuell markiert ist.

Eine abgeleitete Klasse kann überall dort eingesetzt werden, wo eine Basisklasse erwartet wird.

Virtuelle Methoden werden kursiv dargestellt.

Den Namen des Typs bzw. der Klasse des Objekts, auf das this verweist.

1. Protected: Symbol eines Schlüssels

2. Private: Symbol eines Vorhängeschlosses

Auf die Qt-Widgets-Anwendung.

Ein Objekt in der grafischen Oberfläche einer Qt-GUI-Anwendung – z. B. ein Fenster, eine Schaltfläche oder ein Textfeld.

Aus den englischen Wörtern Window (Fenster) und Gadget (Apparat).

1. Haupt-Widgets (Main Widgets): Container für andere Widgets, z. B. das Hauptfenster.

2. Sub-Widgets: enthaltene Elemente, z. B. Schaltflächen oder Eingabefelder.

Sie können verschoben, minimiert, maximiert und in der Größe verändert werden. Sie besitzen eine Titelleiste mit Name und Symbolen.

1. Menüleisten

2. Symbolleisten

3. Menübänder

4. Listen- und Kombinationsfelder

5. Kontrollkästchen

6. Schaltflächen

7. Schieberegler

1. Menü Datei → Neu… wählen.

2. Kategorie Anwendung (Qt) auswählen.

3. Vorlage Qt Widgets-Anwendung wählen.

4. Namen und Ordner festlegen.

5. Einstellungen bestätigen und Abschließen klicken.

1. mainwindow.h (Header-Datei)

2. mainwindow.cpp (Implementierung)

3. mainwindow.ui (Formulardatei für GUI)

1. Sie erbt von QMainWindow.

2. Sie enthält Konstruktor, Destruktor und ein Attribut Ui::MainWindow *ui für die Oberfläche.

Sie enthält den Programmeinstieg (main()-Funktion) und startet die Anwendung.

Erstellt ein QApplication-Objekt für die Ereignisverarbeitung des Programms (zwingend notwendig für jede GUI-Anwendung).

Erzeugt eine Instanz des Hauptfensters (Klasse MainWindow), die von QMainWindow erbt.

Zeigt das Hauptfenster auf dem Bildschirm an.

Startet die Ereignisschleife der Anwendung. Sie läuft, bis das Hauptfenster geschlossen wird, und gibt dann 0 zurück.

Die gesamte Anwendung wird automatisch beendet.

Die Datei mainwindow.ui.

Mit dem Qt Designer, der im Qt Creator integriert ist.

In den Arbeitsbereich Design.

XML (eXtensible Markup Language) beschreibt die Struktur der Oberfläche in der .ui-Datei textbasiert.

Beim Anlegen eines neuen Projekts den Typ Qt Quick-Anwendung (z. B. „Stack“) wählen.

In QML, nicht in C++.

Für mobile Anwendungen und moderne, animierte Oberflächen.

Das Erstellen von Programmen mit grafischen Oberflächen (GUIs) in Qt, deren Aufbau und das Anlegen neuer Projekte im Qt Creator.

GUI steht für Graphical User Interface – also eine grafische Benutzeroberfläche.

1. Programmierung der gesamten Anwendung per Hand mit Qt-Klassen.

2. Verwendung einer Vorlage für eine Qt-Widgets-Anwendung (Formulare und Widgets).

3. Verwendung einer Vorlage für eine Qt-Quick-Anwendung (QML-basierte Oberfläche).

• Qt Widgets: klassische Desktop-GUIs mit C++ und Widgets.

• Qt Quick: moderne GUIs mit QML und JavaScript, häufig für mobile Anwendungen.

Überladen bedeutet, dass mehrere Methoden oder Funktionen denselben Namen haben, sich aber durch ihre Parameterlisten unterscheiden.

Anhand der Parameterliste (Anzahl und Typen der Parameter).

Nein, die Parameterlisten müssen sich unterscheiden. Unterschiedliche Rückgabetypen allein führen zu einem Kompilierfehler.

Wenn der Compiler anhand der Argumente nicht eindeutig entscheiden kann, welche Methode gemeint ist – z. B. bei automatischer Typumwandlung zwischen int und float.

Durch explizites Typecasting der Argumente, z. B.:rechnung(static_cast<float>(1.2), static_cast<float>(2.1));

Ja, Konstruktoren können überladen werden, indem sie verschiedene Parameterlisten haben.

Weil Konstruktoren immer denselben Namen wie die Klasse tragen und man so verschiedene Möglichkeiten zur Objekterzeugung bieten kann (z. B. mit/ohne Parameter).

Der Compiler wählt automatisch den passenden Konstruktor anhand der Argumente aus.

Standardkonstruktor

Eine spezielle Syntax, mit der Klassenattribute direkt beim Aufruf des Konstruktors initialisiert werden, statt erst im Rumpf des Konstruktors.

Durch einen Doppelpunkt (:) hinter dem Konstruktorkopf. Sherry::Sherry(int tAlter) : alter(tAlter), liter(1) {}

Aufrufe von Variablenkonstruktoren, keine Zuweisungen.(z. B. alter(tAlter) statt alter = tAlter;)

Ein Konstruktor, der automatisch aufgerufen wird, wenn eine Variable erzeugt wird; in der Elementinitialisierungsliste wird er zur Initialisierung einzelner Attribute genutzt.

Durch Kommas, z. B.:Sherry::Sherry(int tAlter): alter(tAlter), liter(1) {}

1. Die Elementinitialisierungsliste initialisiert die Variablen direkt bei der Objekterzeugung.

2. Eine Zuweisung erfolgt erst nach der Konstruktion der Attribute.

Bei der Vererbung, um den Konstruktor der Basisklasse aufzurufen.

Vererbung bedeutet, dass eine Klasse (Unterklasse) Attribute und Methoden einer anderen Klasse (Oberklasse) übernimmt und erweitern oder anpassen kann.

Klassen müssen nicht neu erstellt werden; man kann bestehende Klassen wiederverwenden und erweitern, wodurch der Quellcode effizienter und übersichtlicher wird.

Diese Klasse wird Oberklasse oder superclass genannt.

Diese Klasse wird Unterklasse oder subclass genannt.

Durch die Beziehung „ist ein“, z. B. „Ein Känguru ist ein Beuteltier.“

Man müsste alle gemeinsamen Attribute (z. B. Geschwindigkeit, Position) mehrfach neu definieren.

Nein, z. B. kann „Bär“ nicht von „Beuteltier“ erben.

Konstruktoren und Destruktoren.

Eine Klasse erbt von mehreren Oberklassen gleichzeitig.

Sie kann unübersichtlich werden und zu Fehlern in der Klassenhierarchie führen.

Nur, wenn zwischen zwei Klassen die Beziehung „A ist ein B“ besteht.

Von oben nach unten – erst abstrakte, dann immer konkretere Klassen.

Wenn sie

• ein neues Attribut,

• eine neue Methode hat oder

• ihr Verhalten sich ändert.

Er prüft nur die Syntax, nicht die inhaltliche Logik der Beziehungen.

„Känguru ist ein Bär“ – syntaktisch erlaubt, aber logisch falsch.

Eine standardisierte objektorientierte Modellierungssprache für Softwaresysteme.

Als Rechteck mit Klassennamen, Attributen und Methoden.

Durch eine Linie mit einem Dreieck, das auf die Oberklasse zeigt.

Weil sie automatisch übernommen werden und nicht erneut aufgeführt werden müssen.

Sie können aus Klassendiagrammen automatisch Quelltext-Gerüste erzeugen.

1. Wiederverwendung von Code

2. Erweiterbarkeit

3. Strukturierte Hierarchie

Nur dann, wenn die Aussage „A ist ein B“ logisch richtig ist.

In unklaren Zuständigkeiten, doppelten Attributen und schwer nachvollziehbarem Verhalten.

Durch die Syntax class Unterklasse : public Oberklasse

: Es legt fest, dass die öffentlichen Elemente (public) der Basisklasse auch in der abgeleiteten Klasse öffentlich bleiben und zugänglich sind.

Konstruktoren und Destruktoren.

Um die Datenkapselung zu wahren – Attribute sollen nicht direkt, sondern nur über Methoden verändert oder gelesen werden.

Die Attribute gewicht und alter sowie die Methoden getGewicht() und getAlter().

Sie initialisiert die Attribute direkt bei der Objekterzeugung, statt erst nachträglich – das ist effizienter und bei manchen Datentypen zwingend erforderlich.

Weil der Konstruktor der Basisklasse Baer Parameter erwartet, aber nicht automatisch von ElternBaer aufgerufen wurde.

Beim Erzeugen eines Objekts der abgeleiteten Klasse muss zuerst ein Objekt der Basisklasse erstellt werden – der Compiler weiß aber nicht, welche Werte er übergeben soll.

Über die Elementinitialisierungsliste:

ElternBaer::ElternBaer(int tGewicht, int tAlter, int tKinder)

: Baer(tGewicht, tAlter)

{

anzahlKinder = tKinder;

}

Wenn die Basisklasse einen Standardkonstruktor (ohne Parameter) besitzt – dieser wird automatisch aufgerufen.

Ein Konstruktor, der einen anderen Konstruktor derselben Klasse über die Initialisierungsliste aufruft.

Weil dadurch die Datenkapselung verloren geht – jedes Objekt oder jede Klasse könnte die Attribute direkt verändern.

Indem man sie mit dem Zugriffsmodifizierer protected deklariert.

Geschützte Elemente sind für die eigene Klasse und alle abgeleiteten Klassen sichtbar, aber nicht für andere Klassen.

1. private – nur innerhalb der Klasse sichtbar

2. protected – in der Klasse und ihren Unterklassen sichtbar

3. public – überall sichtbar

Weil es die Datenkapselung wahrt, aber trotzdem kontrollierten Zugriff für Unterklassen ermöglicht.

Zuerst der Konstruktor der Basisklasse, danach der Konstruktor der abgeleiteten Klasse.

Der Compiler meldet einen Fehler, weil er nicht weiß, wie die Basisklasse initialisiert werden soll.

private, protected, public – sie bestimmen, welche Klassen auf Attribute und Methoden zugreifen dürfen.

Das Prinzip der Datenkapselung.

Zuweisungen (z. B. alter = tAlter;) – nur Konstruktoraufrufe sind erlaubt.

Um ähnliche Funktionen oder Konstruktoren mit unterschiedlichen Eingaben zu definieren, ohne verschiedene Namen vergeben zu müssen.

Sie ist effizienter und sauberer, da Attribute direkt beim Erstellen des Objekts initialisiert werden.

Ein Destruktor hat denselben Namen wie die Klasse, jedoch mit einer Tilde (~) davor, z. B. ~Klassenname().

Beide haben denselben Namen wie die Klasse und keinen Rückgabetyp.

1. Der Konstruktor initialisiert eine Instanz, der Destruktor räumt sie auf.

2. Der Konstruktor kann Parameter annehmen, der Destruktor nicht.

3. Der Destruktor hat zusätzlich das Symbol ~ vor dem Namen.

Er wird verwendet, um Ressourcen freizugeben, bevor eine Instanz gelöscht wird, z. B. Speicher oder Datei-Handles.

Dann erstellt man versehentlich einen Konstruktor, keinen Destruktor.

Um Speicherlecks zu vermeiden, da ohne delete der Destruktor nicht aufgerufen und der belegte Speicher nicht freigegeben wird.

Der Destruktor wird nicht ausgeführt, und der Speicher bleibt belegt (Speicherleck).

Dass eine oder mehrere Instanzen nicht korrekt freigegeben wurden, also deren Destruktor nicht aufgerufen wurde.

Konstruktoren und Destruktoren sind spezielle Methoden, die automatisch beim Erzeugen bzw. Zerstören einer Instanz einer Klasse ausgeführt werden.

Ein Konstruktor wird automatisch aufgerufen, sobald eine neue Instanz einer Klasse erzeugt wird.

Der Konstruktor trägt exakt denselben Namen wie die Klasse und hat keinen Rückgabetyp – auch nicht void.

Eine Initialisierungsmethode muss manuell nach der Instanzerzeugung aufgerufen werden, während ein Konstruktor automatisch beim Erzeugen der Instanz ausgeführt wird.

Weil Objekte in der realen Welt meist direkt beim Erstellen ihre Eigenschaften erhalten und nicht erst in einem zweiten Schritt.

Dann kann von außen keine Instanz der Klasse erzeugt werden. Konstruktoren müssen daher in der Regel public sein.

Nur einmal – beim Erstellen der Instanz. Ein mehrfacher Aufruf des Konstruktors ist nicht möglich.

Das führt zu einem Fehler, da die Objektidentität eindeutig sein muss.

Es kommt zu einem Fehler, weil die Anzahl und Typen der Parameter exakt zu denen im Konstruktor passen müssen.

Das Überladen von Konstruktoren bedeutet, dass mehrere Konstruktoren mit unterschiedlichen Parameterlisten in derselben Klasse definiert werden können.

Ein Destruktor ist eine spezielle Methode, die automatisch aufgerufen wird, wenn eine Instanz zerstört oder gelöscht wird.

Beim Freigeben einer Instanz (z. B. durch den Operator delete) oder beim Beenden des Programms.

Das Programm lässt sich nicht übersetzen; der Compiler gibt Fehlermeldungen aus.

Sie stellen öffentliche Funktionen bereit, über die der interne Zustand (z. B. Gewicht, Sturheit) kontrolliert geändert oder abgefragt werden kann.

Weil Attribute und Methoden standardmäßig privat sind – private dient dann nur der besseren Lesbarkeit.

Ein konkretes Objekt, das nach dem Bauplan (der Klasse) erzeugt wurde.

So privat wie möglich, so öffentlich wie nötig.

An die Regel „So lokal wie möglich, so global wie nötig“ bei lokalen und globalen Variablen.

Attribute werden in der Regel privat vereinbart.

Methoden werden in der Regel öffentlich vereinbart, da sie von außen aufgerufen werden sollen.

Wenn sie nur innerhalb der Klasse verwendet wird und nicht von außen zugänglich sein muss.

Weil das gegen das Prinzip der Datenkapselung verstößt und zu schwer auffindbaren Fehlern führen kann.

In größeren Projekten kann es zu unkontrollierten Zugriffen, unerwarteten Fehlern und schwerer Wartbarkeit führen.

Weil sie anfangs zusätzlichen Programmieraufwand erfordert und der Nutzen erst bei größeren Projekten sichtbar wird.

Wenn man eine komplexe Klasse wiederverwenden oder in einem anderen Programm einsetzen möchte.

Sie spart Zeit und Aufwand, da gut gekapselte Klassen einfach wiederverwendbar sind.

Protected heißt „geschützt“ und bezeichnet eine weitere Stufe der Sichtbarkeit zwischen private und public.

1. Attribute: so privat wie möglich

2. Methoden: so öffentlich wie nötig

Datenkapselung bedeutet, dass der direkte Zugriff auf die Attribute einer Klasse von außen verboten ist. Stattdessen erfolgt der Zugriff nur über Methoden der Klasse.

1. Programme bleiben übersichtlicher und leichter zu warten.

2. Die Fehlersuche wird einfacher, da Fehlerquellen auf die betreffende Klasse beschränkt sind.

Sie ermöglicht die problemlose Wiederverwendung von Klassen in anderen Programmen (z. B. Dialogfenster, Suchfunktionen).

Das Geheimnisprinzip oder information hiding.

Auf das Was einer Klasse (ihre Funktionalität), nicht auf das Wie (ihre interne Umsetzung).

Durch die Festlegung der Sichtbarkeit (Visibility) von Attributen und Methoden mit Schlüsselwörtern wie private und public.

Sie legt fest, von welchen Stellen im Programm aus auf das Element zugegriffen werden darf.

• private → Zugriff nur innerhalb der Klasse

• public → Zugriff auch von außen (Es gibt außerdem protected, das hier aber nicht behandelt wird.)

Standardmäßig sind alle Attribute und Methoden privat, wenn keine Sichtbarkeit angegeben ist.

Mit dem Schlüsselwort public: vor der Attribut- oder Methodenliste.

Sie gilt ab ihrer Deklaration bis zur nächsten Sichtbarkeitsangabe oder bis zum Ende der Klasse.

Alle danach deklarierten Attribute und Methoden sind öffentlich, bis eine neue Sichtbarkeit folgt oder die Klasse endet.

Zuerst die privaten Attribute und Methoden, danach die öffentlichen. So bleibt die Klasse übersichtlich.

Wenn man versehentlich public vergisst, sind die Attribute automatisch privat – ein sicherer Standard.

Durch die erneute Angabe von private: in der Klassenvereinbarung.

Ja, public und private können in beliebiger Reihenfolge und Häufigkeit verwendet werden.

class Beispiel {

private:

int attribut1;

double attribut2;

public:

void methode1();

int methode2();

};

1. Attribute → privat

2. Methoden → öffentlich

So kann der interne Zustand der Klasse nur über klar definierte Schnittstellen (Methoden) verändert werden.

Das Programm lässt sich nicht übersetzen; der Compiler gibt Fehlermeldungen aus.

Eine einfach verkettete Liste ist eine Datenstruktur, bei der jedes Element auf das nächste Element der Liste zeigt. Jedes Element enthält Daten und einen Zeiger (next) auf das nächste Element.

1. Attribute:

   • string daten → speichert den Inhalt des Elements

   • Listenelement* next → Zeiger auf das nächste Listenelement

2. Methoden:

   • void datenSetzen(string datenneu) → setzt die Daten und next auf nullptr

   • void anhaengen(string datenneu) → hängt ein neues Element am Ende der Liste an

   • void ausgeben() → gibt die Liste von diesem Element aus

   • void freigeben() → gibt den Speicher der gesamten Liste frei

Sie setzt das Attribut daten auf den übergebenen Wert und next auf nullptr. Dies wird genutzt, um das erste Element zu initialisieren, ohne direkt auf die Attribute zuzugreifen.

• Prüft, ob next == nullptr:

  • Ja: Neues Element erstellen, Daten setzen, next = nullptr

  • Nein: Methode rekursiv auf next aufrufen

• Die Methode nutzt Rekursion, um das Ende der Liste zu finden, anstatt eine Schleife mit einem Hilfszeiger.

• Rekursion bedeutet, dass die Methode sich selbst aufruft, wobei der vorherige Aufruf im Stack gespeichert bleibt.

1. Bei Strukturen: Über eine while-Schleife mit einem Hilfszeiger

2. Bei Klassen/Objekten: Über Rekursion (if … else prüft next)

3. Rekursion ruft die Methode für next auf, bis next == nullptr erreicht ist

1. Wenn die Abbruchbedingung fehlt oder falsch ist, endet die Rekursion nie

2. Folge: Stack Overflow, da jeder Aufruf auf dem Stack gespeichert wird

1. Gibt daten des aktuellen Elements aus

2. Prüft, ob next != nullptr

3. Ruft rekursiv ausgeben() für das nächste Element auf

1. Prüft, ob next != nullptr

2. Ruft rekursiv freigeben() für das nächste Element auf

3. Löscht dann das nächste Element (delete next)

4. Im Hauptprogramm wird das erste Element ebenfalls gelöscht (delete listenanfang)

1. Erstes Element erstellen (datenSetzen)

2. Neues Element anhängen (anhaengen):

   • Wenn next == nullptr → direkt anhängen

   • Wenn nicht → rekursiver Aufruf

3. Daten werden von Element zu Element weitergegeben, bis das Ende erreicht ist

1. Kapselt Daten und Methoden in einer Klasse

2. Vermeidet direkten Zugriff auf Attribute von außen

3. Rekursion ersetzt externe Hilfszeiger und Schleifen

4. Einfachere Wartung und Erweiterung

1. Die vorherige Anweisung wird nicht gelöscht, sondern unterbrochen.

2. Nach Abschluss des rekursiven Aufrufs wird die unterbrochene Anweisung fortgesetzt.

3. Dies führt zu einem Stapel (Stack) von wartenden Methodenaufrufen, der in umgekehrter Reihenfolge abgearbeitet wird.

1. Methode anhaengen() wird für Element 1 aufgerufen.

2. next von Element 1 ist nicht nullptr → Methode wird rekursiv für Element 2 aufgerufen.

3. Element 2 hat next == nullptr → neues Element wird erzeugt und Daten gesetzt.

4. Rückkehr zu Element 1 → vorherige Anweisung (cout) wird ausgeführt.

1. Rekursion geht zuerst ans Ende der Liste.

2. Danach werden die Elemente von hinten nach vorne gelöscht, während die wartenden Methoden vom Stack abgearbeitet werden.

1. Gibt die Daten des aktuellen Elements aus.

2. Ruft sich rekursiv für next auf, bis next == nullptr (Ende der Liste).

3. Die Verarbeitung beginnt immer beim Listenanfang, da listenanfang nicht verändert wird.

1. Zeigt stets auf den Anfang der Liste.

2. Methoden wie anhaengen(), ausgeben(), freigeben() starten immer am Anfang.

3. Die Bewegung durch die Liste erfolgt über Rekursion auf next.

1. Durch den rekursiven Aufruf mit next wird das nächste Element aktiv.

2. Das ursprüngliche Element bleibt auf dem Stack und wartet, bis die Rekursion abgeschlossen ist.

1. Stack Overflow, wenn die Abbruchbedingung fehlt oder Listen sehr groß sind.

2. Lösung: Rekursion durch Schleifen ersetzen, ähnlich wie bei der Struktur-Version der Liste.

1. Hilfszeiger auf die aktuelle Instanz setzen (this).

2. Mit einer while-Schleife über next gehen und Daten ausgeben.

3. Vermeidet Überlauf bei großen Listen.

1. Rekursion: Aufruf einer Methode oder Funktion durch sich selbst.

2. Wichtig:

   • Abbruchbedingung definieren

   • Stack Overflow vermeiden

   • Reihenfolge der Verarbeitung beachten (letztes Element zuerst, erstes Element zuletzt)

1. Leidenschaft, Liebe, Begehren

2. Gefahr, Gewalt, Wut

3. Energie und Intensität 👉 Beispiel: „American Beauty“ – die roten Rosen symbolisieren Liebe und Obsession.

Methoden verschiedener Objekte können sich gegenseitig aufrufen und miteinander interagieren, um gemeinsam eine Aufgabe zu erfüllen.

Durch Zeiger oder Referenzen, mit denen ein Objekt auf ein anderes zugreifen und dessen Methoden aufrufen kann.

Eine Instanz ist ein konkretes Objekt, das auf Basis einer Klassenbeschreibung erstellt wurde und über eigene Werte für die Attribute verfügt.

Damit ein Objekt auf andere Objekte des gleichen oder eines anderen Typs zugreifen kann — etwa um deren Methoden aufzurufen oder Daten zu ändern.

Sie kann dadurch eine Beziehung oder Verbindung zwischen Objekten herstellen oder Operationen über mehrere Objekte hinweg ausführen.

Eine Methode wird im Kontext eines Objekts ausgeführt und kann auf dessen Attribute zugreifen; eine normale Funktion steht außerhalb von Klassen.

Durch Übergabe von Zeigern oder Referenzen aufeinander — typischerweise über eine Methode wie verbindenMit() oder einen Konstruktorparameter.

1. Erhöhte Flexibilität

2. Aufteilung komplexer Aufgaben auf mehrere spezialisierte Objekte

3. Bessere Wartbarkeit und Erweiterbarkeit des Codes

• Zeiger müssen gültig sein (nicht auf gelöschte Objekte zeigen).

• Beziehungen sollten klar definiert und symmetrisch gesetzt werden, falls nötig.

• Speicher muss korrekt verwaltet oder mit Smart Pointern abgesichert werden.

Das aufrufende Objekt wechselt den Ausführungskontext zur Methode des anderen Objekts und übergibt ggf. Parameter; Rückgabewerte werden danach im eigenen Kontext weiterverarbeitet.

Damit das aufrufende Objekt Informationen über den Erfolg oder das Ergebnis der Aktion erhält und seinen eigenen Zustand entsprechend anpassen kann.

1. Einseitig: Nur ein Objekt kennt das andere.

2. Beidseitig: Beide Objekte haben Referenzen oder Zeiger aufeinander und können gegenseitig Methoden aufrufen.

1. Attribute: Speichern Daten (Zustand).

2. Methoden: Definieren das Verhalten und die Verarbeitung dieser Daten.

1. Durch klar definierte Schnittstellen (Public-Methoden).

2. Nutzung von Kapselung, um interne Details zu verbergen.

3. Übergabe nur notwendiger Informationen.

Durch Bedingungen (if-Anweisungen), die z. B. Grenzen, Zustände oder Ressourcenverfügbarkeit der beteiligten Objekte überprüfen.

Er kann dem aufrufenden Objekt mitteilen, ob eine Aktion erfolgreich war oder in welchem Umfang sie ausgeführt wurde.

Eine Methode kann Teilaufgaben an andere Methoden (eigene oder fremde Objekte) delegieren; durch diese Aufgabenteilung entsteht ein Zusammenspiel mehrerer Komponenten.

Sie schützt die internen Daten eines Objekts und erlaubt nur definierte Zugriffe über öffentliche Methoden, wodurch unbeabsichtigte Änderungen verhindert werden

1. Nutzung von Smart Pointern (shared_ptr, unique_ptr)

2. Ereignis-/Signal-Systeme

3. Observer-/Listener-Muster

4. Abstraktion über Schnittstellen oder Basisklassen

Zu verstehen, wie Objekte miteinander kommunizieren, Informationen austauschen und gemeinsam Zustände verändern, um ein System als Ganzes funktionsfähig zu machen.

Das ist nicht erlaubt – unique_ptr kann nur verschoben (move) werden, nicht kopiert.

Vor dem Operator -> muss der Bezeichner des Zeigers stehen, nicht der Klassenname.

Autoklasse->init(); führt zu einem Fehler, da Autoklasse nur der Klassenname, aber keine Instanz ist.

Mit auto1->init();

auto2->init();

Die Geschwindigkeit von auto1 wird um 20 erhöht.

Beim dynamischen Erzeugen werden Objekte einer Klasse zur Laufzeit (also während das Programm läuft) mit dem Operator new erstellt – im Gegensatz zur statischen Erzeugung, die zur Compile-Zeit erfolgt.

Mit dem Operator new und dem Klassennamen: Autoklasse* auto1 = new Autoklasse();

Der Standardkonstruktor der Klasse wird aufgerufen.

Über den Pfeiloperator ->, z. B. auto1->init();

Er kombiniert Dereferenzierung und Zugriff auf eine Methode oder ein Attribut eines Objekts, auf das ein Zeiger zeigt.

Mit dem Operator delete, z. B. delete(auto1);

Das führt meist zu einem Programmabsturz, weil auf ungültigen Speicher zugegriffen wird.

Weil auto3 kein Zeiger ist, sondern ein normales Objekt. Der Operator -> funktioniert nur mit Zeigern.

Mit dem Punktoperator ., z. B. auto3.init();

Durch Dereferenzierung: (*auto3).init();

Das sind Klassen (z. B. unique_ptr, shared_ptr), die automatisch die Speicherfreigabe übernehmen, wenn das Objekt nicht mehr benötigt wird.

Mit make_unique: unique_ptr<Autoklasse> auto1 = make_unique<Autoklasse>();

Sie vermeiden Speicherlecks, weil sie den Speicher automatisch freigeben, wenn der Zeiger außerhalb seines Gültigkeitsbereichs liegt.

Gar nicht – unique_ptr ruft delete automatisch auf, wenn der Zeiger zerstört wird.

Ein intelligenter Zeiger, der alleinigen Besitz („unique ownership“) über ein Objekt hat. Es kann nur einen unique_ptr pro Objekt geben.

Nein, nur in der Klassendeklaration steht ein Semikolon – nicht bei der Implementierung.

Ja, sie müssen vollständig identisch sein. Rückgabetyp und Parameter dürfen nicht verändert werden.

Weil die Methode sonst die Parameter im Rumpf nicht ansprechen oder verarbeiten kann.

Sie verringert die Geschwindigkeit um den Wert aenderung, aber nicht unter 0: if ((geschwindigkeit - aenderung) < 0)

geschwindigkeit = 0;

else

geschwindigkeit -= aenderung;

Nein, der Compiler erkennt automatisch, dass geschwindigkeit ein Attribut der Klasse ist.Man kann aber Autoklasse::geschwindigkeit schreiben – das ist jedoch unüblich und unübersichtlich.

1. Klasse: Bauplan (Definition).

2. Instanz: Ein konkretes Objekt, das nach dem Bauplan erstellt wird.

Durch Deklaration mit dem Klassennamen als Typ: Autoklasse auto1;

Autoklasse auto2;

1. Direkt (wie bei Strukturen): Autoklasse auto1;

2. Dynamisch mit Zeigern oder Smartpointern (im nächsten Kapitel behandelt).

Autoklasse auto1;

Autoklasse auto2;

Über den Punktoperator: auto1.init();

auto2.gasgeben(20);

Ohne Klammern interpretiert der Compiler den Namen als Attribut, nicht als Methode.Beispiel:auto1.init; → Fehler, da init kein Attribut ist.

Weil Autoklasse die Klasse ist, keine Instanz. Methoden können nur über Objekte aufgerufen werden.

Man könnte direkt darauf zugreifen, z. B.: auto1.geschwindigkeit = 30;

Das ist aber schlechter Programmierstil, da es die Datenkapselung verletzt.

• Erhöht Fehleranfälligkeit (ähnlich wie globale Variablen).

• Man verliert Überblick über Änderungen.

• Verstößt gegen das Prinzip der Datenkapselung.

Immer über Methoden (z. B. Getter/Setter). Beispiel für einen Getter: int Autoklasse::getGeschwindigkeit() {

return geschwindigkeit;

}

cout << auto1.getGeschwindigkeit();

int wert = auto2.getGeschwindigkeit();

Die lokale Variable überdeckt das Attribut. Der Compiler arbeitet immer mit dem lokalsten Symbol.

Hier wird nur die lokale Variable zeichenkette verändert, nicht das Attribut der Klasse. Das Attribut bleibt leer.

Mit dem this-Zeiger: this->zeichenkette = zeichenkette + " geaendert";

Er ermöglicht den Zugriff auf das Attribut, wenn eine lokale Variable denselben Namen trägt.

Durch unterschiedliche Bezeichner für Attribute und lokale Variablen.

Man kann versehentlich das Attribut mit sich selbst überschreiben, was keine Wirkung hat, aber schwer zu erkennen ist.Beispiel: this->zKette = zKette; // Tippfehler: sollte zKette1 heißen

Eingeleitet mit class, abgeschlossen mit };

Einem Funktionsprototyp.

Außerhalb der Klassenvereinbarung (oft in einer separaten .cpp-Datei).

Instanzname.Methodenname(Parameter);

Um auf Attribute zuzugreifen, die denselben Namen wie lokale Variablen haben.

Eine Klasse ist ein Bauplan für Objekte. Sie definiert, welche Attribute (Daten) und Methoden (Funktionen) die Objekte haben.

Ein Objekt ist eine Instanz einer Klasse, also ein konkretes Exemplar, das nach dem Bauplan der Klasse erstellt wird.

Mit dem Schlüsselwort class gefolgt vom Klassennamen und einem Block in geschweiften Klammern.

Antwort: Mit einer schließenden geschweiften Klammer und einem Semikolon (};).

class Autoklasse {

int geschwindigkeit;

public:

void init();

void bremsen(int aenderung);

void gasgeben(int aenderung);

void ausgeben();

};

Antwort: Das Attribut int geschwindigkeit;, welches die aktuelle Geschwindigkeit des Autos speichert.

t: Es kennzeichnet Methoden oder Attribute, auf die auch von außen (außerhalb der Klasse) zugegriffen werden kann.

a, möglich. Oft werden sie aber außerhalb der Klassendefinition implementiert, um die Übersichtlichkeit zu verbessern.

Mit dem Schema Rückgabetyp Klassenname::Methodenname(…) { … }.

t: Sie setzt die Geschwindigkeit des Autos auf 0.

Sie erhöht die Geschwindigkeit um den übergebenen Wert (geschwindigkeit = geschwindigkeit + aenderung;).

Sie verringert die Geschwindigkeit um den übergebenen Wert, aber nicht unter 0.

Sie gibt die aktuelle Geschwindigkeit des Autos auf dem Bildschirm aus.

void init();

void bremsen(int aenderung);

void gasgeben(int aenderung);

void ausgeben();

void bremsen(int);

void gasgeben(int);

Autoklasse auto1;

Autoklasse auto2;

Durch Aufruf der Methode init():

auto1.init();

auto2.init();

auto1.gasgeben(20);

auto2.bremsen(10);

Antwort: Um den Code übersichtlicher zu halten und die Klassendefinition kompakt zu gestalten.

Antwort: Es ist syntaktisch erforderlich, ähnlich wie bei Strukturen (struct).

1. Klassendefinition → in einer Header-Datei (.h)

2. Methoden-Implementierung → in einer Quelldatei (.cpp)

Antwort: Wiederverwendbarkeit und zentrale Pflege von Klassen.

Menü Datei → Neu → C++-Klasse → Klassennamen eingeben → Qt erstellt automatisch Header- und Quelldatei.

Mit dem Schema

Rückgabetyp Klassenname::Methodenname(Parameterliste) { … }

Antwort: Zwei Doppelpunkte (::), der sogenannte Scope-Operator.

Antwort: Nein, nur in der Klassendeklaration steht ein Semikolon – nicht bei der Implementierung.

Daten (Variablen) und Verhalten (Funktionen), die mit den Daten arbeiten.

Menschen betrachten Objekte meist als Ganzes – Daten (z. B. Größe, Farbe) und Verhalten (z. B. „kann fahren“) werden gemeinsam gesehen.

Daten und Verhalten werden zusammengefasst und als Einheit – als Objekt – betrachtet.

Ein Objekt ist eine Einheit, die Daten (Zustand) und Verhalten (Operationen) zusammenfasst.

1. Daten → beschreiben den Zustand des Objekts

2. Verhalten → beschreibt, was das Objekt tun kann

Reale Objekte (z. B. Person, Auto, Computer) und programmtechnische Objekte (z. B. Dialogfenster).

Das Objekt.

Es kann den Zustand des eigenen Objekts oder den Zustand eines anderen Objekts verändern.

Motor läuft/nicht, Position, Richtung, Geschwindigkeit, Farbe, Ölstand, Reifentiefe usw.

: Starten (Zündschlüssel drehen), Lenken (Lenkrad drehen), Beschleunigen (Gaspedal).

Nur die Informationen, die für eine bestimmte Problemstellung wichtig sind, werden berücksichtigt; irrelevante Daten werden weggelassen.

Um gleiche oder ähnliche Eigenschaften nicht für jedes Objekt neu definieren zu müssen.

Den Bauplan für Objekte – mit gemeinsamen Eigenschaften (Attribute) und Verhalten (Methoden).

Eine Struktur, bei der allgemeine Eigenschaften in einer Oberklasse definiert und spezifische Eigenschaften in Unterklassen ergänzt werden.

Oberklasse: „Auto“ mit allgemeinen Eigenschaften (z. B. Position, Geschwindigkeit).Unterklassen: „Sportwagen“, „Geländewagen“ mit spezifischen Eigenschaften (z. B. Motorisierung, Karosserieform).

1. Konkrete Klassen: Von ihnen können Instanzen (Objekte) erzeugt werden.

2. Abstrakte Klassen: Dienen nur zur Verallgemeinerung, von ihnen können keine Instanzen erstellt werden.

Ein einzelnes Objekt, das aus einer Klasse erzeugt wird.

Antwort: Nein, die Klassenzugehörigkeit bleibt unverändert.

Jedes Objekt gehört ausschließlich einer bestimmten Klasse an.

Durch Attribute und deren Werte (Attributwerte).

Attribut: „geschwindigkeit“, Attributwert: 90 km/h.

Durch Methoden (auch Operationen genannt).

ie ändern den Zustand eines Objekts, also die Attributwerte.

Grundsätzlich nur das Objekt selbst über seine Methoden.

Jedes Objekt hat eine eindeutige Identität, die es von anderen Objekten unterscheidet – auch wenn alle Attribute identisch sind.

Durch einen eindeutigen Objektbezeichner (z. B. „Sportwagen 1“, „Sportwagen 2“).

Objektidentität bleibt immer eindeutig und unveränderlich; Attributwerte können sich ändern.

Um die Kapselung zu wahren – Objekte sollen nur über definierte Schnittstellen kommunizieren.

Über Nachrichten, die von einem Sender (Sender/Source) an einen Empfänger (Receiver) geschickt werden.

Die Menge aller Nachrichten, auf die ein Objekt reagieren kann – vergleichbar mit einer gemeinsamen Sprache.

Ein Dialogfenster (Sender) schickt die Nachricht „Öffne Datei“ an das Programmfenster (Empfänger).

Er stößt die Ausführung an, muss aber nicht wissen, wie der Empfänger die Nachricht verarbeitet.

1. Operationsaufruf

2. Signal

Der Sender ruft direkt eine Methode des Empfängers auf – Empfänger führt die Operation aus.

Eine Nachricht wird abgesetzt, Empfänger entscheiden selbst, ob und wie sie reagieren.

Ampel auf Grün → sendet Signal an nächste Ampel. Diese entscheidet selbst, ob sie ebenfalls auf Grün schaltet.

In grafischen Benutzeroberflächen (GUI-Programmierung).

Nachricht wird von einem Objekt zum nächsten weitergereicht – nur ein Objekt ist jeweils aktiv.Beispiel: „Grüne Welle“ bei Ampeln.

Nachricht wird gleichzeitig an mehrere Empfänger geschickt, mehrere Objekte reagieren parallel.Beispiel: Mehrere Ampeln schalten gleichzeitig auf Rot.

Sender wartet, bis Empfänger Nachricht verarbeitet hat und ggf. Rückmeldung gibt.Beispiel: Suchanfrage mit direkter Ergebnisrückgabe.

Sender wartet nicht, arbeitet weiter, während Empfänger Nachricht im Hintergrund bearbeitet.Beispiel: Hintergrundaktion, deren Ergebnis später zurückkommt.

Zeigerarten wie Funktionszeiger oder typenlose Zeiger, die nicht ständig genutzt werden, aber bestimmte Probleme elegant lösen können.

Ein Zeiger, der auf die Adresse einer Funktion zeigt, sodass man Funktionen über denselben Zeigeraufruf ausführen kann.

int (*rechnen)(int, int);

➡ Rückgabetyp + (*Zeigername) + Parameterliste.

Durch Zuweisung des Funktionsnamens ohne Klammern:

rechnen = addieren;

rechnen = multiplizieren;

cout << rechnen(5,5) << '\n';

➡ ohne Dereferenzierungsoperator *.

Erste Ausgabe: 10, zweite Ausgabe: 25.

ntwort: Erleichtert den Umgang mit Funktionszeigern, da Funktionen als Objekte behandelt werden können.

function<int(int,int)> rechnen = addieren;

Antwort: Ein Zeiger auf void, der auf beliebige Typen zeigen kann.

*(int*)zeiger = 9;

Antwort: Eine explizite Typumwandlung (Typecasting) ist zwingend erforderlich:

*(int*)zeiger = 9;

Antwort: Weil hier nicht in einen Zeiger auf int, sondern in einen Wert von Typ int umgewandelt würde.

delete((int*)zeiger);

Wenn ein Zeiger für unterschiedliche Datentypen genutzt werden soll oder der Typ erst zur Laufzeit bekannt ist.

Speicher wird erst zur Laufzeit eines Programms angefordert und kann auch wieder freigegeben werden.

Speicher wird für Variablen fest bei der Programmausführung reserviert. Lokale Variablen werden nach Funktionsende freigegeben, globale bleiben während der gesamten Laufzeit erhalten.

Man muss die benötigte Speichergröße vorab festlegen. Bei zu kleiner Obergrenze → Programmfehler, bei zu großer Obergrenze → Speicher wird verschwendet.

Wenn z. B. ein Array auf 100 Elemente beschränkt ist, kann man nicht mehr speichern. Setzt man es auf 100000, wird viel ungenutzter Speicher blockiert.

peicher dynamisch nur dann anfordern, wenn er gebraucht wird → z. B. über eine verkettete Liste.