C++20新特征的一些总结

于 2024-08-14 15:14:22 发布
阅读量1.1k 收藏 31
点赞数 25
文章标签： c++20
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50508006/article/details/141191259
版权

C++20 是 C++ 语言发展中的一个重要里程碑，引入了众多新特性，这些特性不仅提升了语言的功能性和性能，还极大地简化了许多编程任务。以下将详细介绍 C++20 的一些关键新特性，包括语法和实际使用示例。

1.Ranges 库

1.1. 概述

Ranges 库是对标准模板库（STL）的一个重要扩展。它重新定义了容器和算法的交互方式，使代码更具可读性和表达力。Ranges 库的设计目标是减少代码中复杂的迭代器操作，使程序员能够以声明式风格操作序列数据。

1.2. 核心组件

views：提供视图（views）以惰性评估（lazy evaluation）的方式对序列进行操作。
actions：用于直接修改序列的内容，类似于视图，但是立即执行的。
adaptors：可以将多个视图组合在一起，例如 filter 和 transform。

1.3. 使用示例

#include <iostream>
#include <ranges>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9};

    // 使用 ranges 进行惰性计算：过滤和变换
    auto even_squares = numbers
                        | std::views::filter([](int n) { return n % 2 == 0; })
                        | std::views::transform([](int n) { return n * n; });

    // 遍历输出结果
    for (int n : even_squares) {
        std::cout << n << " "; // 输出：4 16 36 64
    }
}

分析：
views::filter：过滤序列中的元素，仅保留符合条件的元素。
views::transform：将保留的元素进行转换操作，在这里进行了平方运算。
惰性计算：此操作不会立即对所有元素进行过滤和转换，只有在访问元素时才会计算结果，节省了不必要的开销。

2. 三向比较运算符（<=>）

2.1. 概述

三向比较运算符，俗称“太空飞船运算符”（<=>），是 C++20 引入的一种新型比较运算符。它简化了多重比较运算的实现过程，自动生成 ==、!=、<、<=、>、>= 等运算符。

2.2. 使用示例

#include <iostream>
#include <compare>

struct Point {
    int x, y;

    // 自动生成所有比较运算符
    auto operator<=>(const Point&) const = default;
};

int main() {
    Point p1 = {1, 2};
    Point p2 = {1, 3};

    if (p1 < p2) {
        std::cout << "p1 is less than p2\n";
    }

    if (p1 != p2) {
        std::cout << "p1 is not equal to p2\n";
    }
}

输出：

p1 is less than p2
p1 is not equal to p2

分析：
<=> 运算符：在结构体 Point 中引入此运算符后，编译器会自动生成所有比较运算符的实现，减少了代码冗余。
默认实现：通过 = default 关键字，编译器将生成默认的三向比较逻辑。

3. Coroutines（协程）

3.1. 概述

协程是一种特殊的函数，允许在执行过程中暂停并在稍后恢复。C++20 原生支持协程，使异步编程和生成器的实现更加简洁和高效。与传统的多线程不同，协程通过协作式多任务处理减少了上下文切换的开销。

3.2. 核心组件

co_await：用于等待异步操作的完成。
co_yield：用于生成一个值并暂停协程。
co_return：用于返回结果并结束协程。

3.3. 使用示例

#include <iostream>
#include <coroutine>

struct Generator {
    struct promise_type {
        int current_value;

        auto get_return_object() {
            return Generator{ std::coroutine_handle<promise_type>::from_promise(*this) };
        }
        auto initial_suspend() { return std::suspend_always{}; }
        auto final_suspend() noexcept { return std::suspend_always{}; }
        auto yield_value(int value) {
            current_value = value;
            return std::suspend_always{};
        }
        void return_void() {}
        void unhandled_exception() { std::exit(1); }
    };

    std::coroutine_handle<promise_type> handle;

    Generator(std::coroutine_handle<promise_type> h) : handle(h) {}
    ~Generator() { handle.destroy(); }

    bool next() {
        handle.resume();
        return not handle.done();
    }

    int value() const { return handle.promise().current_value; }
};

Generator counter(int n) {
    for (int i = 1; i <= n; ++i) {
        co_yield i;
    }
}

int main() {
    auto gen = counter(5);
    while (gen.next()) {
        std::cout << gen.value() << " ";
    }
}

输出：

1 2 3 4 5

分析：

co_yield：在每次循环中，co_yield 会暂停协程并返回当前值，直到协程被再次恢复。
promise_type：定义了协程的行为，包括如何暂停和恢复，以及如何处理返回值和异常。
std::coroutine_handle：用于控制协程的执行，如恢复、销毁等。

4. Concepts（概念）

4.1. 概述

Concepts 是 C++20 引入的一种用于约束模板参数的新特性。Concepts 通过编译时检查，确保模板参数满足某些条件，从而使模板代码更加安全和易于调试。它是 C++ 模板编程的重要增强，使得模板的使用更加简洁和清晰。

4.2. 核心组件

概念定义：通过 concept 关键字定义概念，可以用来约束模板参数。
约束模板参数：使用概念来限制模板参数的类型或行为。

4.3. 使用示例

#include <iostream>
#include <concepts>

// 定义一个概念
template<typename T>
concept Integral = std::is_integral_v<T>;

template<Integral T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(1, 2) << std::endl;    // 正常编译
    // std::cout << add(1.0, 2.0) << std::endl;  // 编译错误
}

分析：
Integral 概念：通过 std::is_integral_v 定义，确保模板参数 T 是整型。
概念约束：add 函数只能接受符合 Integral 概念的类型作为模板参数。如果尝试传递不符合条件的类型（如浮点数），编译器会给出清晰的错误信息。

5. 模块（Modules）

5.1. 概述

模块是 C++20 中引入的一种全新的代码组织方式，用于替代传统的头文件。模块提供了一种更加现代和高效的方式来管理项目的依赖关系，减少编译时间，并通过清晰的接口定义提高代码的可维护性。

5.2. 模块的定义和导入

模块定义：使用 export module 关键字定义模块。
模块导入：使用 import 关键字导入模块。

5.3. 使用示例

定义模块（math.ixx 文件）：

// math.ixx
export module math;

export int add(int a, int b) {
    return a + b;
}

使用模块：

import math;

int main() {
    int result = add(2, 3);
    std::cout << result << std::endl;  // 输出: 5
}

分析：
模块化设计：模块将接口与实现分离，使得代码更易管理，同时避免了传统头文件中可能存在的多次定义问题。
编译优化：模块只需编译一次，能够显著减少大型项目的编译时间。

6. constexpr 动态内存分配

6.1. 概述

C++20 扩展了 constexpr 的功能，使其可以在编译时进行动态内存分配。这一特性增强了编译时计算的能力，允许开发者在编译期构建复杂的数据结构。

6.2. 使用示例

#include <iostream>

constexpr int* create_array(int size) {
    return new int[size];  // 允许在 constexpr 函数中使用动态分配
}

constexpr int array_sum(int* arr, int size) {
    int sum = 0;
    for (int i = 0; i < size; ++i) {
        sum += arr[i];
    }
    return sum;
}

int main() {
    constexpr int size = 5;
    constexpr int* arr = create_array(size);
    for (int i = 0; i < size; ++i) {
        arr[i] = i + 1;
    }

    constexpr int sum = array_sum(arr, size);
    std::cout << "Sum: " << sum << std::endl;  // 输出: Sum: 15

    delete[] arr;
}

分析：
编译时内存分配：create_array 函数在编译期分配内存，并将结果作为 constexpr 值。
编译时计算：array_sum 函数在编译期计算数组元素的和，极大地提高了代码的执行效率。

7. std::span

7.1. 概述

std::span 是一个轻量级的视图类型，表示一段连续内存的子集。它类似于指针和数组，但更安全、更易用。std::span 提供了与数组或容器类似的接口，但不负责管理内存，因此可以用于多个不同的数据源。

7.2. 使用示例

#include <iostream>
#include <span>
#include <vector>

void print_span(std::span<int> s) {
    for (int n : s) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    std::vector<int> vec = {6, 7, 8, 9, 10};

    print_span(arr);  // 使用数组初始化 std::span
    print_span(vec);  // 使用 vector 初始化 std::span
}

输出：

1 2 3 4 5 
6 7 8 9 10

分析：
安全性：std::span 提供了类似指针的接口，但不会产生指针的安全问题（如越界访问）。
灵活性：std::span 可以用于数组、std::vector 等不同的数据结构，而无需拷贝数据。

8. constinit 关键字

8.1. 概述

constinit 关键字用于保证变量在程序启动时是静态初始化的。与 constexpr 和 const 关键字不同，constinit 用于确保变量在编译期是静态初始化的，避免在多线程环境中可能发生的重复初始化问题。

8.2. 使用示例

#include <iostream>

constinit int x = 42;

int main() {
    std::cout << x << std::endl;  // 输出: 42
}

分析：
静态初始化保证：constinit 确保变量在程序启动时被静态初始化，从而避免了在多线程环境中可能出现的重复初始化问题。
编译期检查：如果 constinit 变量没有被静态初始化，编译器会给出错误提示。

9. Lambda 表达式的增强

9.1. 概述

C++20 对 Lambda 表达式进行了若干增强，使其更加灵活和强大。主要包括捕获列表中的 this 和模板 Lambda。

9.2. 使用示例

模板 Lambda：

#include <iostream>
#include <vector>

int main() {
    auto add = [](auto a, auto b) { return a + b; };

    std::cout << add(1, 2) << std::endl;      // 输出: 3
    std::cout << add(1.5, 2.3) << std::endl;  // 输出: 3.8
}

捕获 this：

#include <iostream>

struct S {
    int value = 42;

    void print() {
        auto lambda = [*this] { std::cout << value << std::endl; };
        lambda();
    }
};

int main() {
    S s;
    s.print();  // 输出: 42
}

分析：
模板 Lambda：允许 Lambda 表达式接受不同类型的参数，极大地增强了 Lambda 的通用性。
捕获 this：使用 [*this] 捕获当前对象的拷贝，而不是引用，避免了 Lambda 中出现悬空引用的问题。

10. std::jthread

10.1. 概述

std::jthread 是 C++20 引入的新线程类，它与 std::thread 类似，但自动管理线程的生命周期。std::jthread 提供了一种更安全的方式来处理线程，当 std::jthread 对象销毁时，它会自动加入（join）线程。

10.2. 使用示例

#include <iostream>
#include <thread>
#include <chrono>

void task() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Task finished\n";
}

int main() {
    std::jthread t(task);  // std::jthread 会自动管理线程的生命周期
    std::cout << "Main thread\n";
}  // t 作用域结束时自动 join

输出：

Main thread
Task finished

分析：
生命周期管理：std::jthread 在作用域结束时自动调用 join，避免了可能导致程序崩溃的未 join 线程。
可取消性：std::jthread 还支持通过传递 stop_token 来取消正在执行的线程操作。

总结

C++20 是 C++ 标准的一次重大升级，它引入了诸如 Ranges 库、协程、概念、模块和三向比较运算符等众多新特性。这些特性极大地增强了语言的表达能力，使代码更简洁、更高效、更易于维护。通过合理利用这些新特性，开发者可以编写出更具现代感的 C++ 代码，同时提高程序的性能和安全性。

阿狸最厉害
关注
【2024最新版】PCL点云处理算法汇总（C++长期更新版）
点云侠的博客
02-27 57万+
PCL学习目录。博客长期更新，最近一次更新时间为：2024年9月4日。
c++基础知识总结
m0_72582315的博客
10-09 1709
1.浅谈一下c和c++的理解？c语言是一个面向过程的一种语言、c++是一种面向对象的一种语言面向过程：就是按部就班一步一步来，想到每一个步骤需要调用什么函数，按照顺序调用函数。面向对象：就是把问题分解成一个个对象，而对象不是为了解决某一个步骤，而是为了描述事物在解决过程中的行为。2.指针和引用的区别？3.值传递、地址传递、引用传递的区别？值传递：实参把值传递给形参、与原来的实参就没有关系、相当于产生了一个新变量、一个新的地址。地址传递：形参的改变会影响实参，会创建一个指针变量开辟一个新空间，指针保存着实参的
C++高级编程（2）-- 深入C++20新特性
m0_51768024的博客
03-11 908
C++20，作为C++标准的最新迭代，为我们带来了一系列激动人心的新特性。这些特性不仅提高了开发效率、增强了代码安全性，而且让代码更加简洁易读。接下来，让我们深入了解C++20的一些关键新特性，并且探讨它们的高级用法和示例代码。
【C++知识点】C++20 常用新特性总结
Newin2020的博客
03-13 2299
📣专栏定位：整理一下 C++ 相关的知识点，供大家学习参考~🎏唠叨唠叨：在这个专栏里我会整理一些琐碎的 C++ 知识点，方便大家作为字典查询~
探索C++20高级编程：新特性、技巧与性能优化
努力是为了站在万人之中，成为别人的光
04-24 1万+
全书共10章，分别为：类型与对象、编译时多态、概念约束、元编程介绍、模板元编程、constexpr元编程、Ranges标准库、协程、模块、综合运用。其中C++20的四大特性独立成章，一些小的特性则贯穿于全书，其他章节则探讨了面向对象、元编程、函数式编程、并发编程等话题。作为一本讲解C++高级编程的书，本书还探讨了很多元编程话题，这是作为库开发必不可少的技能，它们也将随着C++的演进而不断演进，大大提升库开发者的编程体验，尤其是近年来C++的标准提案经历了从模板元编程向constexpr元编程转换的过程。
C++20新特性.pdf
06-26
这是C++20新特性英文文档，基本涵盖了C++20的所有新特性。在这里提供给大家一起学习、研究，借此机会推广C++。
现代C++编程：C++ 20新特性总结
C/C++Linux、音视频、DPDK
06-11 2581
概念是一种用于描述模板参数必须满足的条件或特性的机制。它们可以看作是模板参数的“类型约束”，让编译器在模板实例化时能够提前验证这些约束，从而提供更明确的错误提示和更强的编译时保障。协程是通过在函数返回类型前面添加co_awaitco_yield或co_return关键字来定义的。// 对范围进行一系列操作: 过滤、变换、排序和反转}) // 只保留偶数}) // 每个数值乘以3// 反转顺序// 打印结果return 0;
C++20新特性概览
weixin_43820463的博客
11-07 1万+
文章目录C++20概览C++20的重要性侧面说明：正面说明：模块(Modules)优点例子创建模块引用模块范围库(Ranges)Ranges 是什么 ?好处:相关概念例子概念库(Concepts)作用C++20以前C++20之后例子协程(Coroutines)协程概念相关关键字用处生成器并发库(Concurrency)原子智能指针智能指针(shared_ptr)线程安全吗?如何将智能指针变成线程安全?自动合并, 可中断的线程示例同步库(Synchronization)信号量(Semaphore)锁存器(La
C++ 20 新特性简介
Tyler_Zx的博客
08-21 5611
本篇介绍的内容源自于 C++ 之父 Bjarne Stroustrup 的论文——HOPL4 。HOPL 是 History of Programming Languages（编程语言历史）的缩写，是 ACM（Association of Computing Machines，国际计算机协会）旗下的一个会议，Bjarne 的这篇论文是他为 2021 年 HOPL IV 会议准备的。这篇 HOPL4 论文尤其重要，因为它涵盖了 C++98 之后的所有 C++ 版本，从 C++11 直到 C++20。论文中有许
c++20新特性
最新发布
m0_60697583的博客
07-15 546
包括对并发编程的支持（例如std::jthread）、对日期和时间处理的增强（std::chrono）以及其他一些新的容器和算法。这些改进使得lambda表达式在C++20中变得更加强大和灵活，能够处理更多种类的编程任务，并提供更高的表达能力和性能。这简化了对集合的操作，例如使用范围for循环来处理数据。通过operator运算符，C++20引入了一种标准的方法来定义类型的三路比较，这简化了自定义类型的比较操作。C++20引入了更灵活和一致的初始化语法，包括聚合初始化的扩展和类类型的默认成员初始化。
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++20新特性—range（二）
guxch的专栏
01-28 2013
6.view view是一种range，它具有固定的拷贝、移动和赋值时间，正如名称所示，view是“视图”(引用)，它本身不保存数据，因而可以保证复制等操作的等时间性。view一个重要的特征是“lazy evaluation”，即它在被定义的时候，仅将各种参数准备好，并没有运算，只有需要结果的时候，它才开始进行运算，得到结果。这个特性与数据库中的视图概念是一致的。 下面的示例说明了“lazy evaluation”的特性。 std::vector<int> ints{0,1,2,
C++基础知识总结（详解）
weixin_44404541的博客
04-12 2331
C++超详细基础知识，有代码演示 一篇就包含C++的所有知识
C++ 20新特性
Tyler_Zx的博客
07-17 6250
目录 Concepts Ranges Modules Coroutines(协程) Reflection 总结 前言 本文主体内容源自公众号 CSDN（ID：CSDNnews），作者：祁宇 本文将只评论大部分确定要加入和可能加入到 C++20 的重要特性，让读者对 C++ 的未来和演进趋势有一个基本的了解。这篇文章创作时间较早，所以一些内容和今年发布的 C++20 具体实现有些许不同。 C++20 中可能增加哪些重要特性，下面这个图可以提供一个参考： 下面是本文将评论的..
c++20新特性概述
首席技术总监的专栏
02-08 272
Concepts 让 C++ 的模版程序的编写变得更简单和容易理解； Ranges 让我们使用 STL 容器和算法更加简单，并且更容易组合算法及延迟计算； Modules 帮助我们大大加快编译速度，同时弥补了 C++ 使用库和缺乏包管理的缺陷； Coroutines 帮助我们简化异步程序的编写； Reflection 给我们提供强大的编译期 AST 元数据查询能力； ...
C++20的这些新特性，你都知道吗？
凌桓丶的博客
04-28 3347
C++20的这些新特性，你都知道吗？
C++20的四大新特性
首席技术总监的专栏
02-09 2466
C++20（C++ 编程语言标准 2020 版）将是 C++ 语言一次非常重大的更新，将为这门语言引入大量新特性。近日，C++ 开发者 Rainer Grimm 正通过一系列博客文章介绍 C++20 的新特性。目前这个系列文章已经更新了两篇，本篇是第一篇，主要介绍了 C++20 的 Big Four（四大新特性：概念、范围、协程和模块）以及核心语言（包括一些新的运算符和指示符）。 C++20 的编译器支持 适应新特性的最简单方法是试用它们。那么接下来我们就面临着这个问题：哪些编译器支持 C++20 的哪
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值