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. C++20-Build, Filterergebnisse, leere Eingaben und unabhängig gespeicherte Rückgabewerte. Die Übung zählt dringende offene Aufträge. Keine Laufzeitmessung oder automatische Prüfung aller möglichen Lebensdauerfehler.
Ein Auftragsfilter benötigt lesenden Zugriff auf eine Liste und einen Suchtext. Er muss deren Speicher nicht besitzen. In diesem Beispiel gehören die Aufträge einem vector. span beschreibt den lesbaren Ausschnitt, string_view den Suchtext und eine Ranges-Pipeline die Auswahl. Das Ergebnis besitzt seine IDs selbst. Diese Grenze verhindert, dass der Aufrufer eine Ansicht auf bereits zerstörte Daten erhält.
Paketinhalt und einzelne Dateien
01Das eigenständige Paket bauen
Entpacke cpp-16.zip. Mit python3 verify.py entstehen ein Demo-Programm und zwei Prüfprogramme. C++20 wird ausdrücklich verlangt. Warnungen werden bei GCC und Clang als Fehler behandelt, damit beispielsweise problematische temporäre Referenzen beim Bauen auffallen.
cmake_minimum_required(VERSION 3.25)
project(cpp_16 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)
CTest meldet zwei bestandene Prüfprogramme.
02Besitz von Ansichten unterscheiden
Order besitzt seinen Titel als std::string. matchingIds nimmt std::span<const Order> und std::string_view entgegen. Beide Parameter leihen Speicher. Die Filteransicht wird innerhalb der Funktion ausgewertet. Der zurückgegebene vector<int> besitzt dagegen seine Elemente. Vergrößere oder zerstöre den ursprünglichen vector nicht, solange du noch eine seiner Ansichten verwendest.
#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
Es verlässt keine geliehene Ansicht die Funktion.
03Filtern und transformieren
Starte ./build/order_lab. filter berücksichtigt nur offene Aufträge, deren Titel den Suchtext enthält. transform liest daraus die ID. Die Suche ist bewusst abhängig von Groß- und Kleinschreibung. Ein leerer Suchtext passt zu allen offenen Aufträgen. Hier ist die Pipeline lazy, das Ergebnis wird beim Aufbau des Rückgabevectors materialisiert.
#include "test_support.hpp"
int main() {
for (int id : orders::matchingIds(samples(), "Deliver"))
std::cout << "Open delivery: " << id << '\n';
}
Open delivery: 1
04Mit nachvollziehbaren Daten arbeiten
Die drei künstlichen Aufträge unterscheiden sich in Titel, Priorität und Status. Ein abgeschlossener Auftrag enthält ebenfalls Deliver. Dadurch erkennt der Test, ob der Statusfilter wirklich greift. require wirft bei einem Fehler eine Ausnahme und funktioniert auch dann, wenn ein Release-Build normale assert-Aufrufe entfernt.
#pragma once
#include "order.hpp"
#include <iostream>
#include <stdexcept>
inline void require(bool condition, const char *message) {
if (!condition)
throw std::runtime_error(message);
}
inline std::vector<orders::Order> samples() {
return {{1, "Deliver motors", 2},
{2, "Move pallets", 0},
{3, "Deliver sensors", 1, orders::Status::done}};
}
Nur der erste Auftrag erfüllt beide Bedingungen.
05Lebensdauer am Rückgabewert prüfen
Die Tests behandeln leere Listen, fehlende Treffer und das Ergebnis nach dem Leeren des Eingabevectors. Dieser letzte Test beweist, dass die zurückgegebenen IDs selbstständig gespeichert sind. Er beweist nicht, dass beliebige span- oder string_view-Objekte automatisch sicher sind. Ungültige Ansichten dürfen auch im Test nicht dereferenziert werden.
#include "test_support.hpp"
int main() {
auto batch = samples();
require(orders::matchingIds(batch, "Deliver") == std::vector<int>{1},
"filter open titles");
require(orders::matchingIds({}, "").empty(), "empty input");
require(orders::matchingIds(batch, "absent").empty(), "no match");
auto owned = orders::matchingIds(batch, "");
batch.clear();
require(owned == std::vector<int>({1, 2}), "returned IDs own their memory");
std::cout << "ranges and ownership checks passed\n";
}
ranges and ownership checks passed
06Eine weitere Abfrage ergänzen
Implementiere die Übung zunächst selbst. Die Lösung verwendet ranges::count_if für offene Aufträge mit Priorität 2. Für eine reine Anzahl braucht es keinen zusätzlichen Ergebnisvector. Prüfe normale Daten, eine leere Eingabe und einen bereits abgeschlossenen dringenden Auftrag.
#include "test_support.hpp"
std::size_t countUrgent(std::span<const orders::Order> values) {
return std::size_t(std::ranges::count_if(values, [](const auto &order) {
return order.status == orders::Status::open && order.priority == 2;
}));
}
int main() {
require(countUrgent(samples()) == 1, "one open urgent order");
require(countUrgent({}) == 0, "empty input");
std::vector<orders::Order> completed{
{1, "Completed", 2, orders::Status::done}};
require(countUrgent(completed) == 0, "done is excluded");
}
Die Beispielmenge enthält genau einen offenen dringenden Auftrag.
Deine Übung
Schreibe countUrgent(span<const Order>). Zähle nur offene Aufträge mit Priorität 2. Die Funktion darf die Eingabe nicht verändern. Ergänze Prüfungen für eine leere Liste und einen abgeschlossenen dringenden Auftrag.
Lösung mit Erklärung anzeigen
solution.cpp kombiniert beide Bedingungen in einem Prädikat und liefert die Anzahl als size_t. Der leere Bereich ergibt 0. Ein Auftrag mit Status done zählt trotz Priorität 2 nicht. Starte python3 verify.py, um Beispiel und Lösung gemeinsam zu prüfen.
#include "test_support.hpp"
std::size_t countUrgent(std::span<const orders::Order> values) {
return std::size_t(std::ranges::count_if(values, [](const auto &order) {
return order.status == orders::Status::open && order.priority == 2;
}));
}
int main() {
require(countUrgent(samples()) == 1, "one open urgent order");
require(countUrgent({}) == 0, "empty input");
std::vector<orders::Order> completed{
{1, "Completed", 2, orders::Status::done}};
require(countUrgent(completed) == 0, "done is excluded");
}
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.