C++20新增特性

C++ core feature!

cplusplus语言特性

新增关键字

  • concept
  • requires
  • constinit
  • consteval
  • co_await
  • co_return
  • co_yield
  • char8_t

模块

优点:

  1. 没有头文件;
  2. 声明实现仍然可分离,但非必要;
  3. 可以显式指定导出哪些类或函数;
  4. 不需头文件重复引入宏;
  5. 模块之间名称可以相同,并且不会冲突;
  6. 模块只处理一次,编译会更快(头文件每次引入都需要处理);
  7. 预处理宏只在模块内有效;
  8. 模块的引入与引入顺序无关;

Module Code

// export entirety
export namespace Test {
    auto GetTestString() {
        return "Welcome to C++20!";
    }
    
    template<typename T>
    T Sum(T t)
    {
        return t;
    }
    
    template<typename T, typename ...Args>
    T Sum(T t, Args ...args)
    {
        return t + Sum<T>(args...);
    }
    
    enum class ValueType : uint8_t {
        Bool = 0,
        Char,
        Int,
        Float,
        Double,
    };
    
    template<typename T>
    T GetType(ValueType type) {
        switch (type)
        {
            using enum ValueType;
            case Bool:
                return true;
            case Char:
                return 'A';
            case Int:
                return 10;
            case Float:
                return 3.1415926;
            case Double:
                return 0.3333333;
        }
        return true;
    }
}; // namespace Test

// export struct
export namespace StructTest {
    struct Grade {
        int val{0};
        int level{3};
    };

    void AddValue(Grade &g, int num) {
        g.val += num;
        g.level += num;
    }
};

// common export
export auto GetCommonString()
{
    return "Welcome to learn C++20!";
}

// export module x.y.z
export module cpp20.test;

Main Code

import cpp20.test;

int main()
{
    auto ret1 = GetCommonString();
    using namespace Test;
    auto ret3 = GetTestString();
    auto ret4 = Sum<int>(3, 4);
    auto ret5 = Sum<double>(3.14, 0.5, 0.125);
    
    auto ret6 = GetType<bool>(ValueType::Bool);
    auto ret7 = GetType<int>(ValueType::Int);
    auto ret8 = GetType<char>(ValueType::Char);
    
    StructTest::Grade grade;
    StructTest::AddValue(grade, 10);
    std::cout << grade.val << " | " << grade.level << std::endl;
    return 0;
}

Lambda表达式

  1. 允许[=, this]作为lambda捕获,并弃用隐式捕获[=];
  2. lambda init-capture中的包扩展:[...args = std::move(args)] { ... };
  3. static,thread_local,和lambda捕获结构化绑定;
  4. 模板形式的lambda;

模板形式的lambda表达式

// before c++20 获取元素的类型
auto fun = [](auto vec) {
    using T = typename decltype(vec)::value_type;
};

// C++20
auto fun = []<typename T>(vector<T> vec) {
    //...
};

lambda表达式捕获支持打包展开

// Before C++20
template<class F, class... Args>
auto DelayInvoke(F f, Args... args) {
    return [f, args...]() {
        return std::invoke(f, args...);
    };
}

// C++20
template<class F, class... Args>
auto DelayInvoke(F f, Args... args) {
    return [f = std::move(f), args = std::move(args)...]() {
        return std::invoke(f, args...);
    };
}

概念(Concepts)

C++20 最重要的新特性。一个 concept 是对”模板实参需要满足什么”的可编译断言,替代了 C++11 enable_if/SFINAE 的迂回写法。核心收益是错得清楚:不满足时编译器直接指出”哪个约束没过”,而不是一长串模板实例化错误。

概念的定义与使用

template <typename T>
concept Integral = std::is_integral_v<T>;

template <Integral T>        // 用作模板约束
T add(T a, T b) { return a + b; }

Integral auto x = add(1, 2); // 缩写形式:直接以类型为概念

add(1.0, 2.0);   // 编译错误:Integral 约束不满足(C++11 只会给出一堆元错误)

requires 子句与 requires 表达式

requires 有两种用法:requires 子句挂在模板后声明约束;requires 表达式在约束里检查”这个类型能不能这样用”。

template <typename T>
concept Addable = requires(T a, T b) {
    a + b;                          // 要求表达式合法
    std::is_integral_v<T>;          // 要求恒真
};

template <typename T> requires Addable<T>   // requires 子句
T f(T a, T b) { return a * b; }

多约束组合(&& 与 ||)

template <typename T>
concept Number = std::is_integral_v<T> || std::is_floating_point_v<T>;

template <typename T>
concept Hashable = requires(T a) {
    { std::hash<T>{}(a) } -> std::same_as<std::size_t>;   // 还能约束表达式类型
};

三路比较运算符 <=>(宇宙飞船)

写一个 operator<=> 就自动获得 <、<=、>、>=、== 的全部推导,通常写成 = default 即可。返回类型分三档:std::strong_ordering(位相等)、std::weak_ordering(值相等)、std::partial_ordering(可能有 NaN)。

struct Point {
    int x, y;
    auto operator<=>(const Point&) const = default;   // 一行生成全部比较运算符
};

Point a{1, 2}, b{1, 3};
a < b;    // true
a == b;   // false(`= default` 的 `<=>` 在成员都可比时还会隐式生成 ==)

范围(Ranges)

std::ranges 把”容器”作为一等公民——算法不需要传 iterator 对,而是直接传整个容器,并支持管道组合。

std::vector<int> v{4, 1, 3, 2};

std::ranges::sort(v);                    // 不再写 sort(v.begin(), v.end())
auto m = std::ranges::max_element(v);

// 视图:惰性、可组合,一行画出"取偶数 → ×3 → 倒序"的管道
auto out = v
    | std::views::filter([](int i) { return i % 2 == 0; })
    | std::views::transform([](int i) { return i * 3; })
    | std::views::reverse;

坑:views 是惰性的、不持有元素,底层容器失效(sort/realloc)会让 view 悬空。

协程(Coroutines)

co_await / co_yield / co_return 让函数可以挂起恢复,编译器自动生成状态机。标准库只提供机器层(coroutine_traits 等),日常需要自己写或者引用第三方封装(如 cppcoro、asio 的 awaitable)。

Generator<int> gen() {
    for (int i = 0;; ++i)
        co_yield i;       // 挂起并交出值(Generator 为用户态/第三方封装)
}

auto g = gen();
g.next();    // 取出下一个值

三大件:

  1. co_yield v;:产出值并暂停(生成器);
  2. co_return v;:结束协程;
  3. co_await expr;:等待可挂起的表达式(异步 IO 的抓手)。

指定初始化器

支持 .成员 = 值,配合聚合类型能写出”自文档化”的结构体:

struct User { std::string name; int age; bool active; };

User u{ .name = "Knight", .age = 30, .active = true };

constexpr 增强

  1. virtual 函数与 new/delete(constexpr 动态分配)可在 constexpr 出现;
  2. std::is_constant_evaluated() 区分编译期/运行期上下文;
  3. std::vector、std::string、std::variant、tuple 等一大批标准库组件进了 constexpr 版图。
constexpr int sq(int n) {
    if (std::is_constant_evaluated()) {   // 编译期分支
        return n * n;
    } else {                              // 运行期分支(可走缓存/查表等)
        return n * n + 1;
    }
}

日历与时区(chrono)

std::chrono 引入了基于 year / month / day 的日历类型与时区库,日期计算不再手撕:

using namespace std::chrono;

auto d1 = 2023y / February / 17d;        // year_month_day
auto d2 = year(2023) / month(2) / day(17);

auto day_streak = sys_days{d2} - sys_days{d1};   // 日历日运算
auto in_shanghai = zoned_time(current_zone(), system_clock::now());

std::format

Python 风格的格式化库,类型安全、与 {} 占位符配合:

std::string s = std::format("{0}{1}{0}", "abra", "cad");
std::string f = std::format("{:>8.2f}", 12.345);   // "   12.35"

由 fmt 库(Victor Zverovich,提议 P0645)促成标准化,早期实现常见 fmt::format。

其他常用组件

  • std::span:无所有权、连续内存的轻量视图(指针+长度的对象化封装),替代 T* + len 的函数参数;
  • std::source_location:内建 __LINE__/__FILE__ 的对象化版本;
  • [[likely]] / [[unlikely]]:分支预测提示;
  • std::jthread:析构自动 join 且支持协作取消;
  • std::atomic<T>::wait / notify_* 与 semaphore / latch / barrier:并发原语补齐;
  • std::erase_if、string::starts_with / ends_with、std::midpoint、std::lerp;
  • 位运算头文件 <bit>:std::bit_cast、popcount、has_single_bit 等。