← C++

C++ · 05 / 24

Header, CMake und erste Unit-Tests

Du baust mehrere Quelldateien als Projekt und prüfst fachliche Grenzen mit GoogleTest.

  • Mittel
  • Fortgeschritten
  • 75 min

Voraussetzungen: Strings, Vektoren und Standardalgorithmen, Klassen, Referenzen, const und RAII

In diesem Tutorial
  1. Die Schnittstelle trennen
  2. Die Grenze sicher berechnen
  3. Das Projekt konfigurieren
  4. Das Programm starten
  5. Die Prüfung nachvollziehen
  6. Fachliche Fälle testen
  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. GoogleTest prüft Kapazitätsgrenzen und ungültige Werte. Die Lösung ergänzt das leere Fahrzeug mit Kapazität null.

Mit mehreren Dateien muss der Compiler wissen, welche Teile zusammengehören. Ein Header beschreibt eine Schnittstelle. Eine Quelldatei enthält ihre Umsetzung. CMake beschreibt Bibliotheken, Programme und Tests. Es ist kein Ersatz für den Compiler, sondern erzeugt dessen Bauanweisungen für ein gewähltes Build-Werkzeug.

Unsere Lernregel prüft, ob eine neue Ladung noch in ein Fahrzeug passt. Sie ist ein eigenständiges Beispiel. FactoryForge transportiert in Version 0.1.0 jeweils einen Auftrag pro Fahrt. Wir verwenden die Laderegel, um exakte Kapazität, ungültige Eingaben und Zahlengrenzen an einer kleinen Funktion nachvollziehbar zu testen.

Paketinhalt und einzelne Dateien

01Die Schnittstelle trennen

cargo.h deklariert canLoad. Die Parameter stehen für vorhandene Ladung, neue Ladung und maximale Kapazität. Andere Dateien können die Funktion aufrufen, ohne ihre Umsetzung zu kopieren. Der Header-Schutz verhindert Mehrfachdefinitionen durch wiederholtes Einbinden.

cargo.h · cppDatei öffnen
#pragma once
bool canLoad(int current, int amount, int capacity);

02Die Grenze sicher berechnen

Die Umsetzung akzeptiert keine negativen Eingaben. Sie prüft zuerst, ob current innerhalb der Kapazität liegt. Danach vergleicht sie amount mit capacity - current. Eine Addition von current und amount könnte bei großen int-Werten überlaufen. Die gewählte Reihenfolge verhindert diese fehlerhafte Zwischenrechnung.

cargo.cpp · cppDatei öffnen
#include "cargo.h"
bool canLoad(int current, int amount, int capacity) {
  return current >= 0 && amount >= 0 && capacity >= 0 && current <= capacity &&
         amount <= capacity - current;
}

03Das Projekt konfigurieren

Lege alle fünf Dateien in denselben Ordner. CMakeLists.txt erzeugt die Bibliothek cargo, das Programm lesson und den Test cargo_tests. GoogleTest 1.15.2 wird beim ersten Konfigurieren in den Build-Ordner geladen. CMake 3.25 oder neuer und Ninja müssen verfügbar sein. Nutze cmake -S . -B build -G Ninja und anschließend cmake --build build.

CMakeLists.txt · cmakeDatei öffnen
cmake_minimum_required(VERSION 3.25)
project(CargoLesson LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
add_library(cargo cargo.cpp)
target_include_directories(cargo PUBLIC .)
add_executable(lesson main.cpp)
target_link_libraries(lesson PRIVATE cargo)
include(CTest)
include(FetchContent)
set(INSTALL_GTEST OFF CACHE BOOL "" FORCE)
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_Declare(googletest URL https://github.com/google/googletest/archive/refs/tags/v1.15.2.tar.gz DOWNLOAD_EXTRACT_TIMESTAMP TRUE)
FetchContent_MakeAvailable(googletest)
add_executable(cargo_tests cargo_test.cpp)
target_link_libraries(cargo_tests PRIVATE cargo GTest::gtest_main)
add_test(NAME cargo COMMAND cargo_tests)

04Das Programm starten

main.cpp ruft die Funktion mit zwei bereits geladenen und drei neuen Paketen bei Kapazität fünf auf. std::boolalpha zeigt true oder false statt einer Zahl. Unter Linux startest du ./build/lesson. Unter Windows verwendest du build\lesson.exe aus der passenden Compilerumgebung.

main.cpp · cppDatei öffnen
#include "cargo.h"
#include <iostream>
int main() {
  std::cout << std::boolalpha << "can_load=" << canLoad(2, 3, 5) << '\n';
}

Starten / prüfen

cmake -S . -B build -G Ninja
cmake --build build
./build/lesson
Erwartetes Ergebnis

can_load=true

05Die Prüfung nachvollziehen

GoogleTest prüft Kapazitätsgrenzen und ungültige Werte. Die Lösung ergänzt das leere Fahrzeug mit Kapazität null. Starte python3 run_checks.py aus dem entpackten Paket. Vergleiche die Test-Erwartungen mit der Übung, bevor du die Lösung öffnest.

cargo_test.cpp · cppDatei öffnen
#include "cargo.h"
#include <gtest/gtest.h>
#include <limits>
TEST(Cargo, AcceptsExactCapacityAndRejectsOverflow) {
  EXPECT_TRUE(canLoad(2, 3, 5));
  EXPECT_FALSE(canLoad(2, 4, 5));
  EXPECT_FALSE(canLoad(std::numeric_limits<int>::max(), 1,
                       std::numeric_limits<int>::max()));
}
TEST(Cargo, RejectsNegativeInput) {
  EXPECT_FALSE(canLoad(-1, 1, 5));
  EXPECT_FALSE(canLoad(1, -1, 5));
}
Erwartetes Ergebnis

Beispiel und automatisierte Lösung bestehen. Die genannten manuellen Prüfungen bleiben getrennt.

06Fachliche Fälle testen

Starte ctest --test-dir build --output-on-failure. Die Tests prüfen genau volle Kapazität, ein Paket zu viel, negative Werte und die höchste int-Grenze. Ein sinnvoller Test formuliert eine Zusage an den Nutzer. Eine bloße Kopie der Funktionsrechnung wäre dafür weniger hilfreich.

cargo_test.cpp · cppDatei öffnen
#include "cargo.h"
#include <gtest/gtest.h>
#include <limits>
TEST(Cargo, AcceptsExactCapacityAndRejectsOverflow) {
  EXPECT_TRUE(canLoad(2, 3, 5));
  EXPECT_FALSE(canLoad(2, 4, 5));
  EXPECT_FALSE(canLoad(std::numeric_limits<int>::max(), 1,
                       std::numeric_limits<int>::max()));
}
TEST(Cargo, RejectsNegativeInput) {
  EXPECT_FALSE(canLoad(-1, 1, 5));
  EXPECT_FALSE(canLoad(1, -1, 5));
}
Erwartetes Ergebnis

Alle Cargo-Tests bestehen.

Deine Übung

Ergänze einen Test für ein leeres Fahrzeug mit leerer Ladung und Kapazität null. Ändere danach eine Grenze absichtlich falsch und beobachte den fehlgeschlagenen Test.

Lösung mit Erklärung anzeigen

canLoad(0, 0, 0) ist gültig und liefert true. canLoad(0, 1, 0) liefert false. Formuliere für beide Fälle eine Erwartung. Wenn die Kapazitätsprüfung die exakte Grenze versehentlich ausschließt, schlägt der bestehende Test fehl. Stelle die korrekte Regel wieder her, bevor du weiterarbeitest.

solution/cargo_test.cpp · cppDatei öffnen
#include "cargo.h"
#include <gtest/gtest.h>
#include <limits>
TEST(Cargo, AcceptsExactCapacityAndRejectsOverflow) {
  EXPECT_TRUE(canLoad(2, 3, 5));
  EXPECT_FALSE(canLoad(2, 4, 5));
  EXPECT_FALSE(canLoad(std::numeric_limits<int>::max(), 1,
                       std::numeric_limits<int>::max()));
}
TEST(Cargo, RejectsNegativeInput) {
  EXPECT_FALSE(canLoad(-1, 1, 5));
  EXPECT_FALSE(canLoad(1, -1, 5));
}

TEST(Cargo, EmptyVehicleWithNoCapacity) {
  EXPECT_TRUE(canLoad(0, 0, 0));
  EXPECT_FALSE(canLoad(0, 1, 0));
}

Projektbezug und Quellen

Die ersten sechs Beispiele sind eigenständige Lernprogramme. Lektionen 7 bis 9 nutzen den vollständigen FactoryForge-Quellstand. Quellcode, Übungen und überprüfte Vereinfachungen sind getrennt beschrieben. Die Projektseite bietet ein Quellcode-ZIP, solange das GitHub-Repository noch nicht veröffentlicht ist.