← C++

C++ · 14 / 24

Fehlertolerante Dateioperationen testen

Du hältst den bisherigen Dateiinhalt bei einem vorbereitenden Schreibfehler unverändert.

  • Groß
  • Anspruchsvoll
  • 90 min

Voraussetzungen: Klassen, Referenzen, const und RAII, Header, CMake und erste Unit-Tests, Karteneditor, Undo/Redo und sichere Projektdateien

In diesem Tutorial
  1. Den Vertrag festlegen
  2. Werkzeuge und Build trennen
  3. Beobachtbare Erwartungen prüfen
  4. Eine falsche Änderung erkennen
  5. Die Übung getrennt ausführen
  6. Grenzen des Nachweises einordnen
  7. Übung und Lösung
  8. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

GCC mit C++20 und CMake ab 3.25. Zusätzlich Python 3 für den gemeinsamen Prüfstart. Entpacke das Lernpaket in einen neuen Ordner und führe dort python3 run_checks.py aus. Das Skript kopiert die enthaltenen Dateien in einen temporären Lernordner. Dort prüft es zuerst das Beispiel und danach die mitgelieferte Lösung. Die Ausgangsdateien bleiben erhalten. Benötigte Pakete werden beim ersten Lauf aus dem Netz geladen.

Geprüft am 21.10.2026 unter Linux x86_64. Prüfe erfolgreichen Ersatz und den Fehlerfall mit bereits vorhandenem temporärem Pfad. Bestehende Daten müssen dabei erhalten bleiben. Mehrere Schreiber benötigen eine zusätzliche Synchronisations- und Namensstrategie.

Die alte Datei wird erst nach erfolgreicher Vorbereitung ersetzt. Der Fehler wird vor dem Umbenennen injiziert. Das Beispiel gilt für einen einzelnen Writer in einem privaten Linux-Lernverzeichnis. Es behauptet weder Stromausfallsicherheit noch plattformübergreifend identische Ersetzungssemantik. FactoryForge verwendet hierfür QSaveFile.

Paketinhalt und einzelne Dateien

01Den Vertrag festlegen

Zuerst wird eine temporäre Datei geschrieben. Erst nach erfolgreichem Schreiben ersetzt rename das Ziel. Das Beispiel nimmt genau einen Schreiber an. Es verspricht weder eine Transaktion über mehrere Dateien noch Haltbarkeit nach Stromausfall.

main.cpp · cppDatei öffnen
#include <filesystem>
#include <fstream>
#include <iostream>
#include <stdexcept>
#include <string>
namespace fs = std::filesystem;
void save(const fs::path &target, const std::string &text, bool fail) {
  const auto temporary = target.string() + ".pending";
  if (fs::exists(temporary))
    throw std::runtime_error("Temporary file occupied");
  try {
    std::ofstream out(temporary, std::ios::binary);
    out.exceptions(std::ios::badbit | std::ios::failbit);
    out << text;
    out.flush();
    out.close();
    if (fail)
      throw std::runtime_error("Injected failure");
    fs::rename(temporary, target);
  } catch (...) {
    std::error_code ignored;
    fs::remove(temporary, ignored);
    throw;
  }
}
std::string read(const fs::path &p) {
  std::ifstream in(p);
  return {std::istreambuf_iterator<char>(in), {}};
}
int main() {
  const fs::path target = "learning-record.txt";
  if (fs::exists(target))
    throw std::runtime_error("Use a fresh learning folder");
  save(target, "old", false);
  try {
    save(target, "new", true);
    throw std::logic_error("Failure not raised");
  } catch (const std::runtime_error &) {
  }
  if (read(target) != "old")
    throw std::runtime_error("Old value lost");
  save(target, "new", false);
  if (read(target) != "new")
    throw std::runtime_error("New value missing");
  fs::remove(target);
  std::cout << "failure and replacement verified\n";
}

Starten / prüfen

python3 verify.py

02Werkzeuge und Build trennen

Lege alle Dateien in einen neuen Ordner. Lies die Compileroptionen und führe verify.py aus. Der Rückgabecode eines fehlgeschlagenen Befehls muss bis zum Aufrufer erhalten bleiben.

verify.py · pyDatei öffnen
import subprocess

subprocess.run(["cmake", "-S", ".", "-B", "build"], check=True)
subprocess.run(["cmake", "--build", "build", "--config", "Release"], check=True)
subprocess.run(
    ["ctest", "--test-dir", "build", "-C", "Release", "--output-on-failure"], check=True
)

03Beobachtbare Erwartungen prüfen

Prüfe erfolgreichen Ersatz und den Fehlerfall mit bereits vorhandenem temporärem Pfad. Bestehende Daten müssen dabei erhalten bleiben. Mehrere Schreiber benötigen eine zusätzliche Synchronisations- und Namensstrategie.

CMakeLists.txt · cmakeDatei öffnen
cmake_minimum_required(VERSION 3.20)
project(learning LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
add_executable(lesson main.cpp)
enable_testing()
add_test(NAME behaviour COMMAND lesson)
Erwartetes Ergebnis

Prüfe erfolgreichen Ersatz und den Fehlerfall mit bereits vorhandenem temporärem Pfad. Bestehende Daten müssen dabei erhalten bleiben. Mehrere Schreiber benötigen eine zusätzliche Synchronisations- und Namensstrategie.

04Eine falsche Änderung erkennen

Ändere eine geprüfte Bedingung oder das erwartete Ergebnis. Der Prüfbefehl muss nun fehlschlagen. Stelle danach den Ausgangszustand wieder her. Ein grüner Prozess allein erklärt noch nicht, welche Eigenschaft geschützt wird.

05Die Übung getrennt ausführen

Lege vor save eine .pending-Datei an. Der Aufruf muss scheitern und diese fremde Datei erhalten.

06Grenzen des Nachweises einordnen

Die Kollisionsprüfung steht vor dem try-Block. Deshalb löscht der Aufräumweg keine Datei, die er nicht selbst angelegt hat. Für mehrere Prozesse reicht diese Vorabprüfung nicht. Dann ist exklusive Dateierzeugung erforderlich.

Erwartetes Ergebnis

Der Prüflauf endet erfolgreich. Die im Beispiel benannten Bedingungen werden geprüft.

Deine Übung

Lege vor save eine .pending-Datei an. Der Aufruf muss scheitern und diese fremde Datei erhalten.

Lösung mit Erklärung anzeigen

Die Kollisionsprüfung steht vor dem try-Block. Deshalb löscht der Aufräumweg keine Datei, die er nicht selbst angelegt hat. Für mehrere Prozesse reicht diese Vorabprüfung nicht. Dann ist exklusive Dateierzeugung erforderlich.

solution.cpp · cppDatei öffnen
#include <filesystem>
#include <fstream>
#include <iostream>
#include <stdexcept>
#include <string>
namespace fs = std::filesystem;
void save(const fs::path &target, const std::string &text, bool fail) {
  const auto temporary = target.string() + ".pending";
  if (fs::exists(temporary))
    throw std::runtime_error("Temporary file occupied");
  try {
    std::ofstream out(temporary, std::ios::binary);
    out.exceptions(std::ios::badbit | std::ios::failbit);
    out << text;
    out.flush();
    out.close();
    if (fail)
      throw std::runtime_error("Injected failure");
    fs::rename(temporary, target);
  } catch (...) {
    std::error_code ignored;
    fs::remove(temporary, ignored);
    throw;
  }
}
std::string read(const fs::path &p) {
  std::ifstream in(p);
  return {std::istreambuf_iterator<char>(in), {}};
}
int main() {
  const fs::path target = "learning-record.txt";
  if (fs::exists(target))
    throw std::runtime_error("Use a fresh learning folder");
  save(target, "old", false);
  try {
    save(target, "new", true);
    throw std::logic_error("Failure not raised");
  } catch (const std::runtime_error &) {
  }
  if (read(target) != "old")
    throw std::runtime_error("Old value lost");
  save(target, "new", false);
  if (read(target) != "new")
    throw std::runtime_error("New value missing");
  fs::remove(target);
  {
    std::ofstream occupied("learning-record.txt.pending");
    occupied << "keep";
  }
  try {
    save("learning-record.txt", "other", false);
    throw std::logic_error("Accepted collision");
  } catch (const std::runtime_error &) {
  }
  if (read("learning-record.txt.pending") != "keep")
    throw std::runtime_error("Existing file changed");
  fs::remove("learning-record.txt.pending");
  std::cout << "failure and replacement verified\n";
}

Projektbezug und Quellen

Das eigenständige Lernprojekt vertieft ein Thema aus diesem Technologiebereich. Die Projektverweise zeigen einen festgehaltenen Quellstand als Architekturkontext. Sie sind kein Beleg dafür, dass jede hier neu eingeführte Bibliothek oder Funktion bereits in dieser App verwendet wird.