← C++

C++ · 16 / 24

Daten mit span, string_view und Ranges auswerten

Du verarbeitest Aufträge ohne unnötige Eingabekopien und erklärst, wann eine geliehene Ansicht ungültig wird.

  • Mittel
  • Fortgeschritten
  • 60 min

Voraussetzungen: Strings, Vektoren und Standardalgorithmen, Header, CMake und erste Unit-Tests, Ownership, Lebensdauer und Move-Semantik, Templates und Concepts praktisch einsetzen

In diesem Tutorial
  1. Das eigenständige Paket bauen
  2. Besitz von Ansichten unterscheiden
  3. Filtern und transformieren
  4. Mit nachvollziehbaren Daten arbeiten
  5. Lebensdauer am Rückgabewert prüfen
  6. Eine weitere Abfrage ergänzen
  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. 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.

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

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.

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

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.

main.cpp · cppDatei öffnen
#include "test_support.hpp"
int main() {
  for (int id : orders::matchingIds(samples(), "Deliver"))
    std::cout << "Open delivery: " << id << '\n';
}
Erwartetes Ergebnis

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.

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

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.

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

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.

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

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.

solution.cpp · cppDatei öffnen
#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.