现代C++ - 标签 - 豆浆小屋

C++14 新特性

Fri, 17 Jul 2026 00:00:00 +0000

C++14 是 C++11 的小版本更新，主要是完善和补充，核心特性不多但很实用。

1 一、函数返回值类型推导

C++11 只有 lambda 可以用 auto 推导返回值，C++14 扩展到所有函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// C++14：自动推导返回 int
auto add(int a, int b) {
    return a + b;
}

// 多个 return 必须类型一致
auto f(bool flag) {
    if (flag) return 1;    // int
    else return 2;         // OK，都是 int
    // return 3.14;        // ERROR，类型不一致
}

注意：

递归函数不能用 auto 返回值推导（除非先有前置声明）
有多个 return 语句时，所有 return 的类型必须相同

2 二、泛型 lambda（Generic Lambda）

C++11 的 lambda 参数必须写具体类型，C++14 可以用 auto：

1
2
3
4
5
6
7
8


// C++14：参数用 auto，相当于模板函数
auto add = [](auto a, auto b) {
    return a + b;
};

add(1, 2);       // int
add(1.5, 2.3);   // double
add(string("a"), string("b"));  // string

本质： 编译器自动生成一个模板函数对象。

3 三、变量模板（Variable Templates）

之前只有类模板、函数模板，C++14 新增变量模板：

1
2
3
4
5
6
7


// 定义一个 pi 变量模板
template<typename T>
constexpr T pi = T(3.1415926535897932385);

// 使用
float  r1 = pi<float>;
double r2 = pi<double>;

最经典的应用：std::is_same_v 就是 C++17 基于变量模板做的。

4 四、聚合初始化增强

C++14 允许聚合体中含有默认成员初始化器时，仍然可以用花括号初始化：

1
2
3
4
5
6
7


struct Point {
    int x = 0;
    int y = 0;
};

Point p1{1, 2};  // C++11 不允许，C++14 可以
Point p2{};      // x=0, y=0，用默认值

5 五、`decltype(auto)`

解决转发函数的返回值问题：

1
2
3
4
5


// 用 auto 会丢失引用
auto f1() -> decltype(expr) { return expr; }  // C++11 写法

// C++14 简化写法
decltype(auto) f2() { return expr; }

区别：

auto：会去掉引用和顶层 const
decltype(auto)：完美保留表达式的原始类型

1
2
3
4
5


int x = 42;
int& ref = x;

auto a = ref;            // int
decltype(auto) b = ref;  // int&

6 六、标准库新增

6.1 6.1 `std::make_unique`

C++11 有 make_shared 但漏掉了 make_unique，C++14 补上：

1

auto p = std::make_unique<int>(42);  // 推荐，比 new 安全

6.2 6.2 `std::shared_timed_mutex`

读写锁的超时版本，C++17 又加了 shared_mutex。

6.3 6.3 整数序列 `std::integer_sequence`

模板元编程工具，用于展开参数包：

1
2


template<typename T, T... Is>
struct integer_sequence { ... };

日常开发用得少，库作者用得多。

6.4 6.4 `std::exchange`

赋值并返回旧值：

1
2
3


std::vector<int> v{1, 2, 3};
auto old = std::exchange(v, {4, 5, 6});
// old = {1,2,3}, v = {4,5,6}

7 七、其他小特性

特性	说明
二进制字面量	`0b1010` 表示十进制 10
数字分隔符	`1'000'000` 可读性更好
lambda 初始化捕获	C++14 可以在捕获列表里初始化新变量

1
2
3


// 初始化捕获（init capture）
int x = 10;
auto f = [y = x + 1]() { return y; };  // y = 11

8 总结

C++14 是一个过渡版本，特性不多但都很实用：

函数返回值 auto：写起来更简洁
泛型 lambda：配合 auto 参数，写算法更方便
decltype(auto)：完美转发返回值
make_unique：终于补上了
变量模板：为后续标准库简化铺路

C++17 新特性

Fri, 17 Jul 2026 00:00:00 +0000

C++17 是一个大版本，引入了很多实用特性，被称为「最舒服的 C++ 版本」。

1 一、结构化绑定（Structured Bindings）⭐

最常用的特性之一，一键解包 tuple/struct/数组：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 解包 pair
std::pair<int, std::string> getPerson() { return {25, "Tom"}; }
auto [age, name] = getPerson();

// 解包 tuple
auto [a, b, c] = std::make_tuple(1, 2.5, "hello");

// 解包 struct
struct Point { int x; int y; };
Point p{10, 20};
auto [x, y] = p;

// 解包数组
int arr[] = {1, 2, 3};
auto [a, b, c] = arr;

结合 map 遍历超好用：

1
2
3
4


std::map<int, std::string> m = {{1, "a"}, {2, "b"}};
for (const auto& [key, value] : m) {
    std::cout << key << ": " << value << std::endl;
}

实战（Q347 前 K 个高频元素）：

1
2
3
4
5
6
7
8
9


// 传统写法：p.first / p.second 访问键值对
for (auto& p : u_map) {
    vec.push_back({p.second, p.first});   // p.first 是数字，p.second 是次数
}

// 结构化绑定写法：一行解包，见名知意
for (auto& [num, cnt] : u_map) {
    vec.push_back({cnt, num});
}

注意：LeetCode 默认 C++17，可以直接用 auto [num, cnt]；本地老编译器（C++14 及以下）不支持。

2 二、`if` / `switch` 初始化语句

在 if 条件里定义变量，缩小作用域：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// C++17 写法
if (auto it = m.find(key); it != m.end()) {
    // 使用 it
}
// it 在这里已经不可见了

// switch 同理
switch (int val = getValue(); val) {
    case 1: ...
    case 2: ...
}

3 三、内联变量（Inline Variables）

解决了「全局变量在头文件里定义导致多重定义」的老问题：

1
2
3
4
5
6
7


// 头文件中，C++17 之前会报重复定义
inline constexpr int MAX_SIZE = 1024;

// 静态成员变量也可以直接在类内初始化
class MyClass {
    inline static int count = 0;  // C++17 不需要在 .cpp 里再定义一次
};

4 四、折叠表达式（Fold Expressions）

简化可变参数模板的展开：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 对所有参数求和
template<typename... Args>
auto sum(Args... args) {
    return (... + args);  // 一元右折叠：((a1 + a2) + a3) + ...
}

sum(1, 2, 3, 4);  // = 10

// 带初始值的折叠
template<typename... Args>
void printAll(Args... args) {
    (std::cout << ... << args) << std::endl;
}

四种折叠形式：

(... op args) 一元右折叠
(args op ...) 一元左折叠
(init op ... op args) 二元右折叠
(args op ... op init) 二元左折叠

5 五、`constexpr` 增强

C++17 中 constexpr 可以用的地方更多了：

5.1 5.1 constexpr if

编译期条件判断，替代部分 SFINAE 写法：

1
2
3
4
5
6
7
8


template<typename T>
auto getValue(T x) {
    if constexpr (std::is_integral_v<T>) {
        return x + 1;
    } else {
        return x;
    }
}

5.2 5.2 constexpr lambda

lambda 可以在编译期执行：

1
2


constexpr auto square = [](int n) { return n * n; };
static_assert(square(5) == 25);  // 编译期计算

6 六、类模板参数推导（CTAD）

构造模板类时不用写模板参数，编译器自动推导：

1
2
3
4
5
6
7


// C++11/14：必须写参数
std::pair<int, double> p1(1, 2.5);
std::vector<int> v1{1, 2, 3};

// C++17：自动推导
std::pair p2(1, 2.5);     // pair
std::vector v2{1, 2, 3};  // vector

7 七、标准库新增容器

7.1 7.1 `std::optional`

表示「可能有值，可能为空」，替代指针判空：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


std::optional<int> findNum(int x) {
    if (x > 0) return x;
    return std::nullopt;  // 空
}

auto res = findNum(5);
if (res) {
    std::cout << *res << std::endl;
}

// 有值返回，没值返回默认
int val = findNum(-1).value_or(0);

7.2 7.2 `std::variant`

类型安全的 union，访问时用 std::visit：

1
2
3
4
5
6
7
8


std::variant<int, double, std::string> v;
v = 42;
v = 3.14;
v = "hello";

std::visit([](auto&& arg) {
    std::cout << arg << std::endl;
}, v);

7.3 7.3 `std::any`

可以存任意类型的容器，类似 void* 但类型安全：

1
2
3
4
5
6


std::any a = 42;
a = std::string("hello");

if (a.type() == typeid(std::string)) {
    std::cout << std::any_cast<std::string>(a) << std::endl;
}

8 八、`std::string_view`

字符串的「视图」，不持有数据，零拷贝：

1
2
3
4
5
6


void print(std::string_view sv) {  // 传 const char* 或 std::string 都不用拷贝
    std::cout << sv << std::endl;
}

print("hello");           // OK
print(std::string("hi")); // OK

注意： string_view 不拥有数据，源字符串销毁后就悬空了。

9 九、文件系统库 `std::filesystem`

终于有了标准的文件操作库：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include 
namespace fs = std::filesystem;

// 创建目录
fs::create_directory("test");

// 遍历目录
for (auto& entry : fs::directory_iterator(".")) {
    std::cout << entry.path() << std::endl;
}

// 文件大小、路径操作
auto size = fs::file_size("test.txt");
auto ext = fs::path("test.txt").extension();

10 十、其他实用特性

特性	说明
`[[nodiscard]]`	标记返回值不能忽略，编译器会警告
`[[maybe_unused]]`	标记可能不用的变量，消除警告
`[[fallthrough]]`	switch 中显式标注故意 fall-through
十六进制浮点字面量	`0x1.2p3`
`std::as_const`	把左值转成 const 引用
`std::clamp`	把值限制在区间内 `clamp(val, min, max)`

1
2
3


// [[nodiscard]] 示例
[[nodiscard]] int compute() { return 42; }
compute();  // 警告：返回值被忽略

11 总结

C++17 是日常开发提升幸福感最多的版本：

结构化绑定 + if-init：代码更简洁
optional/variant/any：类型安全三件套
string_view：字符串处理性能提升
filesystem：终于不用自己写文件操作了
constexpr if：模板元编程变得可读

C++20 新特性

Fri, 17 Jul 2026 00:00:00 +0000

C++20 是继 C++11 以来最大的版本更新，四大天王：Concepts、Ranges、Coroutines、Modules。

1 一、概念（Concepts）⭐

给模板参数加约束，让模板报错不再是天书：

1.1 1.1 基础用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 定义一个概念：T 必须是可加的
template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
};

// 使用概念约束模板参数
template<Addable T>
T add(T a, T b) {
    return a + b;
}

1.2 1.2 requires 表达式

四种约束形式：

简单约束：sizeof(T) == 4
类型约束：std::integral
复合约束：{ expr } -> 类型概念
嵌套约束：requires { ... }

1
2
3
4
5
6
7


template<typename T>
concept Container = requires(T c) {
    c.begin();       // 必须有 begin()
    c.end();         // 必须有 end()
    typename T::value_type;  // 必须有 value_type 类型
    { c.size() } -> std::convertible_to<size_t>;
};

1.3 1.3 标准库内置概念

头文件里提供了一堆：

std::same_as — 类型相同
std::derived_from — 派生关系
std::convertible_to — 可转换
std::integral — 整型
std::floating_point — 浮点型
std::ranges::range — 范围

2 二、范围库（Ranges）⭐

彻底改变 STL 算法的写法，支持链式调用：

2.1 2.1 管道式写法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include 

std::vector<int> nums = {1, 2, 3, 4, 5, 6};

// C++17：嵌套调用，可读性差
// C++20：管道式，从左到右读
auto result = nums
    | std::views::filter([](int n) { return n % 2 == 0; })
    | std::views::transform([](int n) { return n * 2; })
    | std::views::take(3);

for (int x : result) {
    std::cout << x << " ";  // 4 8 12
}

2.2 2.2 常用视图适配器

适配器	作用
`views::filter`	过滤
`views::transform`	转换映射
`views::take(n)`	取前 n 个
`views::drop(n)`	跳过前 n 个
`views::reverse`	反转
`views::keys` / `values`	取 pair 的 key/value
`views::join`	扁平化
`views::split`	分割

2.3 2.3 惰性求值

views 不会立即计算，只有在迭代时才生成元素，性能更好。

3 三、协程（Coroutines）

函数可以暂停和恢复，异步编程神器：

3.1 3.1 三个新关键字

1
2
3


co_await   // 暂停，等待异步操作
co_return  // 返回值并结束
co_yield   // 返回一个值并暂停，下次从这里继续

3.2 3.2 生成器示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


generator<int> fibonacci(int n) {
    int a = 0, b = 1;
    for (int i = 0; i < n; ++i) {
        co_yield b;   // 返回 b，暂停在这里
        int next = a + b;
        a = b;
        b = next;
    }
}

// 使用
for (int x : fibonacci(10)) {
    std::cout << x << " ";
}

3.3 3.3 异步任务

1
2
3
4


task<int> fetchData() {
    auto data = co_await asyncLoad();  // 暂停，不阻塞线程
    co_return data.size();
}

注意：标准库只提供了协程机制，没有提供具体的协程类型（task/generator），需要自己实现或用第三方库（如 cppcoro）。C++23 才补了 std::generator。

4 四、模块（Modules）

告别 #include，解决头文件地狱：

4.1 4.1 定义模块

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// math.ixx （模块接口文件）
export module math;

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

export namespace math_utils {
    int mul(int a, int b) { return a * b; }
}

4.2 4.2 导入模块

1
2
3
4
5
6


import math;

int main() {
    add(1, 2);
    math_utils::mul(3, 4);
}

优点：

编译速度大幅提升（只编译一次）
没有宏污染
模块内部的东西默认不导出，封装更好

5 五、三路比较运算符 `<=>`

俗称「飞船运算符」，一次比较得出大小关系：

1
2
3
4
5
6
7
8
9


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

Point a{1, 2}, b{3, 4};
a < b;   // OK，自动生成
a >= b;  // OK
a == b;  // OK

返回类型有三种：

std::strong_ordering — 强序（完全可比）
std::weak_ordering — 弱序
std::partial_ordering — 偏序（可能不可比，比如 NaN）

6 六、指定初始化（Designated Initializers）

像 C 语言那样按名字初始化结构体成员：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


struct Point {
    int x = 0;
    int y = 0;
    int z = 0;
};

Point p {
    .x = 10,
    .z = 30
    // y 用默认值 0
};

注意：顺序必须和声明顺序一致，不能跳着来。

7 七、`consteval` 与 `constinit`

7.1 7.1 consteval — 立即函数

必须在编译期执行，否则报错：

1
2
3
4
5
6
7


consteval int sqr(int n) {
    return n * n;
}

constexpr int a = sqr(10);  // OK，编译期
int b = sqr(20);            // OK，编译期常量
// int x = 5; sqr(x);       // ERROR，x 不是编译期常量

7.2 7.2 constinit — 常量初始化

保证变量在编译期初始化，避免静态初始化顺序问题：

1

constinit int global = compute_at_compile_time();

8 八、`std::format`

Python 风格的格式化字符串，终于不用 printf 或 stringstream 了：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include 

std::string s = std::format("Hello, {}! You are {} years old.", "Tom", 25);
// "Hello, Tom! You are 25 years old."

// 按位置
std::format("{1} {0}", "world", "Hello");  // "Hello world"

// 格式说明
std::format("{:>10}", 42);    // 右对齐，占10位
std::format("{:08b}", 42);    // 8位二进制，前导零
std::format("{:.2f}", 3.14159);  // 保留2位小数

9 九、`std::span`

连续内存的视图，类似 string_view 但是通用的：

1
2
3
4
5
6
7
8
9


void printArray(std::span<int> arr) {
    for (int x : arr) std::cout << x << " ";
}

int a[] = {1, 2, 3};
printArray(a);              // 原生数组

std::vector v = {4, 5, 6};
printArray(v);              // vector

10 十、其他特性速览

特性	说明
`std::jthread`	自动 join 的线程，支持停止令牌
`std::stop_token`	协作式线程中断
`std::source_location`	获取当前代码位置（文件名、行号）
`std::bit_cast`	安全的类型双关，替代 memcpy
`std::midpoint` / `std::lerp`	中点和线性插值
`[[likely]]` / `[[unlikely]]`	给编译器分支预测提示
范围 for 初始化语句	`for (auto it = v.begin(); auto x : v)`

1
2
3
4
5
6


// likely/unlikely 示例
if (likely(n > 0)) {
    // 大概率走这里，编译器优化
} else {
    // 小概率
}

11 总结

C++20 是改变编程范式的大版本：

Concepts：模板终于好用了，报错终于能看懂了
Ranges：STL 算法的现代写法，链式调用爽
Coroutines：异步编程基础设施
Modules：告别头文件，编译起飞
format / span / jthread：各种小确幸

现代C++ - 标签 - 豆浆小屋

C++14 新特性

1 一、函数返回值类型推导

2 二、泛型 lambda（Generic Lambda）

3 三、变量模板（Variable Templates）

4 四、聚合初始化增强

5 五、decltype(auto)

6 六、标准库新增

6.1 6.1 std::make_unique

6.2 6.2 std::shared_timed_mutex

6.3 6.3 整数序列 std::integer_sequence

6.4 6.4 std::exchange

7 七、其他小特性

8 总结

C++17 新特性

1 一、结构化绑定（Structured Bindings）⭐

2 二、if / switch 初始化语句

3 三、内联变量（Inline Variables）

4 四、折叠表达式（Fold Expressions）

5 五、constexpr 增强

5.1 5.1 constexpr if

5.2 5.2 constexpr lambda

6 六、类模板参数推导（CTAD）

7 七、标准库新增容器

7.1 7.1 std::optional

7.2 7.2 std::variant

7.3 7.3 std::any

8 八、std::string_view

9 九、文件系统库 std::filesystem

10 十、其他实用特性

11 总结

C++20 新特性

1 一、概念（Concepts）⭐

1.1 1.1 基础用法

1.2 1.2 requires 表达式

1.3 1.3 标准库内置概念

2 二、范围库（Ranges）⭐

2.1 2.1 管道式写法

2.2 2.2 常用视图适配器

2.3 2.3 惰性求值

3 三、协程（Coroutines）

3.1 3.1 三个新关键字

3.2 3.2 生成器示例

3.3 3.3 异步任务

4 四、模块（Modules）

4.1 4.1 定义模块

4.2 4.2 导入模块

5 五、三路比较运算符 <=>

6 六、指定初始化（Designated Initializers）

7 七、consteval 与 constinit

7.1 7.1 consteval — 立即函数

7.2 7.2 constinit — 常量初始化

8 八、std::format

9 九、std::span

10 十、其他特性速览

11 总结

5 五、`decltype(auto)`

6.1 6.1 `std::make_unique`

6.2 6.2 `std::shared_timed_mutex`

6.3 6.3 整数序列 `std::integer_sequence`

6.4 6.4 `std::exchange`

2 二、`if` / `switch` 初始化语句

5 五、`constexpr` 增强

7.1 7.1 `std::optional`

7.2 7.2 `std::variant`

7.3 7.3 `std::any`

8 八、`std::string_view`

9 九、文件系统库 `std::filesystem`

5 五、三路比较运算符 `<=>`

7 七、`consteval` 与 `constinit`

8 八、`std::format`

9 九、`std::span`