Einrichtung und Prüfstand
GCC mit C++20, CMake ab 3.25, CTest und Python 3. Qt 6.8 mit Core, Widgets und Test. Setze CMAKE_PREFIX_PATH auf deinen Qt-Installationsordner, falls Qt nicht automatisch gefunden wird. Lokal geprüft mit Qt 6.8.3. Entpacke das ZIP in einen neuen Ordner. python3 run_checks.py prüft Beispiel und Lösung in einer temporären Kopie und erhält deine Dateien. Für einen eigenen Build führe python3 verify.py aus. Danach liegt das Demo unter build/order_lab. Die Qt-Demos verwenden englische Beschriftungen. Automatische Widgettests nutzen standardmäßig offscreen. Starte die sichtbare Demo in einer Desktop-Sitzung ohne QT_QPA_PLATFORM=offscreen. Native Windows-Ausführung ist nicht verifiziert.
Geprüft am 21.10.2026 unter Linux x86_64. Qt-Modellvertrag, Bearbeitungsvalidierung, gespeicherte Änderung, Signalanzahl, Sortierung, Filter und Modellreset. Linux-Widgettests laufen ohne sichtbaren Desktop. Native Windows-Bedienung ist nicht geprüft.
Eine Tabellenzeile ist keine dauerhafte Auftrags-ID. Sobald die Oberfläche sortiert oder filtert, unterscheiden sich sichtbare und ursprüngliche Zeilennummern. Wir bauen ein QAbstractTableModel, schalten ein Proxy-Modell davor und speichern Änderungen über den Anwendungsdienst. Ein Modellprüfer kontrolliert zusätzlich die Regeln, die Qt von eigenen Modellen erwartet.
Paketinhalt und einzelne Dateien
01Qt Widgets und Qt Test einrichten
Installiere Qt 6.8 mit Widgets und Test. Falls CMake Qt nicht findet, setze CMAKE_PREFIX_PATH auf dein Qt-Installationsverzeichnis. python3 verify.py baut die Oberfläche und ihre Tests. AUTOMOC verarbeitet die Metaobjekte der Prüfklassen. Für eine sichtbare Demo starte ./build/order_lab in deiner Desktop-Sitzung.
cmake_minimum_required(VERSION 3.25)
project(cpp_19 LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
enable_testing()
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
add_compile_options(-Wall -Wextra -Wpedantic -Werror)
endif()
find_package(Qt6 6.8 REQUIRED COMPONENTS Core Test Widgets)
set(CMAKE_AUTOMOC ON)
add_executable(order_lab main.cpp)
target_link_libraries(order_lab PRIVATE Qt6::Core Qt6::Test Qt6::Widgets)
add_executable(lesson_tests tests.cpp)
target_link_libraries(lesson_tests PRIVATE Qt6::Core Qt6::Test Qt6::Widgets)
add_test(NAME lesson_tests COMMAND lesson_tests)
set_tests_properties(lesson_tests PROPERTIES TIMEOUT 30)
add_executable(exercise_solution solution.cpp)
target_link_libraries(exercise_solution PRIVATE Qt6::Core Qt6::Test Qt6::Widgets)
add_test(NAME exercise_solution COMMAND exercise_solution)
set_tests_properties(exercise_solution PROPERTIES TIMEOUT 30)
Eine Tabelle zeigt drei künstliche Aufträge.
02Daten und Modellrollen abbilden
rowCount und columnCount liefern bei gültigem Elternindex 0, weil die Tabelle keine Kinder hat. DisplayRole enthält sichtbare Werte. Eigene Rollen transportieren ID, Priorität und Offen-Status unabhängig von der angeklickten Spalte. setData prüft die Änderung über den Dienst und meldet erst danach dataChanged.
#pragma once
#include "repository.hpp"
#include <QAbstractTableModel>
#include <QSortFilterProxyModel>
namespace orders {
class OrderModel final : public QAbstractTableModel {
OrderService &service_;
std::vector<Order> values_;
QString lastError_;
public:
enum Role { Id = Qt::UserRole + 1, Priority, Open };
explicit OrderModel(OrderService &service, QObject *parent = nullptr)
: QAbstractTableModel(parent), service_(service) {}
int rowCount(const QModelIndex &parent = {}) const override {
return parent.isValid() ? 0 : int(values_.size());
}
int columnCount(const QModelIndex &parent = {}) const override {
return parent.isValid() ? 0 : 4;
}
QVariant data(const QModelIndex &index,
int role = Qt::DisplayRole) const override {
if (!index.isValid() || index.row() < 0 || index.row() >= rowCount() ||
index.column() < 0 || index.column() >= 4)
return {};
const auto &order = values_[std::size_t(index.row())];
if (role == Id)
return order.id;
if (role == Priority)
return order.priority;
if (role == Open)
return order.status == Status::open;
if (role != Qt::DisplayRole && role != Qt::EditRole)
return {};
switch (index.column()) {
case 0:
return order.id;
case 1:
return QString::fromStdString(order.title);
case 2:
return order.priority;
case 3:
return order.status == Status::open ? "open" : "done";
}
return {};
}
QVariant headerData(int section, Qt::Orientation orientation,
int role) const override {
if (orientation == Qt::Horizontal && role == Qt::DisplayRole &&
section >= 0 && section < 4)
return QStringList{"ID", "Title", "Priority", "Status"}.at(section);
return QAbstractTableModel::headerData(section, orientation, role);
}
Qt::ItemFlags flags(const QModelIndex &index) const override {
if (!index.isValid())
return Qt::NoItemFlags;
auto result = QAbstractTableModel::flags(index);
if (index.column() == 1)
result |= Qt::ItemIsEditable;
return result;
}
bool setData(const QModelIndex &index, const QVariant &value,
int role) override {
if (role != Qt::EditRole || !index.isValid() || index.column() != 1 ||
index.row() < 0 || index.row() >= rowCount())
return false;
auto candidate = values_[std::size_t(index.row())];
candidate.title = value.toString().toStdString();
auto saved = service_.save(candidate);
if (!succeeded(saved)) {
lastError_ = QString::fromStdString(std::get<Error>(saved).message);
return false;
}
values_[std::size_t(index.row())] = std::move(candidate);
lastError_.clear();
emit dataChanged(index, index, {Qt::DisplayRole, Qt::EditRole});
return true;
}
Result<Done> refresh() {
auto loaded = service_.list();
if (!succeeded(loaded))
return std::get<Error>(loaded);
auto batch = std::get<std::vector<Order>>(std::move(loaded));
beginResetModel();
values_.swap(batch);
endResetModel();
return Done{};
}
QString lastError() const { return lastError_; }
};
class OpenFilter : public QSortFilterProxyModel {
bool onlyOpen_{false};
protected:
bool filterAcceptsRow(int row, const QModelIndex &parent) const override {
return QSortFilterProxyModel::filterAcceptsRow(row, parent) &&
(!onlyOpen_ || sourceModel()
->index(row, 0, parent)
.data(OrderModel::Open)
.toBool());
}
public:
explicit OpenFilter(QObject *parent = nullptr)
: QSortFilterProxyModel(parent) {
setFilterKeyColumn(1);
setFilterCaseSensitivity(Qt::CaseInsensitive);
}
void setOnlyOpen(bool value) {
onlyOpen_ = value;
invalidateFilter();
}
};
} // namespace orders
Ein ungültiger Titel wird abgelehnt und erzeugt kein Änderungssignal.
03Proxy-Indizes richtig zuordnen
OpenFilter verbindet Textsuche und Offen-Filter. Die Tabelle sortiert über diesen Proxy. Vor Auswahl und Löschen wird der sichtbare Index mit mapToSource zurückgeführt und daraus die ID gelesen. Die Demo bearbeitet über ein Formular. Direkte Modellbearbeitung wird zusätzlich in den Tests geprüft.
#pragma once
#include "order_model.hpp"
#include <QCheckBox>
#include <QFormLayout>
#include <QHeaderView>
#include <QLabel>
#include <QLineEdit>
#include <QPushButton>
#include <QSpinBox>
#include <QTableView>
#include <QVBoxLayout>
namespace orders {
class OrderEditor : public QWidget {
OrderService &service_;
OrderModel model_;
OpenFilter proxy_;
QSpinBox *id_;
QLineEdit *title_;
QSpinBox *priority_;
QCheckBox *done_;
QTableView *table_;
QLabel *message_;
public:
explicit OrderEditor(OrderService &service, QWidget *parent = nullptr)
: QWidget(parent), service_(service), model_(service, this),
proxy_(this) {
auto *layout = new QVBoxLayout(this);
auto *search = new QLineEdit(this);
search->setObjectName("search");
search->setPlaceholderText("Filter titles");
search->setAccessibleName("Filter titles");
auto *onlyOpen = new QCheckBox("Open orders only", this);
onlyOpen->setObjectName("onlyOpen");
layout->addWidget(search);
layout->addWidget(onlyOpen);
proxy_.setSourceModel(&model_);
table_ = new QTableView(this);
table_->setObjectName("orders");
table_->setModel(&proxy_);
table_->setSortingEnabled(true);
table_->sortByColumn(0, Qt::AscendingOrder);
table_->setSelectionBehavior(QAbstractItemView::SelectRows);
table_->setSelectionMode(QAbstractItemView::SingleSelection);
table_->setEditTriggers(QAbstractItemView::NoEditTriggers);
table_->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch);
layout->addWidget(table_);
auto *form = new QFormLayout;
id_ = new QSpinBox(this);
id_->setObjectName("id");
id_->setRange(1, 1000000);
title_ = new QLineEdit(this);
title_->setObjectName("title");
priority_ = new QSpinBox(this);
priority_->setObjectName("priority");
priority_->setRange(0, 2);
done_ = new QCheckBox("Done", this);
done_->setObjectName("done");
form->addRow("ID", id_);
form->addRow("Title", title_);
form->addRow("Priority", priority_);
form->addRow("Status", done_);
layout->addLayout(form);
auto *buttons = new QHBoxLayout;
auto *save = new QPushButton("Save order", this);
save->setObjectName("save");
auto *remove = new QPushButton("Delete selected", this);
remove->setObjectName("remove");
buttons->addWidget(save);
buttons->addWidget(remove);
layout->addLayout(buttons);
message_ = new QLabel(this);
message_->setObjectName("message");
message_->setWordWrap(true);
layout->addWidget(message_);
connect(search, &QLineEdit::textChanged, &proxy_,
&QSortFilterProxyModel::setFilterFixedString);
connect(onlyOpen, &QCheckBox::toggled, this,
[this](bool value) { proxy_.setOnlyOpen(value); });
connect(table_->selectionModel(), &QItemSelectionModel::currentRowChanged,
this, [this](const QModelIndex ¤t) {
if (!current.isValid())
return;
auto source = proxy_.mapToSource(current);
id_->setValue(source.data(OrderModel::Id).toInt());
title_->setText(model_.index(source.row(), 1).data().toString());
priority_->setValue(source.data(OrderModel::Priority).toInt());
done_->setChecked(!source.data(OrderModel::Open).toBool());
});
connect(save, &QPushButton::clicked, this, [this] {
auto result = service_.save(
{id_->value(), title_->text().toStdString(), priority_->value(),
done_->isChecked() ? Status::done : Status::open});
if (report(result, "Saved"))
refresh();
});
connect(remove, &QPushButton::clicked, this, [this] {
const auto current = table_->currentIndex();
if (!current.isValid()) {
message_->setText("Select an order first");
return;
}
const auto source = proxy_.mapToSource(current);
auto result = service_.remove(source.data(OrderModel::Id).toInt());
if (report(result, "Deleted"))
refresh();
});
refresh();
}
bool report(const Result<Done> &result, const QString &success) {
if (!succeeded(result)) {
message_->setText(
QString::fromStdString(std::get<Error>(result).message));
return false;
}
message_->setText(success);
return true;
}
void refresh() {
auto loaded = model_.refresh();
if (!succeeded(loaded))
report(loaded, {});
}
};
} // namespace orders
Auch nach absteigender Sortierung bezeichnet die erste sichtbare Zeile den richtigen Auftrag.
04Eine bewusst flüchtige Demo starten
Die Demo verbindet MemoryRepository, OrderService und OrderEditor in dieser Lebensdauerreihenfolge. Suche nach motors, schalte den Offen-Filter um und ändere einen Titel über das Formular. Die Daten liegen nur im Arbeitsspeicher. Dauerhafte Speicherung folgt in Tutorial 21 und im Abschlussprojekt.
#include "order_editor.hpp"
#include "test_support.hpp"
#include <QApplication>
int main(int argc, char **argv) {
QApplication app(argc, argv);
orders::MemoryRepository repository;
orders::OrderService service(repository);
service.replace(samples());
orders::OrderEditor editor(service);
editor.setWindowTitle("Order model · memory example");
editor.resize(720, 520);
editor.show();
return app.exec();
}
Die Suche motors zeigt genau einen Auftrag.
05Modellvertrag und Signale prüfen
QAbstractItemModelTester überwacht Quell- und Proxy-Modell. QSignalSpy zählt dataChanged. Die Tests kontrollieren ungültige Eingaben, erfolgreiches Speichern, Sortierung, Filter und das Leeren des Bestands. Ein Modellprüfer ergänzt fachliche Tests, er ersetzt sie nicht.
#include "order_model.hpp"
#include "test_support.hpp"
#include <QAbstractItemModelTester>
#include <QSignalSpy>
#include <QtTest>
using namespace orders;
class ModelTests : public QObject {
Q_OBJECT
private slots:
void editingAndSorting() {
MemoryRepository repository;
OrderService service(repository);
QVERIFY(succeeded(service.replace(samples())));
OrderModel model(service);
QAbstractItemModelTester tester(
&model, QAbstractItemModelTester::FailureReportingMode::QtTest);
QVERIFY(succeeded(model.refresh()));
QCOMPARE(model.rowCount(), 3);
QCOMPARE(model.rowCount(model.index(0, 0)), 0);
QVERIFY(!model.data(model.index(90, 0)).isValid());
QSignalSpy changed(&model, &QAbstractItemModel::dataChanged);
QVERIFY(!model.setData(model.index(0, 1), " ", Qt::EditRole));
QCOMPARE(changed.count(), 0);
QVERIFY(model.setData(model.index(0, 1), "New title", Qt::EditRole));
QCOMPARE(changed.count(), 1);
QVERIFY(std::get<std::vector<Order>>(service.list())[0].title ==
"New title");
OpenFilter proxy;
proxy.setSourceModel(&model);
QAbstractItemModelTester proxyTester(
&proxy, QAbstractItemModelTester::FailureReportingMode::QtTest);
proxy.sort(0, Qt::DescendingOrder);
QCOMPARE(proxy.index(0, 0).data(OrderModel::Id).toInt(), 3);
proxy.setOnlyOpen(true);
QCOMPARE(proxy.rowCount(), 2);
QCOMPARE(proxy.mapToSource(proxy.index(0, 0)).data(OrderModel::Id).toInt(),
2);
proxy.setFilterFixedString("new");
QCOMPARE(proxy.rowCount(), 1);
QVERIFY(succeeded(service.replace({})));
QVERIFY(succeeded(model.refresh()));
QCOMPARE(proxy.rowCount(), 0);
}
};
QTEST_MAIN(ModelTests)
#include "tests.moc"
Alle Modellprüfungen bestehen. Ein gültiger Edit erzeugt genau ein Änderungssignal.
06Einen Prioritätsfilter ergänzen
Erweitere den vorhandenen Filter um Priorität 2. Rufe die bisherige Filterbedingung weiterhin auf, damit Textsuche und Offen-Filter erhalten bleiben. Die Lösung prüft Ergebniszahl und konkrete ID sowie den später geleerten Datenbestand.
#include "order_model.hpp"
#include "test_support.hpp"
#include <QCoreApplication>
class PriorityFilter final : public orders::OpenFilter {
protected:
bool filterAcceptsRow(int row, const QModelIndex &parent) const override {
return orders::OpenFilter::filterAcceptsRow(row, parent) &&
sourceModel()
->index(row, 0, parent)
.data(orders::OrderModel::Priority)
.toInt() == 2;
}
};
int main(int argc, char **argv) {
QCoreApplication application(argc, argv);
orders::MemoryRepository repository;
orders::OrderService service(repository);
service.replace(samples());
orders::OrderModel model(service);
model.refresh();
PriorityFilter filter;
filter.setSourceModel(&model);
filter.setOnlyOpen(true);
require(filter.rowCount() == 1, "urgent open order");
require(filter.index(0, 0).data(orders::OrderModel::Id).toInt() == 1,
"correct identity");
service.replace({});
model.refresh();
require(filter.rowCount() == 0, "empty model");
}
Im Beispieldatensatz bleibt Auftrag 1 sichtbar.
Deine Übung
Ergänze PriorityFilter als Erweiterung von OpenFilter. Zeige ausschließlich dringende Aufträge mit Priorität 2, unter Beibehaltung der vorhandenen Filter. Prüfe die ID des Ergebnisses und eine leere Datenmenge.
Lösung mit Erklärung anzeigen
Die Lösung kombiniert OpenFilter::filterAcceptsRow mit der Priority-Rolle des Quellmodells. Sie hängt nicht von der aktuell sichtbaren Spalte ab. Nach einem Modellreset muss die Ergebnisliste ebenfalls leer sein.
#include "order_model.hpp"
#include "test_support.hpp"
#include <QCoreApplication>
class PriorityFilter final : public orders::OpenFilter {
protected:
bool filterAcceptsRow(int row, const QModelIndex &parent) const override {
return orders::OpenFilter::filterAcceptsRow(row, parent) &&
sourceModel()
->index(row, 0, parent)
.data(orders::OrderModel::Priority)
.toInt() == 2;
}
};
int main(int argc, char **argv) {
QCoreApplication application(argc, argv);
orders::MemoryRepository repository;
orders::OrderService service(repository);
service.replace(samples());
orders::OrderModel model(service);
model.refresh();
PriorityFilter filter;
filter.setSourceModel(&model);
filter.setOnlyOpen(true);
require(filter.rowCount() == 1, "urgent open order");
require(filter.index(0, 0).data(orders::OrderModel::Id).toInt() == 1,
"correct identity");
service.replace({});
model.refresh();
require(filter.rowCount() == 0, "empty model");
}
Projektbezug und Quellen
Eigenständiges Lernprojekt im Logistikthema von FactoryForge. Der bestehende FactoryForge-Quellstand dient als Architekturkontext. Die hier eingeführten SQLite-, Netzwerk- und Importfunktionen sind Funktionen des Lernprojekts. Das Order-Lab-JSON ist ein eigenes Format.