C++20新增特性
收录于 Cplusplus 浏览量
cplusplus语言特性
新增关键字
- concept
- requires
- constinit
- consteval
- co_await
- co_return
- co_yield
- char8_t
模块
优点:
- 没有头文件;
- 声明实现仍然可分离,但非必要;
- 可以显式指定导出哪些类或函数;
- 不需头文件重复引入宏;
- 模块之间名称可以相同,并且不会冲突;
- 模块只处理一次,编译会更快(头文件每次引入都需要处理);
- 预处理宏只在模块内有效;
- 模块的引入与引入顺序无关;
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表达式
- 允许
[=, this]作为lambda捕获,并弃用隐式捕获[=]; - lambda init-capture中的包扩展:
[...args = std::move(args)] { ... }; static,thread_local,和lambda捕获结构化绑定;- 模板形式的
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(); // 取出下一个值
三大件:
co_yield v;:产出值并暂停(生成器);co_return v;:结束协程;co_await expr;:等待可挂起的表达式(异步 IO 的抓手)。
指定初始化器
支持 .成员 = 值,配合聚合类型能写出”自文档化”的结构体:
struct User { std::string name; int age; bool active; };
User u{ .name = "Knight", .age = 30, .active = true };
constexpr 增强
virtual函数与new/delete(constexpr 动态分配)可在 constexpr 出现;std::is_constant_evaluated()区分编译期/运行期上下文;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等。