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. Validierungsfehler, typisierte Fehlercodes, unveränderter Bestand nach Abweisung und kontrolliert ausgelöster Ausnahme sowie erfolgreicher Batch-Commit. Kein echter Out-of-memory-Test.
Ein Import darf nicht die ersten Aufträge ersetzen und anschließend an einem ungültigen Datensatz scheitern. Wir prüfen deshalb die gesamte Eingabe, bauen einen vollständigen Kandidaten auf und übernehmen ihn an einem klaren Commit-Punkt. Ein typisiertes Ergebnis beschreibt erwartbare Fehler. Für Ausnahmen vor dem Commit sorgt der Aufbau des Algorithmus dafür, dass der Originalbestand erhalten bleibt.
Paketinhalt und einzelne Dateien
01Erfolg und Fehler als Typ modellieren
Result<T> ist eine std::variant aus Wert und Error. Error enthält einen stabilen Fehlercode sowie eine erklärende Meldung. Erfolgreiche Operationen ohne Nutzwert liefern Done. Der Aufrufer prüft succeeded, bevor er den Wert liest. Ungültige Benutzereingaben gehören hier zum normalen Kontrollfluss.
#pragma once
#include <string>
#include <variant>
namespace orders {
enum class ErrorCode { invalid, duplicate, storage, unsupported };
struct Error {
ErrorCode code;
std::string message;
};
template <class T> using Result = std::variant<T, Error>;
using Done = std::monostate;
template <class T> bool succeeded(const Result<T> &result) {
return std::holds_alternative<T>(result);
}
} // namespace orders
Ein Duplikat lässt sich über ErrorCode::duplicate unterscheiden.
02Erst prüfen, dann übernehmen
validateBatch prüft höchstens 1000 Aufträge, eindeutige IDs, Titel mit 1 bis 80 UTF-8-Bytes, Prioritäten 0 bis 2 und gültige Statuswerte. replaceValidated kopiert erst danach in einen Kandidaten. swap übernimmt den Kandidaten ohne weitere Speicherallokation. Schlägt eine vorherige Allokation fehl, bleibt current erhalten.
#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
Nach einem Validierungsfehler ist der ursprüngliche vector unverändert.
03Den Fehler am Aufruf behandeln
Das Demo versucht einen Auftrag ohne Titel zu übernehmen. Es zeigt die Fehlermeldung und anschließend die Zahl der weiterhin gespeicherten Aufträge. Eine leere gültige Liste ist dagegen eine ausdrückliche Löschoperation und kein Fehler. Diese Unterscheidung gehört später auch in die Oberfläche.
#include "test_support.hpp"
int main() {
auto current = samples();
std::vector<orders::Order> invalid{{1, ""}};
auto result = orders::replaceValidated(current, invalid);
if (auto *error = std::get_if<orders::Error>(&result))
std::cout << error->message << '\n';
std::cout << "Still saved: " << current.size() << '\n';
}
Die letzte Zeile lautet Still saved: 3.
04Zustand nach Fehlern vergleichen
Die Tests speichern vor jedem Fehlerversuch den Originalbestand. Sie prüfen Duplikate, leere Titel und ungültige Prioritäten. Entscheidend ist neben dem Fehlercode der Vergleich current == before. Ein Test, der nur irgendeinen Fehler erwartet, würde eine teilweise Änderung übersehen.
#include "test_support.hpp"
int main() {
auto current = samples();
const auto before = current;
auto incoming = samples();
incoming[1].id = incoming[0].id;
auto result = orders::replaceValidated(current, incoming);
require(!orders::succeeded(result), "duplicate rejected");
require(std::get<orders::Error>(result).code == orders::ErrorCode::duplicate,
"typed error");
require(current == before, "validation failure preserves old state");
incoming = samples();
incoming[0].title = " ";
require(!orders::succeeded(orders::replaceValidated(current, incoming)),
"blank title");
incoming[0].title = "New order";
incoming[0].priority = 3;
require(!orders::succeeded(orders::replaceValidated(current, incoming)),
"priority bounds");
require(current == before, "all failures preserve state");
require(orders::succeeded(orders::replaceValidated(current, {})),
"empty replacement valid");
require(current.empty(), "empty replacement clears explicitly");
std::cout << "validation and commit checks passed\n";
}
Alle abgewiesenen Stapel lassen den ursprünglichen Inhalt bestehen.
05Eine Ausnahme mitten im Ablauf auslösen
Die Übung benennt mehrere Aufträge über eine übergebene Funktion um. Diese Funktion darf beim zweiten Auftrag eine Ausnahme werfen. Die Lösung arbeitet deshalb auf einer Kopie und übernimmt erst nach vollständiger Umbenennung und Validierung. Die Ausnahme wird nicht verschluckt. Der Test fängt sie an seiner äußeren Grenze auf und prüft den unveränderten Bestand.
#include "test_support.hpp"
#include <functional>
orders::Result<orders::Done>
renameBatch(std::vector<orders::Order> ¤t,
const std::function<std::string(const orders::Order &)> &rename) {
auto candidate = current;
for (auto &order : candidate)
order.title = rename(order);
return orders::replaceValidated(current, candidate);
}
int main() {
auto current = samples();
const auto before = current;
bool threw = false;
try {
renameBatch(current, [](const auto &order) -> std::string {
if (order.id == 2)
throw std::runtime_error("formatter unavailable");
return "Changed";
});
} catch (const std::runtime_error &) {
threw = true;
}
require(threw && current == before, "exception preserves whole batch");
require(
!orders::succeeded(renameBatch(current, [](const auto &) { return ""; })),
"invalid result rejected");
require(current == before, "validation preserves whole batch");
require(
orders::succeeded(renameBatch(
current, [](const auto &order) { return "Ready: " + order.title; })),
"commit valid rename");
require(current[0].title == "Ready: Deliver motors", "new title");
}
Ein Fehler beim zweiten Titel hinterlässt keinen bereits umbenannten ersten Auftrag.
06Garantien präzise beschreiben
Baue mit python3 verify.py. Der Test löst eine kontrollierte Ausnahme aus. Er simuliert keinen echten Speichermangel des Betriebssystems. Die starke Garantie folgt hier aus Kandidatenaufbau und nicht werfendem swap. Diese Aussage gilt für diesen Ablauf, nicht pauschal für jede Funktion des Programms.
cmake_minimum_required(VERSION 3.25)
project(cpp_17 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)
Beispiel und Umbenennungslösung bestehen CTest.
Deine Übung
Implementiere renameBatch mit einer übergebenen Umbenennungsfunktion. Ein Fehler beim zweiten Auftrag oder ein ungültiger neuer Titel muss alle alten Titel erhalten. Ergänze außerdem einen erfolgreichen Durchlauf.
Lösung mit Erklärung anzeigen
Die Lösung kopiert den Bestand, ruft die Umbenennungsfunktion nur auf dem Kandidaten auf und verwendet replaceValidated für den abschließenden Commit. Der Test prüft geworfene Ausnahme, Validierungsfehler und erfolgreiche Übernahme getrennt.
#include "test_support.hpp"
#include <functional>
orders::Result<orders::Done>
renameBatch(std::vector<orders::Order> ¤t,
const std::function<std::string(const orders::Order &)> &rename) {
auto candidate = current;
for (auto &order : candidate)
order.title = rename(order);
return orders::replaceValidated(current, candidate);
}
int main() {
auto current = samples();
const auto before = current;
bool threw = false;
try {
renameBatch(current, [](const auto &order) -> std::string {
if (order.id == 2)
throw std::runtime_error("formatter unavailable");
return "Changed";
});
} catch (const std::runtime_error &) {
threw = true;
}
require(threw && current == before, "exception preserves whole batch");
require(
!orders::succeeded(renameBatch(current, [](const auto &) { return ""; })),
"invalid result rejected");
require(current == before, "validation preserves whole batch");
require(
orders::succeeded(renameBatch(
current, [](const auto &order) { return "Ready: " + order.title; })),
"commit valid rename");
require(current[0].title == "Ready: Deliver motors", "new title");
}
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.