C++

C++17: Практический стандарт

Изучите наиболее эффективные функции C++17: структурированные связывания, std::optional/variant/any, std::string view, std::filesystem, if constexpr и новые атрибуты.

Почему C++17 Вопросы

C++17 часто называют «практическим стандартом», потому что он ввел множество функций, которые упрощают повседневное кодирование, не требуя глубоких знаний метапрограммирования шаблонов. Он удалил унаследованный багаж (например, std::auto_ptr и триграфы), добавил типы словарного запаса (std::optional, std::variant, std::any) и ввел синтаксический сахар, который делает код короче и яснее. Если вы пишете производство C++ сегодня, C++17 должен быть вашим минимальным исходным уровнем .

Структурированные связывающие и инициализаторные заявления

Структурированные привязки позволяют распаковать агрегаты (структуры, массивы, пары, кортежи) в названные переменные в одной декларации. В сочетании с инициализаторами if/switch они устраняют многие временные переменные:

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;
}

Типы словарей: факультативный, вариант, любой

std::optional представляет собой значение, которое может или не может присутствовать (заменяя сторожевые значения и выходные параметры). std::variant является типобезопасным союзом. std::any имеет любой копируемый тип с проверкой типа выполнения:

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 и файловая система

std::string_view - это легкая, не владеющая ссылка на строку. Он избегает копий, когда вам нужно только прочитать строку. std::filesystem обеспечивает переносные, кросс-платформенные манипуляции и файловые операции:

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;
}

Если constexpr, CTAD и другие

if constexpr позволяет ветвиться внутри шаблонов — ветви, которые не совпадают, полностью отбрасываются. Class Template Argument Deduction (CTAD) позволяет опустить аргументы шаблона, когда компилятор может вывести их. Складные выражения упрощают вариадические наборы параметров шаблона:

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;
}
Лучшая практика

C++17 стандартизовал три важных атрибута:

[[nodiscard]] — Предупреждает об отклонении возвратного значения. Используйте его на функциях, обратная стоимость которых всегда должна проверяться (коды ошибок, выделенные ресурсы, заводские функции).

[[maybe_unused]] — Подавляет предупреждения о неиспользуемых переменных параметрах. Полезно для переменных, используемых только в сборках отладки или коде для конкретной платформы.

[[fallthrough]] Указывает на преднамеренный провал в случае switch, замалчивая предупреждения компилятора.

Принимайте [[nodiscard]] агрессивно на своих API. Выброшенный код ошибки - это ошибка, ожидающая своего появления.

Подводный камень

Никогда не возвращайте std::string_view, который ссылается на локальную строку. Поскольку string_view не владеет своими данными, лежащая в основе строка может быть уничтожена до того, как будет использовано представление, вызывая неопределенное поведение :

// DANGEROUS — returns a view to a destroyed temporary!
std::string_view bad() {
    std::string s = "hello";
    return s;  // s is destroyed at end of function!
}

Правило большого пальца: используйте string_view для параметров (данные чтения), возвращайте std::string для значений возврата (собственные данные).

Ключевые выводы
  • Структурированные связывания (auto [a, b] = ...) распаковывают кортежи, пары, структуры и массивы чисто
  • std::optional заменяет сторожевые значения; std::variant заменяет небезопасные союзы; std::any для действительно динамических типов
  • std::string_view избегает копий для доступа к строкам только для чтения, но остерегайтесь болтающихся ссылок
  • if constexpr обеспечивает ветвление времени компиляции в шаблонах, устраняя SFINAE boilerplate
  • CTAD позволяет компилятору выводить аргументы шаблона: std::vector v{1,2,3} просто работает
  • Использование [[nodiscard]] для функций, обратные значения которых не должны игнорироваться.

Тест — проверьте свои знания

(15 XP)

1. Что делает `auto [x, y] = std::make_pair(1, 2.0);` в C++17?

2. Что представляет собой `std::optional<int>`?

3. Зачем возвращать `std::string_view` из опасной функции, если она ссылается на локальную строку?

Назад
Параллельные алгоритмы и исполнительная политика
Далее
C++20: Большая четверка и многое другое