# C++ 现代特性掌握从 C++11 到 C++23 的现代 C++ 功能，包括 lambda、移动语义、范围、概念和编译时评估。这项技能使您能够编写高效、富有表现力且可维护的现代 C++ 代码。 ## C++11 特性 ### 自动类型推导 `auto` 关键字启用自动类型推断，减少冗长并提高可维护性： // 传统 std::vector::iterator it = vec.begin(); std::map>::const_iterator map_it = mymap.find("key"); // 现代 C++11 自动它 = vec.begin(); auto map_it = mymap.find("key"); // 自动初始化自动值= 42； // 整数自动圆周率 = 3.14； // 双自动名称 = std::string("爱丽丝"); // std::字符串自动 lambda = [](int x) { 返回 x * 2; }; // 拉姆达类型 ### 基于范围的 For 循环容器和数组的简化迭代： std::vector 数字 = {1, 2, 3, 4, 5}; // 传统循环 for (std::vector::iterator it =numbers.begin(); it!=numbers.end(); ++it) { std::cout << *it << " "; } // 基于范围的 for (C++11) for (int num : 数字) { std::cout << num << " "; } // 使用修改元素的引用 for (int& num : 数字) { 数 *= 2; } // 使用 const 引用来提高效率 for (const auto& str : string_vector) { 进程（str）； } ### Lambda 表达式具有捕获功能的匿名函数： // 基本的 lambda 自动添加 = [](int a, int b) { return a + b; }; int 结果 = 添加(3, 4); // 7 // 带有捕获的 Lambda 整数乘数 = 10; 自动乘法 = [乘数](int x) { return x * 乘数; }; // 通过引用捕获整数计数器 = 0；自动增量 = [&counter]() { counter++; }; // 按值捕获所有内容自动 func1 = [=]() { 返回 x + y + z; }; // 通过引用捕获所有内容自动 func2 = [&]() { x++; y++； }; // 混合捕获 auto func3 = [&sum, 乘数](int x) { sum += x * 乘数; }; // 可变 lambda（可以修改捕获的值） auto mutable_func = [counter]() mutable { 返回 counter++; }; ### 智能指针使用 RAII 进行自动内存管理： #include <内存> // unique_ptr - 独占所有权 std::unique_ptr ptr1 = std::make_unique(42); std::unique_ptr obj = std::make_unique(arg1, arg2); //shared_ptr - 具有引用计数的共享所有权 std::shared_ptr ptr2 = std::make_shared(100); std::shared_ptr ptr3 = ptr2; // 引用计数 = 2 //weak_ptr - 非拥有引用 std::weak_ptr 弱 = ptr2; if (自动锁定=weak.lock()) { // 安全地使用锁定的指针 std::cout << *锁定 << std::endl; } // 自定义删除器自动删除器 = [](FILE* fp) { fclose(fp); }; std::unique_ptr file(fopen("data.txt", "r"), 删除器); ### 空指针类型安全的空指针常量： // 老方法（不明确）无效函数（int x）；无效函数（字符* ptr）；函数（空）； // 哪个重载？取决于 NULL 定义 // 现代方式（明确）函数（空指针）； // 明确调用 func(char*) // 智能指针初始化 std::unique_ptr ptr = nullptr; if (ptr != nullptr) { // 使用指针 } ## C++14 特性 ### 通用 Lambda 表达式带有“auto”参数的 Lambda 表达式： // 泛型 lambda (C++14) auto generic_add = [](auto a, auto b) { return a + b; }; int sum1 = generic_add(3, 4); // 与 int 一起使用双 sum2 = generic_add(3.14, 2.71); // 适用于双精度 std::string concat = generic_add(std::string("Hello"), std::string("World")); // 多个自动参数自动比较 = [](自动 a, 自动 b) { 返回 a < b; }; // 在算法中使用 std::vector vec = {5, 2, 8, 1, 9}; std::sort(vec.begin(), vec.end(), [](auto a, auto b) { return a > b; }); ### 返回类型推导函数的自动返回类型： // C++14: 自动返回类型推导自动乘法(int a, int b) { 返回a*b； // 返回类型推导为 int } 自动获取向量（）{ 返回 std::vector{1, 2, 3}； // 推导为 std::vector } // 多个return语句必须具有相同的类型自动条件（布尔标志）{ 如果（标志）返回42； // 整数否则返回 100； // int - 确定 //返回3.14； // 错误：类型不同 } ### 打造独特 unique_ptr 的工厂函数： // C++11需要手动构造 std::unique_ptr ptr1(new MyClass(arg1, arg2)); // C++14 提供了 std::make_unique 自动 ptr2 = std::make_unique(arg1, arg2); // 异常安全的好处 func(std::unique_ptr(new int(1)), std::unique_ptr(new int(2))); // 有风险 func(std::make_unique(1), std::make_unique(2)); // 安全 ## C++17 特性 ### 结构化绑定将对象分解为单独的变量： // 对和元组 std::pair get_data() { 返回{42，“答案”}； } auto [id, 名称] = get_data(); std::cout << id << ": " << 名称 << std::endl; // 地图 std::map 分数 = {{"Alice", 95}, {"Bob", 87}}; for (const auto& [姓名, 分数] : 分数) { std::cout << 名称 << “得分” << 得分 << std::endl; } // 数组 int arr[3] = {1,2,3}; 自动[a，b，c] = arr； // 结构体结构点 { int x, y; }; 点 p{10, 20}；自动[x，y] = p； ### 如果Constexpr 编译时条件语句：模板<类型名称 T> 自动处理（T值）{ if constexpr (std::is_integral_v) { 返回值*2； } else if constexpr (std::is_floating_point_v) { 返回值*3.14； } 否则{ 返回值； } } int 结果1 = 过程(10); // 返回 20 双结果2 = 过程(2.0); // 返回 6.28 ### 折叠表达式可变参数模板操作： // 对所有参数求和模板<类型名称...参数> 自动求和（参数...参数）{ 返回（参数+...）； } int 总计 = sum(1, 2, 3, 4, 5); // 15 // 打印所有参数模板<类型名称...参数> 无效打印（参数...参数）{ (std::cout << ... << 参数) << std::endl; } 打印（“值：”，42，“”，3.14）; // 值：42 3.14 // 逻辑运算模板<类型名称...参数> 布尔 all_true(参数... 参数) { 返回（... && 参数）； } 布尔结果 = all_true(true, true, false); // 假 ### 标准::可选类型安全的可选值： #include <可选> std::optional find_value(const std::vector& vec, int target) { auto it = std::find(vec.begin(), vec.end(), target); if (it != vec.end()) { 返回*它； } 返回 std::nullopt; } // 用法 std::vector 数字 = {1, 2, 3, 4, 5}; if (自动结果 = find_value(数字, 3)) { std::cout << "找到：" << *结果 << std::endl; } 否则{ std::cout << "未找到" << std::endl; } // Value_or 默认值 int value = find_value(numbers, 10).value_or(-1); ### 标准::变体类型安全联合： #include <变体> std::variant 数据；数据 = 42；数据=3.14；数据 = std::string("你好"); // 访问模式 std::visit([](auto&& arg) { 使用 T = std::decay_t; if constexpr (std::is_same_v) { std::cout << "int:" << arg << std::endl; } else if constexpr (std::is_same_v) { std::cout << "双精度:" << arg << std::endl; } 否则{ std::cout << "字符串：" << arg << std::endl; } }，数据）； // 获取值 if (auto* str = std::get_if(&data)) { std::cout << *str << std::endl; } ## C++20 特性 ### 概念约束模板参数： #include <概念> // 定义一个概念模板<类型名称 T> 概念 Numeric = std::is_arithmetic_v; // 使用概念来约束模板模板<数字 T> T 添加(T a, T b) { 返回a+b； } // 带有requires子句的概念模板<类型名称 T> 概念 Hashable = 需要(T a) { { std::hash{}(a) } -> std::convertible_to; }; // 多重约束模板<类型名称 T> 概念 Sortable = std::copyable && 需要(T a, T b) { { a < b } -> std::convertible_to; }; // 在函数中使用模板<可排序 T> void sort_data(std::vector& vec) { std::sort(vec.begin(), vec.end()); } ### 范围可组合的算法和视图： #include <范围> std::vector 数字 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 使用视图进行过滤和转换自动结果 = 数字 | std::views::filter([](int n) { return n % 2 == 0; }) | std::views::transform([](int n) { return n * n; }); for (int n : 结果) { std::cout << n << " "; // 4 16 36 64 100 } // 取前N个元素自动第一个五=数字| std::views::take(5); // 反向视图自动反转 = 数字 | std::视图::反向； // 链接多个操作自动complex_view = 数字 | std::views::filter([](int n) { return n > 3; }) | std::views::transform([](int n) { return n * 2; }) | std::views::take(3); ### 协程协作多任务处理： #include <协程> #include // 简单的生成器结构生成器{ 结构promise_type { int 当前值；生成器 get_return_object() { 返回生成器{std::coroutine_handle::from_promise(*this)}; } std::suspend_always 初始挂起() { 返回 {}; } std::Suspend_always Final_Suspend() noException { 返回 {}; } std::suspend_always yield_value(int value) { 当前值=值；返回 {}; } 无效 return_void() {} 无效未处理的异常（）{} }; std::coroutine_handle 句柄；生成器（std::coroutine_handle h）：句柄（h）{} 〜Generator（）{ if（句柄）handle.destroy（）; } int value() { return handle.promise().current_value; } } 布尔下一个（）{ 处理.resume(); return !handle.done(); } }; 生成器计数器(int start, int end) { for (int i = 开始; i < 结束; ++i) { co_yield i； } } // 用法自动生成 = 计数器(0, 5); while (gen.next()) { std::cout << gen.value() << " "; } ### 三向比较（宇宙飞船操作员）简化的比较运算符： #include <比较> 结构点{ int x, y; // 单个运算符生成所有六个比较运算符 auto 运算符<=>(const Point& other) const = default; }; 点 p1{1, 2}; 点 p2{1, 3}; 布尔 eq = (p1 == p2); // 假布尔 lt = (p1 < p2); // 正确布尔gt = (p1 > p2); // 假 // 自定义飞船操作符结构人{ std::字符串名称；年龄；自动运算符<=>(const Person& other) const { if (自动 cmp = 名称 <=> other.name; cmp != 0) 返回CMP；返回年龄 <=> other.age; } }; ## C++23 功能预览 ### 标准::预期无异常的错误处理： #include <预期> std::expected 除(int a, int b) { 如果（b==0）{ return std::unexpected("除以零"); } 返回a/b； } // 用法自动结果 = 除(10, 2); 如果（结果）{ std::cout << "Result: " << *result << std::endl; } 否则{ std::cout << "错误：" << result.error() << std::endl; } // 转换和错误处理自动变换 = 除(20, 4) .transform([](int x) { 返回 x * 2; }) .or_else([](自动错误) { std::cout << "错误：" << 错误 << std::endl; 返回 std::expected(0); }); ### If 带有初始化器增强 // C++23: if 具有模式匹配改进 std::map map = {{1, "一"}, {2, "二"}}; if (auto [it, 插入] = map.insert({3, "三"}); 插入) { std::cout << "插入：" << it->第二 << std::endl; } // 增强的 static constexpr if 模板<类型名称 T> void process(T值) { if constexpr (需要 { value.size(); }) { std::cout << "大小：" << value.size() << std::endl; } } ## 移动语义 ### 右值参考类缓冲区{ 字符*数据； size_t 尺寸；公众： // 构造函数缓冲区（size_t s）：大小，数据（新字符[s]）{} // 复制构造函数 Buffer(const Buffer& other) : size(other.size), data(new char[size]) { std::copy(other.data, other.data + size, data); } // 移动构造函数 Buffer(Buffer&& other) noexcept : size(other.size), data(other.data) { 其他.data = nullptr; 其他.大小 = 0; } // 复制赋值缓冲区&运算符=（常量缓冲区&其他）{ 如果（这个！=＆其他）{ 删除[]数据；大小=其他.大小；数据=新的字符[大小]； std::copy(other.data, other.data + size, data); } 返回*这个； } // 移动赋值缓冲区&运算符=(缓冲区&&其他) noexcept { 如果（这个！=＆其他）{ 删除[]数据；数据=其他.数据；大小=其他.大小；其他.data = nullptr; 其他.大小 = 0; } 返回*这个； } ~Buffer() { 删除[]数据; } }; ### Std::move 和完美转发 #include <实用程序> // 使用 std::move std::vector vec1 = {1, 2, 3, 4, 5}; std::vector vec2 = std::move(vec1); // vec1 现在为空 // 完美转发模板<类型名称 T> 无效包装器（T&& arg）{ // 转发参数保留其值类别过程(std::forward(arg)); } // 完美转发的工厂函数模板<类型名称 T，类型名称...参数> std::unique_ptr make_unique_custom(Args&&... args) { 返回 std::unique_ptr(new T(std::forward(args)...)); } // Emplace 方法使用完美转发 std::vector> vec; vec.emplace_back(1, "一"); // 就地构造 ## Lambda 高级功能 ### 递归 Lambda 表达式 // C++14 及更高版本自动斐波那契 = [](int n) { auto impl = [](int n, auto& self) -> int { 如果（n <= 1）返回n；返回自我（n-1，自我）+自我（n-2，自我）； }; 返回 impl(n, impl); }; // C++23：推导这个 auto fibonacci_cpp23 = [](this auto self, int n) -> int { 如果（n <= 1）返回n；返回自我（n-1）+自我（n-2）； }; ### 初始化捕获 (C++14) // 捕获中的仅移动类型自动 ptr = std::make_unique(42); 自动 lambda = [p = std::move(ptr)]() { std::cout << *p << std::endl; }; // 在捕获中初始化新变量自动 lambda2 = [值 = 计算昂贵值（）]（）{ 返回值*2； }; // 多个初始化捕获自动 lambda3 = [x = getValue(), y = getOtherValue()]() { 返回 x + y； }; ## 编译时评估 ### 常量表达式函数 // C++11 constexpr（有限） constexpr int Factorial_cpp11(int n) { 返回 (n <= 1) ? 1：n*factorial_cpp11(n-1)； } // C++14 constexpr (更强大) constexpr int 阶乘(int n) { 整数结果 = 1； for (int i = 2; i <= n; ++i) { 结果*=我； } 返回结果； } constexpr int 值 = 阶乘(5); // 编译时计算 // C++20 constexpr 与 std::vector constexpr 自动compute_primes(int max) { std::vector 素数； for (int i = 2; i < max; ++i) { 布尔 is_prime = true; for (int p : 素数) { 如果（i％p==0）{ is_prime = false; 休息; } } if (is_prime) primes.push_back(i); } 返回素数； } ### 保守 (C++20) 必须在编译时评估的函数： consteval int square(int n) { 返回 n * n； } constexpr int value1 = square(5); // 好的：编译时 // int x = 5; // int value2 = square(x); // 错误：必须是编译时 // 使用 constexpr 进行 consteval constexpr int Maybe_compile_time(int n) { if (std::is_constant_evaluated()) { 返回 n * n； } 否则{ 返回 n + n； } } ## 最佳实践 1. **对于复杂类型首选 auto** ：使用 `auto` 来避免冗长的类型声明，特别是对于迭代器和 lambda 2. **尽可能使用基于范围的 for** ：比传统循环更清晰的意图并且更不容易出错 3. **对于简单操作更喜欢 lambda** ：特别是在像 `std::transform` 和 `std::for_each` 这样的算法调用中 4. **使用智能指针获得所有权** ：对于拥有的资源，优先使用`unique_ptr`和`shared_ptr`而不是原始指针 5. **拥抱移动语义**：为资源拥有类型实现移动构造函数/赋值 6. **使用结构化绑定**：在使用对、元组和映射时使代码更具可读性 7. **优先使用 std::Optional 而不是特殊值** ：使用 `std::Optional` 而不是像 -1 或 nullptr 这样的哨兵值 8. **使用概念来约束模板（C++20）**：使模板错误更清晰并记录需求 9. **利用范围和视图 (C++20)**：比传统算法更可组合、更高效 10. **使用 constexpr 进行编译时计算** ：尽可能将计算移至编译时以获得更好的性能 ## 常见陷阱 1. **带有 auto 的悬空引用**：`auto&` 可以创建对临时对象的悬空引用 2. **在 lambda 中通过引用捕获**：引用捕获的寿命可能比捕获的变量长 3. **从 const 对象移动** : const 对象上的 `std::move` 实际上并没有移动 4. **默认捕获[=]或[&]**：可能会意外捕获超出预期的数量 5. **忘记标记移动操作 noexcept** ：阻止容器中的某些优化 6. **使用对象后使用 std::move** ：移出的对象处于有效但未指定的状态 7. **Range-based for with temporaries** ：容器临时对象在循环体之前销毁 8. **可选值访问而不检查**：使用`*`或`value()`而不验证`has_value()` 9. **未经检查的变量访问**：如果类型错误，`std::get` 会抛出异常；使用“get_if”或访问者 10. **过度使用auto** ：可以隐藏重要的类型信息；明智地使用 ## 何时使用在以下情况下使用此技能： * 使用现代 C++ 代码库（C++11 及更高版本） * 重构遗留代码以使用现代功能 * 使用RAII实现资源管理 * 使用模板和 lambda 编写通用代码 * 通过移动语义优化性能 * 实现类型安全的可选或变体类型 * 使用范围和函数式算法 * 创建编译时计算值 * 应用概念来约束模板 * 学习或教授现代 C++ 实践 ## 资源 * [C++ 参考 - Lambda]() * [C++ 参考 - 自动]() * [C++ 参考 - 基于范围的 for]() * [C++ 参考 - 智能指针]() * [C++ 参考 - 移动语义]() * [C++ 参考 - 结构化绑定]() * [C++ 参考 - 可选]() * [C++ 参考 - 变体]() * [C++ 参考 - 概念]() * [C++ 参考 - 范围]() * [C++ 参考 - 协程]() * [C++ 参考 - Constexpr]()

Cpp 现代功能

包含技能