← C++

C++ · 17 / 24

Fehlerbehandlung und starke Ausnahmegarantie

Du trennst erwartbare Validierungsfehler von Ausnahmen und erhältst bei einem fehlgeschlagenen Stapelupdate den bisherigen Zustand.

  • Groß
  • Anspruchsvoll
  • 90 min

Voraussetzungen: Header, CMake und erste Unit-Tests, Ownership, Lebensdauer und Move-Semantik

In diesem Tutorial
  1. Erfolg und Fehler als Typ modellieren
  2. Erst prüfen, dann übernehmen
  3. Den Fehler am Aufruf behandeln
  4. Zustand nach Fehlern vergleichen
  5. Eine Ausnahme mitten im Ablauf auslösen
  6. Garantien präzise beschreiben
  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. 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.

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

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.

order.hpp · cppDatei öffnen
#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> &current,
                                     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
Erwartetes Ergebnis

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.

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

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.

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

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.

solution.cpp · cppDatei öffnen
#include "test_support.hpp"
#include <functional>
orders::Result<orders::Done>
renameBatch(std::vector<orders::Order> &current,
            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");
}
Erwartetes Ergebnis

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.

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

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.

solution.cpp · cppDatei öffnen
#include "test_support.hpp"
#include <functional>
orders::Result<orders::Done>
renameBatch(std::vector<orders::Order> &current,
            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.