【C++ 17 新特性 】拥抱现代C++：深入C++17特性以获得更高效、更安全的代码

#include <iostream>
#include <tuple>
#include <map>
int main() {
    // 使用结构化绑定从元组中解析变量
    std::tuple<int, double, std::string> t = {42, 3.14, "Hello"};
    auto [a, b, c] = t;
    std::cout << a << ", " << b << ", " << c << std::endl;
    // 使用结构化绑定从map遍历中解析键值对
    std::map<int, std::string> m = {{1, "One"}, {2, "Two"}, {3, "Three"}};
    for (const auto& [key, value] : m) {
        std::cout << key << " -> " << value << std::endl;
    }
    // 使用结构化绑定从结构体中解析成员
    struct Point {
        int x;
        int y;
    };
    Point p = {1, 2};
    auto [x, y] = p;
    std::cout << "Point: (" << x << ", " << y << ")" << std::endl;
    return 0;
}

#include <tuple>
class MyType {
public:
    int a = 1;
    double b = 2.0;
    std::string c = "Three";
};
// 提供get函数
template <std::size_t N>
decltype(auto) get(const MyType& mt) {
    if constexpr (N == 0) {
        return mt.a;
    } else if constexpr (N == 1) {
        return mt.b;
    } else {
        return mt.c;
    }
}
// 特化std::tuple_size
namespace std {
    template <>
    struct tuple_size<MyType> : std::integral_constant<std::size_t, 3> {};
}
// 特化std::tuple_element
namespace std {
    template <>
    struct tuple_element<0, MyType> {
        using type = int;
    };
    template <>
    struct tuple_element<1, MyType> {
        using type = double;
    };
    template <>
    struct tuple_element<2, MyType> {
        using type = std::string;
    };
}
int main() {
    MyType mt;
    auto [my_a, my_b, my_c] = mt;  // 现在MyType支持结构化绑定
    return 0;
}

#include <iostream>
#include <type_traits>
template <typename T>
auto print_type_info(const T& t) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << t << " is an integral number." << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << t << " is a floating-point number." << std::endl;
    } else {
        std::cout << "Unknown type." << std::endl;
    }
}
int main() {
    int i = 42;
    double d = 3.14;
    std::string s = "hello";
    print_type_info(i);
    print_type_info(d);
    print_type_info(s);
    return 0;
}

// counter.h
extern int counter; // 在其他源文件中声明变量
// counter.cpp
int counter = 0; // 在一个源文件中定义变量
// main.cpp
#include "counter.h"
// 在main.cpp中使用counter

// counter.h
inline int counter = 0; // 使用内联变量在头文件中定义变量
// main.cpp
#include "counter.h"
// 在main.cpp中使用counter，无需额外的链接操作

#include <iostream>
#include <filesystem>
int main() {
    namespace fs = std::filesystem;
    // 创建一个新目录
    fs::create_directory("test_directory");
    // 在新目录下创建一个文件
    fs::path file_path = "test_directory/test_file.txt";
    std::ofstream file(file_path);
    file << "Hello, Filesystem!";
    file.close();
    // 查询文件大小
    std::uintmax_t file_size = fs::file_size(file_path);
    std::cout << "File size: " << file_size << " bytes" << std::endl;
    // 重命名文件
    fs::path new_file_path = "test_directory/renamed_file.txt";
    fs::rename(file_path, new_file_path);
    // 删除文件和目录
    fs::remove(new_file_path);
    fs::remove("test_directory");
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
#include <random>
#include <chrono>
int main() {
    // 生成一个包含1000000个随机整数的向量
    std::vector<int> data(1000000);
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1, 1000000);
    std::generate(data.begin(), data.end(), [&]() { return dis(gen); });
    // 使用顺序算法排序
    auto seq_data = data;
    auto start = std::chrono::high_resolution_clock::now();
    std::sort(std::execution::seq, seq_data.begin(), seq_data.end());
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed = end - start;
    std::cout << "Sequential sort time: " << elapsed.count() << " seconds" << std::endl;
    // 使用并行算法排序
    auto par_data = data;
    start = std::chrono::high_resolution_clock::now();
    std::sort(std::execution::par, par_data.begin(), par_data.end());
    end = std::chrono::high_resolution_clock::now();
    elapsed = end - start;
    std::cout << "Parallel sort time: " << elapsed.count() << " seconds" << std::endl;
    return 0;
}

#include <iostream>
#include <optional>
#include <cmath>
// 计算平方根，当输入值为负数时返回std::nullopt
std::optional<double> sqrt_optional(double x) {
    if (x >= 0) {
        return std::sqrt(x);
    } else {
        return std::nullopt;
    }
}
int main() {
    auto result1 = sqrt_optional(4.0);
    auto result2 = sqrt_optional(-1.0);
    if (result1) {
        std::cout << "Square root of 4.0 is: " << *result1 << std::endl;
    } else {
        std::cout << "Cannot compute square root of 4.0" << std::endl;
    }
    if (result2) {
        std::cout << "Square root of -1.0 is: " << *result2 << std::endl;
    } else {
        std::cout << "Cannot compute square root of -1.0" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <variant>
#include <string>
int main() {
    std::variant<int, double, std::string> my_variant;
    my_variant = 42;
    std::cout << "my_variant contains an int: " << std::get<int>(my_variant) << std::endl;
    my_variant = 3.14;
    std::cout << "my_variant contains a double: " << std::get<double>(my_variant) << std::endl;
    my_variant = "hello";
    std::cout << "my_variant contains a string: " << std::get<std::string>(my_variant) << std::endl;
    return 0;
}

#include <iostream>
#include <any>
#include <string>
int main() {
    std::any my_any;
    my_any = 42;
    std::cout << "my_any contains an int: " << std::any_cast<int>(my_any) << std::endl;
    my_any = 3.14;
    std::cout << "my_any contains a double: " << std::any_cast<double>(my_any) << std::endl;
    my_any = std::string("hello");
    std::cout << "my_any contains a string: " << std::any_cast<std::string>(my_any) << std::endl;
    return 0;
}

#include <iostream>
#include <unordered_set>
int main() {
    std::unordered_set<int> set1{1, 2, 3, 4};
    std::unordered_set<int> set2{5, 6, 7, 8};
    auto node = set1.extract(2); // 提取节点
    set2.insert(std::move(node)); // 插入节点到set2
    for (const auto &elem : set2) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <string_view>
void print_string_view(std::string_view sv) {
    std::cout << sv << std::endl;
}
int main() {
    std::string s = "hello, world!";
    std::string_view sv(s);
    print_string_view(sv.substr(0, 5)); // 输出 "hello"
    return 0;
}

#include <iostream>
#include <functional>
void print(int x) {
    std::cout << x << std::endl;
}
struct Printer {
    void operator()(int x) const {
        std::cout << x << std::endl;
    }
};
int main() {
    auto lambda = [](int x) { std::cout << x << std::endl; };
    std::invoke(print, 42); // 调用普通函数
    std::invoke(lambda, 42); // 调用Lambda表达式
    std::invoke(Printer{}, 42); // 调用函数对象
    return 0;
}

constexpr auto square = [](int x) { return x * x; };
int main() {
    constexpr int result = square(4); // 编译时执行
    static_assert(result == 16, "Error: Incorrectsquare computation!");
    return 0;
   }

#include <iostream>
#include <tuple>
#include <functional>
int add(int a, int b) {
    return a + b;
}
int main() {
    auto args = std::make_tuple(1, 2);
    int result = std::apply(add, args); // 调用add(1, 2)
    std::cout << "1 + 2 = " << result << std::endl;
    return 0;
}