C++

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

In vier Schritten: Verbindung herstellen, Daten abfragen, Daten verarbeiten, Verbindung schließen.

Klassen aus dem Modul QtSql, z. B. QSqlDatabase, QSqlQuery, QSqlTableModel.

Der Eintrag QT += sql muss ergänzt werden.

QSqlDatabase.

Über QSqlDatabase::addDatabase(), z. B. mit dem Treibernamen "QSQLITE".

it der Methode setDatabaseName().

Mit open(), das true oder false zurückgibt.

ber lastError().text() der Klasse QSqlDatabase

QSqlQuery.

Mit der Methode exec().

Eine Sammlung von Datensätzen, die durch eine SQL-Abfrage zurückgegeben werden.

Mit der Methode next().

Mit value(Spaltenindex).

Bei 0

Weil value() den allgemeinen Typ QVariant zurückgibt.

Durch Umwandlung mit toStdString().

Um Ressourcen freizugeben und Fehler zu vermeiden.

close().

Für den Zugriff auf Datenbanktabellen ohne eigene SQL-Anweisungen.

: Mit der Methode setTable().

Mit der Methode select().

Durch Einfügen einer neuen Zeile mit insertRow().

Über rowCount() des Modells.

Mit setData() in Kombination mit index().

Mit submitAll().

Es blockiert andere Fenster, bis es geschlossen wird.

Sie reagieren auf Benutzeraktionen wie Button-Klicks.

Slots werden automatisch mit passenden Signalen verbunden.

m Hauptfenster der Anwendung.

Um beim Schließen des Fensters z. B. die Datenbank sauber zu schließen.

QTableView.

Mit setModel().

Mit setHeaderData().

Die Spaltennamen aus der Datenbank werden verwendet.

Änderungen werden automatisch in die Datenbank übernommen.

Antwort: Model – View – Controller.

Es repräsentiert und verwaltet die Daten.

Sie stellt die Daten grafisch dar.

Er verarbeitet Benutzereingaben und steuert Aktionen.

View und Controller sind oft in einer Klasse kombiniert (z. B. QTableView).

1. Listenansicht: zeigt alle Datensätze

2. Detailansicht: zeigt und bearbeitet einen einzelnen Datensatz

1. Navigation zwischen Datensätzen

2. Auslösen von Aktionen wie Neu, Löschen oder Speichern

1. Strukturierte Eingabe neuer Daten

2. Übersichtliche Bearbeitung komplexer Datensätze

Eine strukturierte Sammlung von Daten, die elektronisch gespeichert und verwaltet werden.

Eine zusammengehörige Menge von Informationen zu einem Objekt, z. B. zu einer Person.

Ein einzelnes Merkmal eines Datensatzes, z. B. Name oder Telefonnummer.

Damit Daten eindeutig gespeichert, abgefragt und verarbeitet werden können.

Ein Datenmodell, bei dem Daten in Tabellen mit Zeilen und Spalten organisiert sind.

1. Attribute: Spalten einer Tabelle

2. Tupel: Zeilen bzw. einzelne Datensätze

Ein eindeutiges Attribut zur Identifikation eines Datensatzes.

Ein Attribut, das auf den Primärschlüssel einer anderen Tabelle verweist.

Um Beziehungen zwischen Tabellen herzustellen und Datenredundanz zu vermeiden.

Eine Software zur Verwaltung von Datenbanken und zur Bereitstellung von Datenzugriffen.

Eine standardisierte Sprache zur Abfrage und Bearbeitung von Daten in relationalen Datenbanken.

Weil Frameworks oder Bibliotheken den Datenbankzugriff abstrahieren.

Über eine spezielle Qt-Datenbankschnittstelle mit einheitlichen Klassen.

Unabhängigkeit vom konkreten Datenbanksystem und einheitliche Programmierung.

Sie übersetzen allgemeine Datenbankbefehle in systemabhängige Anweisungen.

• Portabilität

• Weniger Fehleranfälligkeit

• Einfachere Wartung

Ein Mechanismus zur Kommunikation zwischen GUI-Elementen und Programmcode.

Eine Methode, die auf ein Signal (z. B. Button-Klick) reagiert.

Qt verbindet Signale und Slots automatisch anhand ihrer Namenskonvention.

Um die Programmstruktur früh festzulegen und die Funktionalität schrittweise zu ergänzen.

• Speichern von strukturierten Daten (z. B. Kunden, Fahrzeuge)

• Anlegen, Ändern und Löschen von Datensätzen

• Anzeigen von Daten in Listen- und Detailansichten

• Bessere Wartbarkeit

• Klare Aufgabenverteilung

• Austauschbarkeit der Datenbank ohne große Änderungen an der Anwendung

• Listenansicht: zeigt alle Datensätze

• Detailansicht: zeigt und bearbeitet einen einzelnen Datensatz

1. Navigation zwischen Datensätzen

2. Auslösen von Aktionen wie Neu, Löschen oder Speichern

1. Strukturierte Eingabe neuer Daten

2. Übersichtliche Bearbeitung komplexer Datensätze

Eine strukturierte Sammlung von Daten, die elektronisch gespeichert und verwaltet werden.

ine zusammengehörige Menge von Informationen zu einem Objekt, z. B. zu einer Person.

Beim sequenziellen Zugriff werden Daten nacheinander gelesen oder geschrieben. Beim direkten Zugriff kann man über einen Positionszeiger eine beliebige Stelle innerhalb der Datei ansteuern und dort lesen oder schreiben.

Über einen internen Positionszeiger, der nach jedem Lese- oder Schreibvorgang automatisch um die Anzahl der verarbeiteten Bytes weitergesetzt wird.

seek() der Klasse QIODevice.

Sie liefert die Größe einer Datei in Bytes und dient u. a. dazu, Überläufe beim Positionieren zu vermeiden.

Weil dann ungültige Daten gelesen würden, was zu Fehlern und undefiniertem Verhalten führt.

Damit man sicherstellen kann, dass noch genügend Bytes in der Datei vorhanden sind (ein int benötigt 4 Bytes). Die letzte gültige Position ist daher: Dateigröße - 4.

Pro Eintrag: zuerst die Punkte (int), danach der Name (QString inkl. Längenangabe).

Weil Qt bei QString-Speicherung automatisch zuerst die Länge des Strings speichert.

atEnd() der Klasse QFile.

Die Länge des Namens lesen → über seek(pos + Länge) den Zeiger weiterstellen.

in.status() != QDataStream::Ok.

Es wird eine Meldung wie „Kein Eintrag gefunden.“ angezeigt.

Kopiert eine Datei. Entweder auf ein QFile-Objekt bezogen oder als statische Methode mit Quell- und Zielnamen.

Sie prüft, ob eine Datei existiert (liefert true/false).

Den vollständigen Dateinamen des zugehörigen QFile-Objekts.

Um den Pfad einer Datei zu bestimmen.

Löscht eine Datei.

Benennt eine Datei um.

Wechselt in einen Ordner (Unterverzeichnis).

Wechselt in das übergeordnete Verzeichnis.

Die Anzahl der Objekte im Ordner (Dateien + Unterordner).

Den aktuellen Arbeitsordner der Anwendung.

Den Namen des aktuellen Ordners, aber ohne Pfad.

Es prüft, ob der Ordner das Wurzelverzeichnis ist.

Erstellt einen neuen Ordner.

Erstellt einen kompletten Ordnerpfad inklusive aller fehlenden Zwischenordner.

Benennt einen Ordner um.

Löscht einen einzelnen Ordner (falls er leer ist).

Löscht einen kompletten Ordnerpfad.

Setzt den aktuellen Arbeitsordner der Anwendung.

Die Klasse QFile, abgeleitet von QIODevice, dient zum Anlegen, Öffnen, Schließen, Lesen und Schreiben von Dateien.

1. Dateiobjekt erzeugen: QFile *datei = new QFile("dateiname");

2. Datei öffnen mit Modus: datei->open(QIODevice::WriteOnly);

1. QIODevice::Append → an bestehende Datei anhängen

2. QIODevice::ReadOnly → nur lesen

3. QIODevice::WriteOnly → nur schreiben

4. QIODevice::ReadWrite → lesen und schreiben

1. Einzelzeichen: getChar(), putChar()

2. Mehrere Zeichen oder ganze Texte: read(), readAll(), write()

QDataStream kann beliebige Daten binär speichern, nicht nur Text, z. B. Zahlen im ursprünglichen Bitmuster.

1. Schreiben: Stream-Operator <<

2. Lesen: Stream-Operator >>

Die Daten müssen im gleichen Datentyp gelesen werden, in dem sie gespeichert wurden, sonst kommt es zu falscher Interpretation (z. B. int vs. short vs. double).

1. Methode status() → gibt QDataStream::Ok zurück, wenn alles korrekt gelesen wurde

2. Methode atEnd() → prüft, ob das Dateiende erreicht ist

1. Datei öffnen (QFile)

2. QDataStream out(datei) erzeugen

3. Schleife über Listenelemente: item(zaehler)->write(out)

4. Datei schließen (datei->close())

1. Datei öffnen (QFile)

2. QDataStream in(datei) erzeugen

3. Solange nicht atEnd(): neue QListWidgetItem erzeugen, read(in) aufrufen, addItem() ins Listenfeld

4. Datei schließen

Mit findChildren<T*>() eine Liste aller Widgets vom Typ T erzeugen und dann in einer Schleife darauf zugreifen.

QList<QLineEdit*> widgetListe = findChildren<QLineEdit*>();

Über den Index zaehler und die Methode at(), z. B. widgetListe.at(zaehler).

Mit der Methode size(), z. B. widgetListe.size().

1. Liste erstellen: QList<QLineEdit*> widgetListe = findChildren<QLineEdit*>();

2. Datei öffnen: datei->open(QIODevice::WriteOnly);

3. QDataStream out(datei) erzeugen

4. Schleife über alle Widgets:for (int zaehler = 0; zaehler < widgetListe.size(); zaehler++)

   out << widgetListe.at(zaehler)->text();

   
   

1. Datei öffnen: datei->open(QIODevice::ReadOnly);

2. QDataStream in(datei) erzeugen

3. Liste der Widgets erstellen: QList<QLineEdit*> widgetListe = findChildren<QLineEdit*>();

4. Schleife: for (int zaehler = 0; zaehler < widgetListe.size(); zaehler++) {

   QString inhalt;

   in >> inhalt;

   widgetListe.at(zaehler)->setText(inhalt);

   }

   Datei schließen

Mit datei->error() prüfen und z. B. QMessageBox::critical() anzeigen.

QDataStream.

<< zum Schreiben, >> zum Lesen.

Daten müssen in derselben Reihenfolge und mit dem richtigen Typ gelesen werden, in dem sie gespeichert wurden. Falscher Typ führt zu fehlerhaften Werten.

read(), write(), open(), close() sowie Methoden wie getChar(), putChar() für Einzelzeichen.

Um Ressourcen freizugeben und sicherzustellen, dass alle Daten korrekt gespeichert wurden.

findChildren<T*>(), z. B. findChildren<QLineEdit*>().

QTextStream.

1. MainWindow: enthält Menü- und Statusleiste

2. TextEdit: Darstellung und Bearbeitung von Text

3. QFileDialog: Datei laden/speichern

Neu, Öffnen, Speichern, Beenden (optional Trennlinie vor Beenden)

Aktionen aus dem Aktionseditor auf die Symbolleiste ziehen (Icons aus Ressourcen-Datei).

Durch Setzen eines Layouts (z. B. horizontal) auf das gesamte Formular.

1. void dateiNeu();

2. void dateiOeffnen();

3. void dateiSpeichern();

Mit connect(), z. B.: connect(ui->action_Neu, SIGNAL(triggered(bool)), this, SLOT(dateiNeu()));

Durch eine QMessageBox mit Ja/Nein-Optionen und anschließendem exec()-Aufruf.

ui->textEdit->clear();

1. Datei mit QFileDialog::getOpenFileName() auswählen

2. Prüfen, ob ein Dateiname vorliegt

3. Datei per QFile im ReadOnly-Modus öffnen

4. Inhalt mit readAll() laden

5. Inhalt mit setPlainText() anzeigen

6. Statusleiste per showMessage() informieren

7. Datei schließen

Weil readAll() ein QByteArray liefert und TextEdit ein QString erwartet.

1. Speicherpfad mit QFileDialog::getSaveFileName() wählen

2. Prüfen, ob Dateiname vorhanden

3. Datei im WriteOnly-Modus öffnen (legt neue Datei an)

4. Text mit toPlainText().toUtf8() holen

5. Mit write() in die Datei schreiben

6. Statusmeldung anzeigen

7. Datei schließen

1. Datei anschließend immer schließen, sonst ist sie evtl. leer

2. Benutzer muss .txt im Dateinamen selbst angeben (Filter erzwingt keine Endung)

exec()

1. Anzeigen: setPlainText()

2. Auslesen: toPlainText()

ui->statusbar->showMessage("Text", 5000);

Mit hasError(). Bei Fehlern sollte eine Meldung angezeigt und der Vorgang abgebrochen werden.

Sie arbeiten ausschließlich sequenziell – es kann nicht beliebig im Dokument gesprungen werden.

Das Einlesen scheitert oder liefert falsche Ergebnisse.

Die Klasse QDomDocument, die Navigieren, Ändern und Einfügen an beliebigen Stellen erlaubt.

XML steht für Extensible Markup Language. Es ist ein textbasiertes, strukturiertes Format zur Beschreibung von Daten und eignet sich für den anwendungsübergreifenden Austausch.

Ein XML-Dokument besteht aus einer hierarchischen Baumstruktur mit einem Wurzelelement und beliebigen Unterelementen (Knoten).

Tags stehen in spitzen Klammern und bestehen normalerweise aus einem Start-Tag <tag> und einem End-Tag </tag>. Sie sind case-sensitive.

Ein Tag-Name darf nicht „xml“ heißen, muss mit Buchstabe oder Unterstrich beginnen und Groß-/Kleinschreibung beachten.

Sie steht zu Beginn eines XML-Dokuments und enthält u. a. Version und Zeichensatz, z. B. <?xml version="1.0" encoding="UTF-8"?>.

Kommentare werden mit <!-- eingeleitet und mit --> beendet.

Es ist das oberste Element, das alle anderen Elemente einschließt – ein Dokument darf genau ein solches Element haben.

Antwort: Mit jedem Texteditor – wichtig ist die Speicherung im UTF-8-Format.

Durch Öffnen im Browser – bei Fehlern wird meist eine Fehlermeldung angezeigt.

: Er dient zum sequenziellen Einlesen von XML-Daten Knoten für Knoten.

: Man ruft wiederholt eine Methode wie readNext() auf, um zum nächsten Knoten zu gelangen.

Der Reader liefert einen speziellen Typ (z. B. „StartElement“), der geprüft werden kann.

Über eine Methode wie readElementText(), die den Inhalt zwischen Start- und End-Tag zurückgibt.

Über eine Methode wie hasError(), die prüft, ob beim Lesen Probleme aufgetreten sind.

Eine Methode wie atEnd() liefert true.

Weil manche Methoden, z. B. das Lesen von Elementtext, nur für bestimmte Knotentypen geeignet sind.

Die Datei muss existieren und im passenden Modus (z. B. „Nur Lesen“) geöffnet werden.

L setzt korrekte Zeichensatzangaben voraus – oft wird UTF-8 verwendet, da es viele Zeichen unterstützt.

Man prüft, ob der Reader den Knotentyp StartDocument liefert, und liest dann Version und Encoding aus.

documentVersion() und documentEncoding().

Wie können die ausgelesenen Deklarationsinformationen angezeigt werden?

Durch Aufruf von writeStartDocument(), das automatisch Version 1.0 und UTF-8 setzt.

Mit writeStartElement("name") wird ein Element geöffnet, mit writeEndElement() geschlossen.

Mit writeTextElement("elementname", "wert"). Das End-Tag wird dabei automatisch erzeugt.

Über QFile::open(QIODevice::WriteOnly) wird sie im Schreibmodus geöffnet.

Ob die Datei bereits existiert – sonst ggf. Meldung ausgeben und Schreiben abbrechen.

Es aktiviert automatische Einrückung und Zeilenumbrüche, was die XML-Datei lesbarer macht.

1. Datei öffnen

2. Writer erstellen

3. writeStartDocument()

4. Wurzelelement beginnen

5. Unterelemente schreiben

6. Elemente schließen

7. Dokument schließen

8. Datei schließen

Weil der zugehörige StreamReader die Daten später in derselben Reihenfolge erwartet.

Durch Anhängen von „.xml“ an den Pfad der laufenden Anwendung, z. B. via applicationFilePath().

Mit QFile::exists(dateiname).

Beliebige Texteingaben, boolesche Einstellungen, Zahlen oder weitere strukturierte Daten.

Als Text: "true" oder "false".

Als Elemente wie <top> und <left> mit den aktuellen x/y-Werten.

Sie müssen vor dem Schreiben in Zeichenketten umgewandelt werden (z. B. QString::number()).

Wert aus readElementText() auslesen und anschließend mit toInt() in eine Zahl umwandeln.

Über Prüfung des Rückgabewerts von readNext() gegen StartElement.

Ja

1. Zu jedem try-Block müssen die catch-Blöcke direkt folgen.

2. Ein innerer try-Block kann catch-Blöcke des äußeren Blocks nutzen, wenn er keine passenden eigenen hat.

3. Ein äußerer Block kann niecatch-Blöcke eines inneren nutzen.

Mit dem Schlüsselwort throw.

Jeder beliebige Typ (z. B. int, string, char*, Objekte).

throw 1;

catch (int e) { … }

catch (const char* e) { … }

catch(int e) fängt Exceptions vom Typ int, catch(const char* e) fängt Exceptions vom Typ konstante Zeichenkette ab.

Die int-Ausnahmen 1 und 2 sind Exceptions vom Typ int, die default-Ausnahme ist vom Typ const char*.

Er macht die Ausnahmebehandlung übersichtlicher, strukturierter und besser lesbar.

Der Typ.

Der Compiler sucht nach einem Typ namens 1, was zu einem Übersetzungsfehler führt.

enum fehler {zuKlein, zuGross, istNull};

1. wert == 0 → wirft istNull

2. wert < 10 → wirft zuKlein

3. wert > 20 → wirft zuGross

catch(fehler e)

Um unterschiedliche Fehlerwerte (zuKlein, zuGross, istNull) verschieden zu behandeln.

ZuKlein, ZuGross, IstNull.

Jede Klasse besitzt die Methode fehler(), die eine Fehlermeldung als Text zurückgibt.

Durch Instanzwurf, z. B.:throw istNull();, throw zuKlein();, throw zuGross();

Um unnötige Kopien zu vermeiden und Polymorphie zu ermöglichen.

Der Wert der Variablen zahl wird abhängig vom Fehler angepasst (z. B. +10, –10 oder auf 10 gesetzt).

Viele Fehler entstehen durch unsaubere Programmierung, und man kann sie durch gute Tests und korrekten Code vermeiden.

Wenn das Programm nicht weiß, welche Daten eingegeben werden – z. B. durch Anwender.

Nein

Array-Grenzüberschreitung, z. B. feld[100] bei einem Array von Größe 10.

Weil Array-Grenzüberschreitungen in C++ keine Exceptions auslösen – sie verursachen undefiniertes Verhalten und führen oft später zum Absturz.

Durch sorgfältige Programmierung, Prüfungen und umfangreiche Tests

Weil es unzählige Ausführungsmöglichkeiten gibt und nicht alle vorhersehbar sind – selbst bei sorgfältiger Arbeit entstehen Fehler.

Fehler zu finden und zu korrigieren, nicht die Fehlerfreiheit zu beweisen.

Wegen der nahezu unendlichen Zahl möglicher Programmläufe und Eingaben.

Der Tester muss aktiv nach Fehlern suchen und davon ausgehen, dass das Produkt fehlerhaft ist.

Er übersieht Fehler aufgrund seiner Annahmen und Erwartungen; eine objektive Sicht fehlt.

Willkürliches Eingeben von Daten und Ausführen des Programms, bis ein Fehler auftritt.

Für einen schnellen, groben Test unmittelbar nach der Programmierung.

1. unsystematisch

2. viele Fehler bleiben unentdeckt

3. Ursache eines Fehlers ist oft unklar

Das Testobjekt wird mit Eingaben gefüttert, und die Ausgaben werden mit den erwarteten Ergebnissen verglichen – ohne Kenntnis der internen Funktionsweise.

Testfälle

1. Eingaben und erwartete Ausgaben müssen definiert sein.

2. Es müssen gültige, ungültige und unerwartete Eingaben berücksichtigt werden.

Weil selbst bei kleinen Eingabebereichen enorme Mengen an Kombinationen entstehen (z. B. 26³ mögliche 3-Buchstaben-Kombinationen für Texteingaben).

Ähnliche Eingaben werden zu Gruppen zusammengefasst, die gleiche Ergebnisse erwarten lassen – dadurch reduziert sich die Zahl der Testfälle.

Jede Klasse beschreibt eine Gruppe gleichwertiger Eingaben und wird durch Beispieldaten repräsentiert.

1. Zwei positive Zahlen

2. Positive + negative Zahl

3. Zwei negative Zahlen

4. Ungültige Eingaben (z. B. Buchstaben

1. Dynamische Tests: Programm wird ausgeführt.

2. Statische Tests: Programmcode oder Dokumente werden ohne Ausführung geprüft.

Ein Durchgehen des ausgedruckten Quelltexts „auf dem Trockenen“ – ähnlich einem Debugging per Hand.

ie distanzierte Betrachtung erleichtert das Erkennen von Fehlern oder Denkfehlern.

Pause einlegen und später mit frischem Blick erneut prüfen.

1. heißes Testen

2. funktionsorientierte Tests / Blackbox-Tests

3. Äquivalenzklassen

4. statische Tests (z. B. Schreibtischtest)

Weil Benutzer ungültige Werte eingeben können oder das Programm in unerwartete Zustände gelangt.

Die Division durch null.

Das Programm wird abgebrochen.

Sie liefern NaN, +∞ oder –∞ (z. B. Ausgabe: inf).

Durch eine vorherige Überprüfung, z. B. if (zahl2 == 0).

1. Quelltext wird schnell unübersichtlich

2. eigene Prüfungen können Fehler enthalten

3. nicht alle Fehler sind vorhersehbar oder prüfbar

Mit toFloat() und einem bool-Referenzparameter, der bei Fehlern auf false gesetzt wird.

Es wird eine Exception vom Typ std::bad_alloc ausgelöst.

terminate called after throwing an instance of 'std::bad_alloc'

Eine Ausnahme, die bei Laufzeitfehlern ausgelöst wird.

Das Abfangen und Behandeln von Exceptions durch den Programmierer.

terminate()

Er enthält Anweisungen, die auf Exceptions überprüft werden sollen.

Er verarbeitet die Ausnahme, wenn sie im try-Block ausgelöst wurde.

try = „versuche“, catch = „fange“.

Es fängt alle möglichen Ausnahmen ab (universeller Handler).

Nein, sie sind immer erforderlich.

Alle nachfolgenden Anweisungen im try-Block werden übersprungen.

Immer der erste passende catch-Block.

Immer als letzter catch-Block.

Eine Exception der Klasse out_of_range.

catch (ExceptionTyp&)

bad_alloc

Durch mehrere catch-Blöcke, z. B.:

1. catch(out_of_range&)

2. catch(bad_alloc&)

3. catch(...) (für alle übrigen)

Setze einen Haltepunkt (z. B. in taschenrechner.cpp bei Einlese-Anweisungen) und starte das Debuggen über das Debug-Symbol oder die entsprechende Funktionstaste. Dann Eingaben machen und die Aktion (z. B. „Berechnen“) auslösen.

Er unterbricht die Programmausführung an einer definierten Stelle, sodass man Variablen, Programmfluss und Anweisungen schrittweise untersuchen kann.

Mit den Einzel-Schritt-Funktionen (Step Into / Step Over) kann man Anweisungen einzeln ausführen und beobachten, wie Variablenwerte und Verzweigungen sich verändern.

ebugging abbrechen, den Quellcode korrigieren, Programm neu übersetzen (kompilieren) und erneut ausführen/prüfen.

Rechtsklick links neben der Zeilennummer und „Ausführen bis Zeile“ (oder im Menü Debuggen) wählen — das Programm läuft bis zu dieser Zeile und stoppt dort.

Haltepunkte, die nur dann ausgelöst werden, wenn eine angegebene Bedingung (logischer Ausdruck) wahr ist — z. B. i == 100 oder ptr != nullptr.

Haltepunkt setzen → Rechtsklick auf das Haltepunkt-Symbol → „Haltepunkt bearbeiten…“ → Im Bereich „Erweitert“ im Feld „Bedingung“ den logischen Ausdruck eingeben.

Der Haltepunkt wird erst ausgelöst, nachdem die Anweisung eine bestimmte Anzahl von Malen ausgeführt wurde (Hit-Count). In Kombination mit einer Bedingung muss die Bedingung entsprechend oft erfüllt worden sein.

Nahezu alles, was in einer normalen if-Abfrage möglich ist (Vergleiche, logische Operatoren, etc.), solange die verwendeten Variablen an dieser Stelle dem Debugger bekannt sind.

Ungültige Ausdrücke werden übernommen, aber bei der Ausführung ignoriert (sie lösen den Haltepunkt nicht zuverlässig aus).

m Quelltext den Bezeichner anklicken → Kontextmenü → „Ausdruck auswerten“; oder rechts oben im Debug-Fenster Rechtsklick → „Neuen ausgewerteten Ausdruck hinzufügen…“ und dort den Ausdruck eingeben.

Einfachen Bezeichnern, Vergleichen und beliebigen berechenbaren Ausdrücken (z. B. a+b, vec.size() > 0), sofern sie zum Zeitpunkt des Stopps gültig sind.

m Bereich mit den lokalen Variablen (rechts oben) in die Spalte „Wert“ der betreffenden Variablen doppelklicken und den neuen Wert eingeben; danach weiter ausführen — das Programm verwendet dann den geänderten Wert.

Nur in der Spalte „Wert“ doppelklicken (andere Spalten funktionieren nicht). Variablenänderung kann Seiteneffekte haben; der neue Wert muss zum Typ passen und die Anwendung kann daraufhin anders laufen.

Ausdrücke und Variablen sind nur dann bekannt/auswertbar, wenn sie im aktuellen Stack-Frame bzw. Gültigkeitsbereich sichtbar sind; sonst führt die Auswertung nicht zum erwarteten Ergebnis.

Sie vermeiden unnötige Stopps bei häufig aufgerufenen Stellen und erlauben gezieltes Anhalten z. B. nur bei einem bestimmten Wert oder beim n-ten Durchlauf — effizienteres Debugging bei Schleifen/rekursiven Aufrufen.

1) Problem reproduzieren und Vermutungen bilden; 2) Haltepunkt an sinnvoller Stelle setzen; 3) Debugger starten, schrittweise ausführen; 4) Variablen und Bedingungen prüfen (auswerten/anzeigen); 5) Fehlerquelle lokalisieren; 6) Code korrigieren, neu kompilieren und testen.

Ein Werkzeug zur Fehlersuche in Programmen; „debuggen“ bedeutet Fehler suchen und beheben.

Der Begriff kommt von „Bug“ (Fehler/Insekt) — früher verursachte ein Insekt Kurzschlüsse; „debuggen“ = Fehler entfernen.

: Programm Anweisung für Anweisung ausführen; Inhalte von Datenobjekten (z. B. Variablen) anzeigen.

In den Modus „Debuggen“.

Es wird gestartet und läuft sofort bis zum Ende durch — Haltepunkte werden benötigt, damit es anhält.

Eine Markierung in einer Quelltextzeile, bei deren Erreichen die Programmausführung angehalten wird.

1) Einfügemarke in die Zeile stellen und Funktionstaste drücken; 2) Menü „Debuggen → Haltepunkt umschalten“; 3) Mit der Maus links neben die Zeilennummer klicken.

: Links vor der Zeile erscheint eine rote Kugel (roter Punkt).

Der Haltepunkt wird bei der Ausführung ignoriert.

Dieselbe Funktion zum Setzen des Haltepunktes in derselben Zeile erneut aufrufen (oder aufs Symbol klicken).

Die Anweisung, die als Nächstes vom Debugger ausgeführt wird.

„Einzelschritt herein“ (step into).

„Einzelschritt über“ (step over).

„Einzelschritt heraus“ (step out).

Die gesamte Funktion wird ausgeführt, das Ergebnis zugewiesen, und der Debugger markiert die nächste Zeile in der aufrufenden Funktion.

Wenn das schrittweise Ausführen mit dem Debugger nicht wie erwartet funktioniert (z. B. bei optimiertem Code oder fehlenden Debug-Informationen).

Ein Werkzeug, das Programmanweisungen in Maschinensprache/Assembler darstellt.

Auf „Fortsetzen“ klicken oder entsprechende Funktionstaste — das Programm läuft bis zum nächsten Haltepunkt oder bis zum Ende.

Im Bereich rechts oben (oder im Variablen-/Watches-Bereich) während des Debuggens.

Weil die Variable in der Quelle initialisiert wurde; Änderung der Initialisierung (+ neu starten im Debugger) zeigt den neuen aktuellen Wert an.

Das Programm muss mit der Debug-Konfiguration (nicht Release) übersetzt werden; die aktive Konfiguration sieht man unten links.

Nein — Haltepunkte werden dann ignoriert.

Haltepunkt in die Zeile setzen → Debugger starten → Ausführung stoppt am Haltepunkt (gelber Pfeil) → „Einzelschritt herein“ verwenden, um Schleifendurchläufe einzeln auszuführen und Variablenwerte zu beobachten.

Auf „Debugger anhalten“ klicken oder die Funktion Debuggen → Debugger anhalten wählen.

„Einzelschritt herein“ springt in aufgerufene Funktionen hinein; „Einzelschritt über“ führt aufgerufene Funktionen komplett aus, ohne hineinzuspringen.

Haltepunkt in die Zeile while (zaehler < 10) setzen, Programm im Debugger starten und mit Einzelschritten Schleifendurchläufe beobachten; später zaehler initial auf 1 setzen und erneut testen.

Ein Syntaxfehler ist ein Verstoß gegen die Regeln der Programmiersprache, z. B. fehlendes Semikolon oder falsche Klammer.👉 Wird vom Compiler automatisch erkannt.

Ein Semantikfehler ist ein Fehler in der Programmlogik.👉 Wird vom Compiler nicht erkannt.

Durch Testausgaben, z. B.:cout << "Im ersten Zweig \n";Sie zeigen, welcher Codeabschnitt ausgeführt wird.

1. Müssen umständlich eingefügt und später wieder gelöscht werden

2. Liefern nur begrenzte Informationen

3. Werden oft versehentlich im Code vergessen („Hallo“, „Huhu“)

Durch Testausgaben im Funktionskörper, z. B.:cout << "Wert 1 ist: " << wert1 << '\n';

Debugger bieten:

• Ausführliche Laufzeitinformationen

• Breakpoints

• Schrittweises Ausführen

• Beobachten von Variablenwerten 👉 Deutlich effizienter und übersichtlicher.

Es wird gleichzeitig eine passende Aktion (QAction) angelegt, die im Aktionseditor erscheint.

Im Aktionseditor des Qt Creators – dieser zeigt alle Aktionen des Projekts und erlaubt deren Konfiguration.

1. ToolTip (Bildschirmtipp)

2. Icon/Symbol

3. Tastenkürzel

4. Objektname

5. Statusinformationen

Durch Doppelklick auf die Aktion im Aktionseditor.

Es ermöglicht das Starten einer Funktion direkt über die Tastatur, unabhängig davon, ob das Menü geöffnet ist.

Es markiert ein Zeichen für die Tastaturbedienung innerhalb eines geöffneten Menüs (Mnemonics).

Aktion markieren → Kontextmenü → „Slot anzeigen…“ → passendes Signal (meist triggered()) wählen → Slot wird automatisch erzeugt.

Die Methode close().

Man sollte keine unüblichen oder widersprüchlichen Kürzel verwenden – sich an Standardanwendungen orientieren.

Über das Kontextmenü des Formulars → „Werkzeugleiste hinzufügen“.

Durch Drag-and-Drop einer vorhandenen Aktion aus dem Aktionseditor auf die Symbolleiste.

Man muss der Aktion ein Icon zuweisen.

Durch das Anlegen einer Qt-Ressourcen-Datei (.qrc) und das Hinzufügen der gewünschten Dateien im Ressourceneditor.

Ein Ordnername innerhalb der Ressourcenstruktur, unter dem Symbole oder Dateien gruppiert werden (z. B. /bilder).

Aktion bearbeiten → Icon-Auswahl öffnen → im Ressourcenbrowser das passende Symbol wählen.

Über den Aktionseditor → Neue Aktion → Name, Text, ToolTip, Icon und Objektname festlegen.

Zum optischen Gruppieren von Werkzeugen und zur besseren Übersichtlichkeit.

Um Mausereignisse wie mousePressEvent() und mouseReleaseEvent() zu überschreiben und eigenes Zeichnen auf einer Pixmap zu ermöglichen.

Die Startposition der Maus (mausStartPosition) wird gespeichert.

Je nach gewählter Zeichenaktion wird auf die Pixmap gezeichnet und anschließend wird die Pixmap mit setPixmap() aktualisiert.

1. Die Größe des Labels wird festgelegt.

2. Eine neue Pixmap wird erstellt.

3. Pixmap wird weiß gefüllt.

4. Pixmap wird dem Label zugewiesen.

1 = Kreis/Ellipse

2 = Linie

3 = Rechteck

Speichert die Startposition, wenn die linke Maustaste gedrückt wird.

1. Erstellt QPainter für die Pixmap

2. Setzt Stiftfarbe

3. Zeichnet je nach Aktion Linie, Ellipse oder Rechteck

4. Aktualisiert das Label mit setPixmap()

Durch die Differenz zwischen Start- und Endposition.

Setzt den Wert von zeichenAktion – wird in den Slots der Symbolleiste genutzt.

Als zeichenLabel, erzeugt im Konstruktor von MainWindow.

Mit setCentralWidget(zeichenLabel).

Über setFixedSize().

Kreis (1) im Konstruktor des MainWindow.

1. stift (QPen)

2. meineFarbe (QColor)

Jeder QPainter setzt den Stift neu beim Erzeugen—Farbe muss daher vorher aktualisiert werden.

Setzt meineFarbe auf eine übergebene QColor.

stift.setColor(meineFarbe);

myPainter.setPen(stift);

Über QColorDialog::getColor(), Validitätsprüfung mit isValid().

Mit eraseRect() der QPainter-Klasse, anschließend setPixmap().

1. Aktion hinzufügen

2. Policy setzen: setContextMenuPolicy(Qt::ActionsContextMenu)

Wenn Qt::ActionsContextMenu gesetzt ist, werden alle Aktionen des Widgets verwendet.

Ein QLabel (z.B. aktionsLabel), über addWidget().

Zunächst „Kreis“ (die Standardaktion).

Durch Anpassen des Textes, z. B.aktionsLabel->setText("Kreis");

In der Menüleiste den Eintrag Hilfe erstellen und darin den Menüpunkt Info… anlegen

Es wird eine Messagebox mit einem Infosymbol angezeigt.

QMessageBox::information(this, "Information",

"Programmiert von <Mein Name>");

Der eigene Name des Programmierers.

Die entsprechende Header-Datei muss eingebunden werden.

Eine Grafikdatei (z. B. BMP oder ICO) zu den Projektressourcen hinzufügen und die Eigenschaft windowIcon des Hauptfensters darauf setzen.

: BMP, ICO und andere gebräuchliche Formate.

1. mousePressEvent() – wird ausgelöst, wenn eine Maustaste gedrückt wird.

2. mouseReleaseEvent() – wird ausgelöst, wenn eine Maustaste losgelassen wird.

3. mouseMoveEvent() – wird ausgelöst, wenn die Maus bewegt wird.

4. mouseDoubleClickEvent() – wird bei einem Doppelklick ausgelöst.

1. Mausposition (z. B. über x() und y() oder position()).

2. Welche Taste gedrückt wurde (z. B. button() → Qt::LeftButton, etc.).

Man muss unterscheiden zwischen:

• Maus gedrückt → Startpunkt speichern

• Maus losgelassen → Endpunkt speichern und zeichnen Dies erfolgt über mousePressEvent() und mouseReleaseEvent().

Weil man die paintEvent()-Methode überschreiben muss, um eigene Zeichenoperationen auszuführen.

paintEvent() wird immer dann ausgeführt, wenn das Widget neu gezeichnet werden muss. Darin können mit einem QPainter beispielsweise Linien oder Formen gezeichnet werden.

update() fordert ein Neuzeichnen an und sorgt dafür, dass paintEvent() bald aufgerufen wird (nicht sofort).Im Gegensatz dazu erzwingt repaint() sofortiges Zeichnen.

1. Eine Linie erscheint beim Start, weil Start- und Endpunkte Nullwerte haben.

2. Man kann mit jeder Maustaste zeichnen, wenn nicht explizit geprüft wird.

3. Alte Linien verschwinden, wenn nur im Label selbst gezeichnet wird (statt auf einem persistenten Bild).

Durch Einführung eines booleschen Attributs, das steuert, ob gezeichnet werden soll (erst aktiv, nachdem eine echte Eingabe erfolgt).

Weil ein QPixmap den Inhalt dauerhaft speichert, während das Label beim Neuzeichnen alte Inhalte überschreibt. So bleiben die gezeichneten Elemente erhalten.

1. Linien zeichnen

2. Rechtecke zeichnen

3. Kreise oder Ellipsen zeichnen

4. Farbe über einen Farbdialog auswählen

5. Zeichenfläche löschen

1. MenuBar für Einträge wie „Datei → Beenden“.

2. ToolBar bzw. Symbolleiste für Zeichenwerkzeuge.

3. Kontextmenü zum schnellen Löschen der Zeichenfläche.

Über die automatisch bereitgestellte QMenuBar.Einträge werden über den Editor angelegt, Aktionen (Logik) über entsprechende QAction-Objekte.

Das nächste Zeichen wird zur Tastenkombination für die Tastatursteuerung (Mnemonic).

Durch Übergabe des Elternobjekts an den Konstruktor und Weitergabe über die Initialisierungsliste, z. B.:MyWidget::MyWidget(QWidget *parent) : QLabel(parent) {}

Durch Doppelklick auf einen leeren Menüeintrag, Eingabe des gewünschten Textes (inkl. & für Tastaturzugriff) und Bestätigen mit Enter.

Die Klasse QPen für Linien (Stift) und QBrush für Füllungen (Pinsel).

• QPen = „Stift“ → steuert Linienfarbe, -breite, -stil usw.

• QBrush = „Pinsel“ → steuert Füllfarbe, Füllmuster oder Verläufe.

Mit der Klasse QPainter.

Mit myPen.setColor(Qt::red); oder direkt mit myPainter.setPen(Qt::red);

Qt:: (z. B. Qt::blue, Qt::white).

myPen.setColor(QColor(rot, gruen, blau));

setStyle() mit einem Wert aus Qt::PenStyle.

1. Qt::NoPen – keine Linie

2. Qt::SolidLine – durchgezogene Linie

3. Qt::DashLine – gestrichelt

4. Qt::DotLine – gepunktet

5. Qt::DashDotLine – Strich-Punkt

6. Qt::DashDotDotLine – Strich-Punkt-Punkt

Mit myPen.setWidth(int).

Mit setCapStyle(), z. B. Qt::RoundCap für abgerundete Enden.

setStyle() mit einem Wert aus Qt::BrushStyle.

1. Qt::SolidPattern – gleichmäßig gefüllt

2. Qt::Dense1Pattern bis Qt::Dense7Pattern – verschiedene Dichten

3. Qt::HorPattern – horizontale Linien

4. Qt::VerPattern – vertikale Linien

5. Qt::CrossPattern – Kreuzlinien

6. Qt::DiagCrossPattern – diagonale Kreuzlinien

Mit myBrush.setColor(Qt::red);.

Nach jeder Änderung, sonst werden die neuen Einstellungen nicht wirksam.

1. QImage myImage("pfad/zur/grafik.bmp");

2. myBrush.setTextureImage(myImage);

3. Mit fillRect() zeichnen.

<random>.

1. std::random_device – Initialisierung

2. std::mt19937 – Zufallsgenerator

3. std::uniform_int_distribution<int> – Verteilung

Er liefert eine gleichmäßig verteilte Zufallszahl im Bereich 0–50.

Mit QLinearGradient.

Mit setColorAt(Position, Farbe), z. B.

myGradient.setColorAt(0, Qt::red);

myGradient.setColorAt(1, Qt::blue);

QBrush myBrush(myGradient);

Ja, indem der Verlaufspinsel mit myPen.setBrush(myBrush); gesetzt wird.

drawText() der Klasse QPainter.

Mit

myPainter.setFont(QFont("Arial", 20));

QRect bereich(100, 100, 200, 100);

myPainter.drawText(bereich, "Text");

Unten links in der Zeichenfläche.

Sie werden nicht automatisch zurückgesetzt – man muss sie selbst ändern.

Den Stift bzw. Pinsel neu zuweisen an den QPainter mit setPen() oder setBrush().

1. Ein Array von QPoint-Koordinaten

2. Die Anzahl der Punkte

Ja, zwischen letztem und erstem Punkt wird automatisch eine Linie gezogen.

drawPolyline().