← C++

C++ · 06 / 24

Deine erste Qt-Oberfläche mit Signals und Slots

Du baust ein Fenster, reagierst auf einen Button und zeichnest ein Wegelement.

  • Mittel
  • Fortgeschritten
  • 75 min

Voraussetzungen: Klassen, Referenzen, const und RAII, Header, CMake und erste Unit-Tests

In diesem Tutorial
  1. Qt und CMake vorbereiten
  2. Fenster und Zeichenfläche lesen
  3. Ein Ereignis verbinden
  4. Die Prüfung nachvollziehen
  5. Bauen und ausprobieren
  6. Übung und Lösung
  7. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

GCC mit C++20 und CMake ab 3.25, Qt ab 6.4. Zusätzlich Python 3 für den gemeinsamen Prüfstart. Entpacke das Lernpaket in einen neuen Ordner und führe dort python3 run_checks.py aus. Das Skript kopiert die enthaltenen Dateien in einen temporären Lernordner. Dort prüft es zuerst das Beispiel und danach die mitgelieferte Lösung. Die Ausgangsdateien bleiben erhalten. Benötigte Pakete werden beim ersten Lauf aus dem Netz geladen.

Setze CMAKE_PREFIX_PATH auf deine Qt-Installation, falls CMake Qt nicht findet. Für eine Prüfung ohne Display kann QT_QPA_PLATFORM=offscreen gesetzt werden.

Geprüft am 21.10.2026 unter Linux x86_64. Der Qt-Selbsttest klickt den Button ohne Display. Die Lösung prüft auch die aktualisierte Beschriftung.

Eine grafische App wartet auf Ereignisse. Sie läuft nicht einfach wie eine Konsolenliste von oben nach unten bis zur letzten Ausgabe. QApplication verwaltet die Ereignisschleife. Widgets bilden die Oberfläche. Ein Layout ordnet die Widgets an, damit nicht jede Bildschirmposition von Hand festgelegt werden muss.

Qt verbindet Ereignisse und Reaktionen über Signals und Slots. Ein Button sendet clicked. Eine verbundene Funktion führt anschließend die gewünschte Arbeit aus. Unser Lernfenster setzt Wegelemente mit einem Button. Der vollständige FactoryForge-Editor ergänzt später Mauskoordinaten, Werkzeuge und ein getrenntes Projektmodell.

Paketinhalt und einzelne Dateien

01Qt und CMake vorbereiten

Du benötigst Qt 6.4 oder neuer mit dem Widgets-Modul. Die überprüfte Projektumgebung nutzt Qt 6.8.3. Auf dem vorhandenen Linux-Rechner richtet scripts/setup.sh die Werkzeuge im Benutzerverzeichnis ein. In einer eigenen Installation setzt du CMAKE_PREFIX_PATH auf deinen Qt-Ordner. Verwende auf Windows dieselbe Compilerfamilie für Qt und dein Programm.

02Fenster und Zeichenfläche lesen

QWidget ist das Fenster. QVBoxLayout ordnet Zeichenfläche und Button untereinander an. QGraphicsScene hält die grafischen Objekte und QGraphicsView zeigt sie an. Die Reihenfolge der lokalen Variablen bewahrt ihre Lebensdauer während der Ereignisschleife. Diese kleine Oberfläche speichert noch keine Projekte.

main.cpp · cppDatei öffnen
#include <QApplication>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QPushButton>
#include <QTimer>
#include <QVBoxLayout>
#include <QWidget>
#include <iostream>
int main(int argc, char **argv) {
  QApplication app(argc, argv);
  QWidget window;
  window.setWindowTitle("First warehouse grid");
  QVBoxLayout layout(&window);
  QGraphicsScene scene;
  QGraphicsView view(&scene);
  QPushButton add("Place a road");
  layout.addWidget(&view);
  layout.addWidget(&add);
  int placed = 0;
  QObject::connect(&add, &QPushButton::clicked, &window, [&] {
    scene.addRect(placed * 36, 0, 34, 34, QPen(Qt::NoPen),
                  QBrush(QColor("#23856d")));
    ++placed;
  });
  window.resize(500, 250);
  window.show();
  if (app.arguments().contains("--self-test"))
    QTimer::singleShot(0, &window, [&] {
      add.click();
      std::cout << "tiles=" << placed << '\n';
      app.exit(placed == 1 ? 0 : 1);
    });
  return app.exec();
}

Starten / prüfen

cmake -S . -B build -G Ninja
cmake --build build
./build/lesson

03Ein Ereignis verbinden

QObject::connect verbindet clicked mit einer Lambda-Funktion. Eine Lambda ist eine kleine Funktion direkt an der benötigten Stelle. Der Ausdruck [&] benutzt vorhandene lokale Variablen über Referenzen. Das ist hier sicher, weil diese Variablen bis zum Ende von app.exec leben. Der Handler fügt ein grünes Rechteck hinzu und erhöht placed.

04Die Prüfung nachvollziehen

Der Qt-Selbsttest klickt den Button ohne Display. Die Lösung prüft auch die aktualisierte Beschriftung. Starte python3 run_checks.py aus dem entpackten Paket. Vergleiche die Test-Erwartungen mit der Übung, bevor du die Lösung öffnest.

Erwartetes Ergebnis

Beispiel und automatisierte Lösung bestehen. Die genannten manuellen Prüfungen bleiben getrennt.

05Bauen und ausprobieren

Konfiguriere mit cmake -S . -B build -G Ninja und baue mit cmake --build build. Starte ./build/lesson beziehungsweise build\lesson.exe. Jeder Klick auf Place a road ergänzt ein Rechteck. Mit --self-test löst das Programm einen echten Button-Klick aus, prüft das Ergebnis und beendet sich automatisch.

CMakeLists.txt · cmakeDatei öffnen
cmake_minimum_required(VERSION 3.25)
project(QtGridLesson LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
find_package(Qt6 6.4 REQUIRED COMPONENTS Widgets)
add_executable(lesson main.cpp)
target_link_libraries(lesson PRIVATE Qt6::Widgets)
Erwartetes Ergebnis

Mit --self-test erscheint tiles=1. Im normalen Fenster ergänzt jeder Klick ein Rechteck.

Deine Übung

Ändere die Farbe und den Abstand der Rechtecke. Ergänze dann eine Beschriftung, die die Anzahl der platzierten Wege zeigt.

Lösung mit Erklärung anzeigen

Die Farbe steht im QColor-Wert. Der Abstand entsteht durch placed * 36. Für eine Anzahlbeschriftung ergänzt du ein QLabel im Layout und setzt dessen Text im Handler nach dem Erhöhen von placed. Die Anzeige muss aus dem aktuellen Zustand entstehen. Der Selbsttest prüft weiterhin, dass ein Ereignis genau ein Wegelement erzeugt.

solution/main.cpp · cppDatei öffnen
#include <QApplication>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QLabel>
#include <QPushButton>
#include <QTimer>
#include <QVBoxLayout>
#include <QWidget>
#include <iostream>
int main(int argc, char **argv) {
  QApplication app(argc, argv);
  QWidget window;
  window.setWindowTitle("First warehouse grid");
  QVBoxLayout layout(&window);
  QGraphicsScene scene;
  QGraphicsView view(&scene);
  QPushButton add("Place a road");
  layout.addWidget(&view);
  layout.addWidget(&add);
  QLabel count("0 roads");
  layout.addWidget(&count);
  int placed = 0;
  QObject::connect(&add, &QPushButton::clicked, &window, [&] {
    scene.addRect(placed * 44, 0, 38, 38, QPen(Qt::NoPen),
                  QBrush(QColor("#2954b8")));
    ++placed;
    count.setText(QString::number(placed) + " roads");
  });
  window.resize(500, 250);
  window.show();
  if (app.arguments().contains("--self-test"))
    QTimer::singleShot(0, &window, [&] {
      add.click();
      std::cout << "tiles=" << placed << '\n';
      app.exit(placed == 1 && count.text() == "1 roads" ? 0 : 1);
    });
  return app.exec();
}

Projektbezug und Quellen

Die ersten sechs Beispiele sind eigenständige Lernprogramme. Lektionen 7 bis 9 nutzen den vollständigen FactoryForge-Quellstand. Quellcode, Übungen und überprüfte Vereinfachungen sind getrennt beschrieben. Die Projektseite bietet ein Quellcode-ZIP, solange das GitHub-Repository noch nicht veröffentlicht ist.