C++17更新内容汇总

news2025/4/9 13:36:43

C++17 是 C++14 的进一步改进版本，它引入了许多增强特性，优化了语法，并提升了编译期计算能力。以下是 C++17 的主要更新内容：

1. 结构化绑定（Structured Bindings）

允许同时解构多个变量，从 std::tuple、std::pair、struct 或 array 中提取多个值。

#include <tuple>
#include <iostream>

std::tuple<int, double, char> getData() {
    return {42, 3.14, 'a'};
}

int main() {
    auto [x, y, z] = getData();  // 解构赋值
    std::cout << x << ", " << y << ", " << z << "\n";
}

2. `if constexpr`

编译期条件判断，避免编译无效代码，提高模板编程灵活性。

#include <iostream>
#include <type_traits>

template <typename T>
void printTypeInfo(const T& value) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "Integer: " << value << "\n";
    } else {
        std::cout << "Non-integer: " << value << "\n";
    }
}

int main() {
    printTypeInfo(42);    // 输出: Integer: 42
    printTypeInfo(3.14);  // 输出: Non-integer: 3.14
}

3. `std::optional`（可选值）

用于表示可能为空的值，替代 std::pair<bool, T> 这样的方案。

#include <optional>
#include <iostream>

std::optional<int> findEven(int n) {
    return (n % 2 == 0) ? std::optional<int>(n) : std::nullopt;
}

int main() {
    auto result = findEven(5);
    if (result) {
        std::cout << "Found: " << *result << "\n";
    } else {
        std::cout << "Not found\n";
    }
}

4. `std::variant`（类型安全的联合体）

类似 union，但支持类型安全。

#include <variant>
#include <iostream>

int main() {
    std::variant<int, double, std::string> data;
    data = 42;
    std::cout << std::get<int>(data) << "\n"; // 输出: 42

    data = "Hello";
    std::cout << std::get<std::string>(data) << "\n"; // 输出: Hello
}

5. `std::any`（任意类型存储）

可以存储任何类型的值。

#include <any>
#include <iostream>

int main() {
    std::any value = 42;
    std::cout << std::any_cast<int>(value) << "\n";

    value = std::string("Hello");
    std::cout << std::any_cast<std::string>(value) << "\n";
}

6. 文件系统库 (`<filesystem>`)

提供跨平台的文件和目录操作功能。

#include <iostream>
#include <filesystem>

int main() {
    std::filesystem::path p = "/usr/bin";
    std::cout << "Path: " << p.string() << "\n";
}

7. `std::string_view`（字符串视图）

比 std::string 更高效，不需要复制字符串数据。

#include <iostream>
#include <string_view>

void print(std::string_view sv) {
    std::cout << sv << "\n";
}

int main() {
    std::string str = "Hello, World!";
    print(str);
    print("C++17");
}

8. `std::map::try_emplace` 和 `std::unordered_map::try_emplace`

避免重复构造对象，提高效率。

#include <map>
#include <iostream>

int main() {
    std::map<int, std::string> m;
    m.try_emplace(1, "Hello");  // 仅当键 1 不存在时插入
    std::cout << m[1] << "\n";
}

9. `std::scoped_lock`（多锁安全管理）

C++17 允许同时锁定多个 std::mutex，避免死锁。

#include <mutex>
#include <thread>

std::mutex m1, m2;

void task() {
    std::scoped_lock lock(m1, m2); // 避免死锁
    // 关键代码区
}

10. `std::clamp`（值范围约束）

限制值的范围。

#include <algorithm>
#include <iostream>

int main() {
    int x = std::clamp(15, 10, 20);
    std::cout << x << "\n"; // 输出: 15
}

11. `std::reduce` 和 `std::accumulate`

std::reduce 是 std::accumulate 的并行版本，用于高效计算累积和。

#include <numeric>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v{1, 2, 3, 4, 5};
    int sum = std::reduce(v.begin(), v.end()); // 并行累加
    std::cout << sum << "\n"; // 输出: 15
}

12. `constexpr if`（编译期条件判断）

在模板编程中进行编译期条件判断，提高代码效率。

template <typename T>
void func(T value) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "Integer\n";
    } else {
        std::cout << "Non-integer\n";
    }
}

13. `std::shared_mutex`（读写锁）

std::shared_mutex 允许多个线程同时读取数据，但写入时必须独占。

#include <shared_mutex>
#include <thread>

std::shared_mutex smutex;

void read() {
    std::shared_lock lock(smutex); // 共享锁，多个线程可读
}

void write() {
    std::unique_lock lock(smutex); // 独占锁
}