C++

C++17: Der praxisnahe Standard

Erkunde die wirkungsvollsten Features von C++17: structured bindings, std::optional/variant/any, std::string_view, std::filesystem, if constexpr und neue Attribute.

Warum C++17 wichtig ist

C++17 wird oft der "praxisnahe Standard" genannt, weil es eine Fülle von Features mitbrachte, die den Alltagscode vereinfachen, ohne tiefes Wissen über Template-Metaprogrammierung vorauszusetzen. Es hat Altlasten entfernt (etwa std::auto_ptr und Trigraphen), Vokabulartypen hinzugefügt (std::optional, std::variant, std::any) und syntaktischen Zucker eingeführt, der Code zugleich kürzer und klarer macht. Wenn du heute produktives C++ schreibst, sollte C++17 deine Mindestbasis sein.

Structured Bindings & Initializer-Anweisungen

Structured Bindings erlauben es dir, Aggregate (Structs, Arrays, Pairs, Tupel) in einer einzigen Deklaration in benannte Variablen zu zerlegen. In Kombination mit if/switch-Initialisierern sparen sie viele temporäre Variablen ein:

structured_bindings.cpp
#include <iostream>
#include <map>
#include <string>
#include <tuple>

std::tuple<std::string, int, double> get_employee() {
    return {"Alice", 42, 95000.0};
}

int main() {
    // Structured binding with tuple
    auto [name, age, salary] = get_employee();
    std::cout << name << " is " << age << " years old\n";

    // Structured binding with map iteration
    std::map<std::string, int> scores{{"Alice", 95}, {"Bob", 87}};
    for (const auto& [student, score] : scores) {
        std::cout << student << ": " << score << "\n";
    }

    // if with initializer — the variable is scoped to the if/else
    if (auto it = scores.find("Alice"); it != scores.end()) {
        std::cout << "Found: " << it->second << "\n";
    } else {
        std::cout << "Not found\n";
    }
    // 'it' no longer exists here — no scope leakage

    // Structured binding with array
    int arr[3] = {10, 20, 30};
    auto [x, y, z] = arr;
    std::cout << x << ", " << y << ", " << z << "\n";

    return 0;
}

Vokabulartypen: optional, variant, any

std::optional steht für einen Wert, der vorhanden sein kann oder auch nicht (und ersetzt damit Sentinel-Werte und Ausgabeparameter). std::variant ist eine typsichere Union. std::any nimmt jeden kopierbaren Typ auf, mit Typprüfung zur Laufzeit:

vocabulary_types.cpp
#include <iostream>
#include <optional>
#include <variant>
#include <any>
#include <string>

// optional: replaces "return -1 on failure" patterns
std::optional<int> find_index(const std::string& haystack, char needle) {
    for (size_t i = 0; i < haystack.size(); ++i) {
        if (haystack[i] == needle) return static_cast<int>(i);
    }
    return std::nullopt;  // no value
}

int main() {
    // std::optional
    auto idx = find_index("hello", 'l');
    if (idx.has_value()) {
        std::cout << "Found at index " << *idx << "\n";       // 2
    }
    std::cout << idx.value_or(-1) << "\n";  // safe default

    // std::variant — type-safe union
    std::variant<int, double, std::string> value = "hello";
    std::cout << std::get<std::string>(value) << "\n";

    // Visit pattern — exhaustive handling of all types
    std::visit([](const auto& v) {
        std::cout << "Value: " << v << "\n";
    }, value);

    value = 3.14;  // now holds a double
    std::cout << std::get<double>(value) << "\n";

    // std::any — truly any type, with runtime checking
    std::any data = 42;
    std::cout << std::any_cast<int>(data) << "\n";
    data = std::string("world");
    std::cout << std::any_cast<std::string>(data) << "\n";

    return 0;
}

string_view & filesystem

std::string_view ist eine leichtgewichtige, nicht besitzende Referenz auf einen String. Sie vermeidet Kopien, wenn du einen String nur lesen musst. std::filesystem bietet portable, plattformübergreifende Pfadmanipulation und Dateioperationen:

string_view_fs.cpp
#include <iostream>
#include <string>
#include <string_view>
#include <filesystem>

namespace fs = std::filesystem;

// string_view avoids copying — just a pointer + length
void print_trimmed(std::string_view sv) {
    auto start = sv.find_first_not_of(' ');
    auto end = sv.find_last_not_of(' ');
    if (start != std::string_view::npos) {
        std::cout << sv.substr(start, end - start + 1) << "\n";
    }
}

int main() {
    std::string name = "  Hello, C++17!  ";
    print_trimmed(name);       // no copy — string_view binds to string
    print_trimmed("  world  "); // no copy — binds to string literal

    // std::filesystem — portable path operations
    fs::path source_dir = "/home/user/project/src";
    std::cout << "Filename: " << source_dir.filename() << "\n";
    std::cout << "Parent:   " << source_dir.parent_path() << "\n";
    std::cout << "Exists:   " << fs::exists(source_dir) << "\n";

    // Iterate directory entries
    for (const auto& entry : fs::directory_iterator(".")) {
        if (entry.is_regular_file()) {
            std::cout << entry.path().filename()
                      << " (" << entry.file_size() << " bytes)\n";
        }
    }

    // Create directories recursively
    fs::create_directories("output/logs/2024");

    return 0;
}

if constexpr, CTAD und mehr

if constexpr ermöglicht Verzweigungen zur Kompilierzeit innerhalb von Templates — Zweige, die nicht passen, werden vollständig verworfen. Class Template Argument Deduction (CTAD) erlaubt es dir, Template-Argumente wegzulassen, wenn der Compiler sie herleiten kann. Fold Expressions vereinfachen variadische Template-Parameter-Packs:

if_constexpr.cpp
#include <iostream>
#include <string>
#include <vector>
#include <type_traits>

// if constexpr — branches resolved at compile time
template<typename T>
std::string to_string_safe(T value) {
    if constexpr (std::is_arithmetic_v<T>) {
        return std::to_string(value);
    } else if constexpr (std::is_same_v<T, std::string>) {
        return value;
    } else {
        return "[unsupported type]";
    }
}

// Fold expressions — collapse parameter packs
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);  // unary right fold
}

template<typename... Args>
void print_all(Args&&... args) {
    ((std::cout << args << " "), ...);  // fold over comma
    std::cout << "\n";
}

int main() {
    std::cout << to_string_safe(42) << "\n";
    std::cout << to_string_safe(std::string("hi")) << "\n";

    std::cout << sum(1, 2, 3, 4, 5) << "\n";  // 15
    print_all(1, "hello", 3.14);               // 1 hello 3.14

    // CTAD — no need for std::vector<int>
    std::vector v{1, 2, 3, 4, 5};   // deduced as vector<int>
    std::pair p{"hello", 42};        // deduced as pair<const char*, int>

    // Nested namespaces
    // namespace A::B::C { } instead of namespace A { namespace B { namespace C { } } }

    // Inline variables — can be defined in headers without ODR violations
    // inline constexpr int version = 17;

    return 0;
}
Best Practice

C++17 hat drei wichtige Attribute standardisiert:

[[nodiscard]] — Warnt, wenn ein Rückgabewert verworfen wird. Setze es bei Funktionen ein, deren Rückgabewert immer geprüft werden sollte (Fehlercodes, allokierte Ressourcen, Factory-Funktionen).

[[maybe_unused]] — Unterdrückt Warnungen über unbenutzte Variablen/Parameter. Nützlich für Variablen, die nur in Debug-Builds oder plattformspezifischem Code verwendet werden.

[[fallthrough]] — Kennzeichnet ein beabsichtigtes Durchfallen in einem switch-Case und bringt Compiler-Warnungen zum Schweigen.

Setze [[nodiscard]] in deinen APIs offensiv ein. Ein verworfener Fehlercode ist ein Bug, der nur darauf wartet zu passieren.

Stolperfalle

Gib niemals eine std::string_view zurück, die auf einen lokalen String verweist. Da string_view ihre Daten nicht besitzt, kann der zugrunde liegende String zerstört werden, bevor die View benutzt wird — das führt zu undefiniertem Verhalten:

// GEFÄHRLICH — gibt eine View auf ein zerstörtes Temporary zurück!
std::string_view bad() {
    std::string s = "hello";
    return s;  // s wird am Ende der Funktion zerstört!
}

Faustregel: Verwende string_view für Parameter (Daten lesen) und gib std::string als Rückgabewert zurück (Daten besitzen).

Wichtigste Erkenntnisse
  • Structured Bindings (auto [a, b] = ...) zerlegen Tupel, Pairs, Structs und Arrays sauber
  • std::optional ersetzt Sentinel-Werte, std::variant ersetzt unsichere Unions, std::any dient für wirklich dynamische Typen
  • std::string_view vermeidet Kopien beim rein lesenden String-Zugriff — aber Vorsicht vor Dangling-Referenzen
  • if constexpr ermöglicht Verzweigungen zur Kompilierzeit in Templates und macht SFINAE-Boilerplate überflüssig
  • CTAD lässt den Compiler Template-Argumente herleiten: std::vector v{1,2,3} funktioniert einfach
  • Verwende [[nodiscard]] bei Funktionen, deren Rückgabewerte nicht ignoriert werden dürfen

Quiz — Teste dein Wissen

(15 XP)

1. Was bewirkt `auto [x, y] = std::make_pair(1, 2.0);` in C++17?

2. Wofür steht `std::optional<int>`?

3. Warum ist es gefährlich, eine `std::string_view` aus einer Funktion zurückzugeben, wenn sie auf einen lokalen String verweist?

Zurück
Parallele Algorithmen & Ausführungsrichtlinien
Weiter
C++20: Die großen Vier und mehr