← C++

C++ · 13 / 24

Templates und Concepts praktisch einsetzen

Du begrenzt einen generischen Algorithmus und prüfst erlaubte Typen beim Kompilieren.

  • Groß
  • Anspruchsvoll
  • 90 min

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

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. Das gültige Beispiel kompiliert und liefert den erwarteten Wert. Der negative Compile-Test übergibt einen ungeeigneten Typ und muss abgelehnt werden. Die Lösung begrenzt die erlaubte Eingabe auf 32-Bit-Typen bewusst.

Templates lassen den Compiler für konkrete Typen passenden Code erzeugen. Ein Concept beschreibt, welche Typen ein Vertrag annimmt. Es ersetzt keine fachliche Prüfung von Werten. Unser Beispiel akzeptiert ganze Zahlen, aber bool wird bewusst ausgeschlossen.

Paketinhalt und einzelne Dateien

01Den Vertrag festlegen

Ein Concept beschreibt die Operationen, die ein Template benötigt. Der Compiler prüft diese Anforderungen vor der Instanziierung. Die Fehlermeldung liegt dadurch näher an der Schnittstelle als ein zufälliger Fehler tief im Template.

main.cpp · cppDatei öffnen
#include <concepts>
#include <iostream>
#include <limits>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
template <class T>
concept Reading = std::integral<T> && (!std::same_as<T, bool>);
template <Reading T> long long total(const std::vector<T> &values) {
  long long result = 0;
  for (T value : values) {
    if (!std::in_range<long long>(value))
      throw std::overflow_error("Input too large");
    const auto next = static_cast<long long>(value);
    if ((next > 0 && result > std::numeric_limits<long long>::max() - next) ||
        (next < 0 && result < std::numeric_limits<long long>::min() - next))
      throw std::overflow_error("Total too large");
    result += next;
  }
  return result;
}
static_assert(Reading<int>);
static_assert(!Reading<std::string>);
static_assert(!Reading<bool>);
int main() {
  if (total(std::vector<int>{1, 2, 3}) != 6)
    throw std::runtime_error("Wrong total");
  if (total(std::vector<short>{}) != 0)
    throw std::runtime_error("Empty total");
  std::cout << "constraints 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
)

from pathlib import Path

Path("invalid.cpp").write_text(
    '#define main lesson_main\n#include "main.cpp"\n#undef main\nint main() { total(std::vector<bool>{true}); }\n'
)
invalid = subprocess.run(
    ["g++", "-std=c++20", "-c", "invalid.cpp"], capture_output=True, text=True
)
if invalid.returncode == 0 or "constraints" not in invalid.stderr:
    raise RuntimeError("Expected a concept constraint failure")

03Beobachtbare Erwartungen prüfen

Das gültige Beispiel kompiliert und liefert den erwarteten Wert. Der negative Compile-Test übergibt einen ungeeigneten Typ und muss abgelehnt werden. Die Lösung begrenzt die erlaubte Eingabe auf 32-Bit-Typen bewusst.

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

Gültige Ganzzahlen werden summiert. bool wird vom Compiler abgelehnt. Ein zu großer Wert führt zu overflow_error.

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

Begrenze die Eingabetypen auf höchstens 32 Bit, damit der Beispielvertrag keine 64-Bit-Eingaben verspricht.

06Grenzen des Nachweises einordnen

Die zusätzliche Bedingung schränkt die Typmenge ein. Auch damit können extrem lange Eingaben überlaufen. Für einen allgemeinen Summenvertrag wären geprüfte Addition und eine dokumentierte Mengengrenze nötig.

Erwartetes Ergebnis

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

Deine Übung

Begrenze die Eingabetypen auf höchstens 32 Bit, damit der Beispielvertrag keine 64-Bit-Eingaben verspricht.

Lösung mit Erklärung anzeigen

Die zusätzliche Bedingung schränkt die Typmenge ein. Auch damit können extrem lange Eingaben überlaufen. Für einen allgemeinen Summenvertrag wären geprüfte Addition und eine dokumentierte Mengengrenze nötig.

solution.cpp · cppDatei öffnen
#include <concepts>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
template <class T>
concept Reading = std::integral<T> && (!std::same_as<T, bool>);
template <Reading T> long long total(const std::vector<T> &values) {
  long long result = 0;
  for (T value : values)
    result += value;
  return result;
}
static_assert(Reading<int>);
static_assert(!Reading<std::string>);
static_assert(!Reading<bool>);
template <class T>
concept SmallReading = Reading<T> && (sizeof(T) <= 4);
static_assert(SmallReading<int>);
static_assert(!SmallReading<long long>);
int main() {
  if (total(std::vector<int>{1, 2, 3}) != 6)
    throw std::runtime_error("Wrong total");
  if (total(std::vector<short>{}) != 0)
    throw std::runtime_error("Empty total");
  std::cout << "constraints 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.