← C++

C++ · 19 / 24

Qt Model/View mit Sortierung, Filtern und Bearbeitung

Du trennst Auftragsdaten von ihrer Darstellung und erhältst beim Sortieren und Bearbeiten die richtige Datensatzidentität.

  • Groß
  • Anspruchsvoll
  • 90 min

Voraussetzungen: Deine erste Qt-Oberfläche mit Signals und Slots, Austauschbare Repositories und gezielte Test-Doubles

In diesem Tutorial
  1. Qt Widgets und Qt Test einrichten
  2. Daten und Modellrollen abbilden
  3. Proxy-Indizes richtig zuordnen
  4. Eine bewusst flüchtige Demo starten
  5. Modellvertrag und Signale prüfen
  6. Einen Prioritätsfilter ergänzen
  7. Übung und Lösung
  8. Projektbezug und Quellen

Lernpaket herunterladen

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.

CMakeLists.txt · cmakeDatei öffnen
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)
Erwartetes Ergebnis

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.

order_model.hpp · cppDatei öffnen
#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
Erwartetes Ergebnis

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.

order_editor.hpp · cppDatei öffnen
#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 &current) {
              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
Erwartetes Ergebnis

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.

main.cpp · cppDatei öffnen
#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();
}
Erwartetes Ergebnis

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.

tests.cpp · cppDatei öffnen
#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"
Erwartetes Ergebnis

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.

solution.cpp · cppDatei öffnen
#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");
}
Erwartetes Ergebnis

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.

solution.cpp · cppDatei öffnen
#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.