Einrichtung und Prüfstand
GCC mit C++20, CMake ab 3.25, CTest und Python 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. Es werden keine zusätzlichen Bibliotheken benötigt. Die dokumentierten Befehle wurden unter Linux geprüft.
Geprüft am 21.10.2026 unter Linux x86_64. Speicherimplementierung, Aktualisieren und Löschen, Fehlerweitergabe beim Lesen ohne anschließenden Schreibaufruf und getrennte Schreibausfälle. Mehrprozess-Konflikte sind außerhalb dieses Beispiels.
Eine Oberfläche soll Aufträge speichern können, ohne SQL-Befehle zu kennen. OrderService beschreibt diesen Ablauf. OrderRepository legt fest, was die Speicherung leisten muss. Eine Speicherimplementierung ermöglicht schnelle Tests. Fehlerimplementierungen beweisen, dass der Dienst Fehlschläge weitergibt und nach einem gescheiterten Lesevorgang nicht trotzdem schreibt.
Paketinhalt und einzelne Dateien
01Einen kleinen Vertrag formulieren
Das Repository stellt list und replaceAll bereit. replaceAll ist atomar aus Sicht des Aufrufers: Bei einem Fehler bleibt der zuletzt übernommene Bestand erhalten. Der virtuelle Destruktor erlaubt korrekte polymorphe Zerstörung. OrderService leiht eine Referenz. Das Repository muss deshalb länger leben als der Dienst.
#pragma once
#include "order.hpp"
namespace orders {
class OrderRepository {
public:
virtual ~OrderRepository() = default;
virtual Result<std::vector<Order>> list() const = 0;
// Contract: failure leaves the previously committed batch intact.
virtual Result<Done> replaceAll(std::span<const Order> batch) = 0;
};
class MemoryRepository final : public OrderRepository {
std::vector<Order> data_;
public:
Result<std::vector<Order>> list() const override { return data_; }
Result<Done> replaceAll(std::span<const Order> batch) override {
return replaceValidated(data_, batch);
}
};
class OrderService {
OrderRepository &repository_;
public:
explicit OrderService(OrderRepository &repository)
: repository_(repository) {}
Result<std::vector<Order>> list() const { return repository_.list(); }
Result<Done> replace(std::span<const Order> batch) {
auto result = validateBatch(batch);
if (!succeeded(result))
return std::get<Error>(result);
return repository_.replaceAll(batch);
}
Result<Done> save(const Order &order) {
auto result = repository_.list();
if (!succeeded(result))
return std::get<Error>(result);
auto batch = std::get<std::vector<Order>>(std::move(result));
auto found = std::ranges::find(batch, order.id, &Order::id);
if (found == batch.end())
batch.push_back(order);
else
*found = order;
return replace(batch);
}
Result<Done> remove(int id) {
auto result = repository_.list();
if (!succeeded(result))
return std::get<Error>(result);
auto batch = std::get<std::vector<Order>>(std::move(result));
std::erase_if(batch, [id](const Order &order) { return order.id == id; });
return replace(batch);
}
};
} // namespace orders
Der Dienst kennt weder Dateinamen noch SQL-Verbindungen.
02Regeln im Anwendungskern halten
Die Validierung bleibt unabhängig von Qt und Datenbanktreibern. Der Dienst prüft einen Stapel vor der Übergabe. Konkrete Repositories prüfen ihren Vertrag ebenfalls, damit ein direkter Aufruf keine ungültigen Daten einschleust. Das ist eine Grenze zwischen Komponenten, kein Ersatz für Datenbank-Constraints.
#pragma once
#include "result.hpp"
#include <algorithm>
#include <ranges>
#include <set>
#include <span>
#include <string_view>
#include <vector>
namespace orders {
enum class Status { open, done };
struct Order {
int id;
std::string title;
int priority{0};
Status status{Status::open};
bool operator==(const Order &) const = default;
};
inline Result<Done> validate(const Order &order) {
const bool blank = std::ranges::all_of(order.title, [](char c) {
return c == ' ' || c == '\t' || c == '\n' || c == '\r';
});
if (order.id < 1 || order.id > 1000000 || order.title.empty() ||
order.title.size() > 80 || blank || order.priority < 0 ||
order.priority > 2 ||
(order.status != Status::open && order.status != Status::done))
return Error{ErrorCode::invalid, "ID 1..1000000, title 1..80 UTF-8 bytes, "
"priority 0..2 and valid status required"};
return Done{};
}
inline Result<Done> validateBatch(std::span<const Order> batch) {
if (batch.size() > 1000)
return Error{ErrorCode::invalid, "At most 1000 orders are allowed"};
std::set<int> ids;
for (const auto &order : batch) {
auto result = validate(order);
if (!succeeded(result))
return std::get<Error>(result);
if (!ids.insert(order.id).second)
return Error{ErrorCode::duplicate, "Duplicate order ID"};
}
return Done{};
}
inline std::vector<int> matchingIds(std::span<const Order> values,
std::string_view needle) {
// Both views borrow their input. Consume them before the owner changes.
auto matching =
values | std::views::filter([needle](const Order &order) {
return order.status == Status::open &&
order.title.find(needle) != std::string::npos;
}) |
std::views::transform([](const Order &order) { return order.id; });
return {matching.begin(), matching.end()};
}
inline Result<Done> replaceValidated(std::vector<Order> ¤t,
std::span<const Order> incoming) {
auto result = validateBatch(incoming);
if (!succeeded(result))
return std::get<Error>(result);
std::vector<Order> candidate(incoming.begin(), incoming.end());
// Validation and allocations precede this non-throwing commit point.
current.swap(candidate);
return Done{};
}
} // namespace orders
Leere Titel und doppelte IDs erreichen keine erfolgreiche Speicherung.
03Abhängigkeiten am Start verbinden
main erzeugt zuerst das Repository und danach den Dienst. save ergänzt eine neue ID oder aktualisiert einen vorhandenen Auftrag. Das Beispiel verwendet bewusst genau einen schreibenden Anwendungsablauf. Ein gleichzeitiges Read-modify-write aus mehreren Prozessen benötigt einen weitergehenden Konfliktvertrag.
#include "repository.hpp"
#include "test_support.hpp"
int main() {
orders::MemoryRepository repository;
orders::OrderService service(repository);
service.save({1, "Deliver motors", 2});
std::cout << "Saved orders: "
<< std::get<std::vector<orders::Order>>(service.list()).size()
<< '\n';
}
Saved orders: 1
04Leseausfälle gezielt nachstellen
Unavailable liefert beim Lesen einen Speicherfehler. Sein Schreibaufruf wirft absichtlich einen Logikfehler. Der Test ruft save auf und erwartet den Lesefehler. Würde der Dienst trotzdem schreiben, bräche das Prüfprogramm ab. Zusätzlich prüft die echte Speicherimplementierung Aktualisieren und Löschen.
#include "repository.hpp"
#include "test_support.hpp"
class Unavailable final : public orders::OrderRepository {
public:
orders::Result<std::vector<orders::Order>> list() const override {
return orders::Error{orders::ErrorCode::storage, "Disk unavailable"};
}
orders::Result<orders::Done>
replaceAll(std::span<const orders::Order>) override {
throw std::logic_error("save must not write after failed read");
}
};
int main() {
orders::MemoryRepository memory;
orders::OrderService service(memory);
require(orders::succeeded(service.replace(samples())), "seed");
require(orders::succeeded(service.save({2, "Updated", 1})), "update");
require(std::get<std::vector<orders::Order>>(service.list())[1].title ==
"Updated",
"persisted update");
require(orders::succeeded(service.remove(1)), "remove");
require(std::get<std::vector<orders::Order>>(service.list()).size() == 2,
"removed one");
Unavailable unavailable;
orders::OrderService offline(unavailable);
auto failed = offline.save({9, "Order", 0});
require(!orders::succeeded(failed), "read failure propagated without write");
std::cout << "repository contract checks passed\n";
}
Ein fehlgeschlagener Lesevorgang führt zu keinem Schreibversuch.
05Schreibausfälle unabhängig testen
Das zweite Test-Double lässt Lesen zu und lehnt Schreiben ab. Dadurch erreicht der Dienst tatsächlich seine Speichergrenze. Prüfe sowohl save als auch remove und vergleiche danach den kompletten Bestand. Eine nur beim Lesen fehlschlagende Attrappe könnte diese Fehlerbehandlung nicht abdecken.
#include "repository.hpp"
#include "test_support.hpp"
class WriteFailure final : public orders::OrderRepository {
orders::MemoryRepository data_;
public:
WriteFailure() { data_.replaceAll(samples()); }
orders::Result<std::vector<orders::Order>> list() const override {
return data_.list();
}
orders::Result<orders::Done>
replaceAll(std::span<const orders::Order>) override {
return orders::Error{orders::ErrorCode::storage, "Simulated write failure"};
}
};
int main() {
WriteFailure repository;
orders::OrderService service(repository);
require(!orders::succeeded(service.save({9, "Cannot save"})),
"write error returned");
require(!orders::succeeded(service.remove(1)), "delete error returned");
require(std::get<std::vector<orders::Order>>(service.list()) == samples(),
"data unchanged");
}
Beide Operationen melden einen Fehler und erhalten die Ausgangsdaten.
06Die Architektur begründen
Führe python3 verify.py aus. Alle Tests laufen ohne Qt, Netzwerk oder Datenbank. Das zeigt die Abhängigkeitsrichtung des Kerns. In Tutorial 21 wird dieselbe Schnittstelle mit SQLite umgesetzt. Ein Test-Double allein beweist jedoch noch nicht, dass diese spätere Implementierung Transaktionen korrekt verwendet.
cmake_minimum_required(VERSION 3.25)
project(cpp_18 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()
add_executable(order_lab main.cpp)
add_executable(lesson_tests tests.cpp)
add_test(NAME lesson_tests COMMAND lesson_tests)
set_tests_properties(lesson_tests PROPERTIES TIMEOUT 30)
add_executable(exercise_solution solution.cpp)
add_test(NAME exercise_solution COMMAND exercise_solution)
set_tests_properties(exercise_solution PROPERTIES TIMEOUT 30)
Zwei Prüfprogramme bestehen ohne externe Dienste.
Deine Übung
Baue ein Repository, das vorhandene Beispieldaten lesen lässt, aber jede Änderung mit ErrorCode::storage ablehnt. Prüfe save und remove sowie den vollständigen Zustand danach.
Lösung mit Erklärung anzeigen
WriteFailure kapselt ein MemoryRepository zum Lesen und gibt beim Schreiben einen Fehler zurück. Die Tests zeigen, dass der Dienst keine erfolgreiche Änderung meldet und die gespeicherten Aufträge erhalten bleiben.
#include "repository.hpp"
#include "test_support.hpp"
class WriteFailure final : public orders::OrderRepository {
orders::MemoryRepository data_;
public:
WriteFailure() { data_.replaceAll(samples()); }
orders::Result<std::vector<orders::Order>> list() const override {
return data_.list();
}
orders::Result<orders::Done>
replaceAll(std::span<const orders::Order>) override {
return orders::Error{orders::ErrorCode::storage, "Simulated write failure"};
}
};
int main() {
WriteFailure repository;
orders::OrderService service(repository);
require(!orders::succeeded(service.save({9, "Cannot save"})),
"write error returned");
require(!orders::succeeded(service.remove(1)), "delete error returned");
require(std::get<std::vector<orders::Order>>(service.list()) == samples(),
"data unchanged");
}
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.