C++20新特性的补充讲解

C++20 标志着 C++ 语言的一次重要更新，除了 Concepts、Ranges、协程等被广泛讨论的特性外，还有许多值得注意的改进。本文将详细探讨其他一些核心新特性，包括 constexpr 扩展、新增的 std::format、std::span、std::bit 操作、原子智能指针、char8_t 类型以及 lambda 表达式的改进等。通过这些特性，C++20 带来了更简洁、更高效的编程体验。

文章目录

@[toc]
一、`constexpr` 扩展
示例

二、`std::format`：强大的字符串格式化
示例

三、`std::span`：安全的连续内存视图
示例

四、`std::bit` 操作库
示例

五、原子智能指针
示例

六、`char8_t` 类型
示例

七、lambda 表达式的改进
1. 捕获 `this` 的改进
2. 模板 lambda

八、扩展的`[[nodiscard]]`属性
示例

九、改进的`std::chrono`库
示例

十、其他改进
1. `std::source_location`
2. `std::stop_token` 和 `std::jthread`
3. 匿名结构体和联合体

总结

一、`constexpr` 扩展

在 C++20 中，constexpr 关键字得到了进一步扩展，使得更多的操作可以在编译期执行。这意味着我们可以在 constexpr 中使用更复杂的代码，包括 try-catch 异常处理、动态分配和更多的标准库函数，使编译时常量计算的范围大大增加。

示例

#include <array>
#include <iostream>constexpr int factorial(int n) {if (n <= 1) return 1;return n * factorial(n - 1);
}int main() {constexpr int result = factorial(5); // 在编译期计算std::cout << result << std::endl;    // 输出：120return 0;
}

在这个例子中，我们利用 constexpr 计算阶乘函数 factorial。在 C++20 中，这种递归计算不仅更加灵活，还可以在编译期完成，为程序提供了额外的性能优化空间。

二、`std::format`：强大的字符串格式化

std::format 是 C++20 引入的一个重要新特性，类似于 Python 的 f-string 或者 printf 函数，提供了更现代、灵活的字符串格式化功能。std::format 使用占位符和格式说明符来简化字符串拼接操作，使代码更清晰。

示例

#include <format>
#include <iostream>int main() {int year = 2023;double pi = 3.14159;std::string formatted = std::format("The year is {} and Pi is {:.2f}.", year, pi);std::cout << formatted << std::endl;  // 输出：The year is 2023 and Pi is 3.14.return 0;
}

这里，std::format 使用 {} 作为占位符，支持指定宽度、精度等格式化参数。相比传统的 sprintf 函数，std::format 更加类型安全、功能更强大，提升了代码的可读性和安全性。

三、`std::span`：安全的连续内存视图

std::span 是一种轻量级的非拥有数据的容器视图，用于表示连续的内存块，例如数组或 std::vector 的某部分。std::span 提供了访问连续内存的方式，而不需要传递指针和大小参数，提高了接口的安全性和可读性。

示例

#include <span>
#include <iostream>void print(std::span<int> data) {for (int value : data) {std::cout << value << " ";}
}int main() {int arr[] = {1, 2, 3, 4, 5};print(arr); // 可以直接传入数组return 0;
}

std::span 的优势在于可以避免数组指针传递带来的边界不清问题，提供了更加一致和简洁的接口。它还可以与 std::vector 等容器结合使用，进一步增强代码的灵活性。

四、`std::bit` 操作库

C++20 新增了 std::bit 标准库，提供了一系列用于位操作的函数，包括按位旋转、按位计数等操作。这些操作对底层位操作有很大的帮助，简化了位处理的复杂度。

示例

#include <bit>
#include <iostream>int main() {unsigned int x = 0b0011'1100;// 位旋转操作unsigned int rotated = std::rotl(x, 2); // 左旋 2 位std::cout << "After left rotation: " << std::bitset<8>(rotated) << std::endl;// 计算 1 的数量int count = std::popcount(x);std::cout << "Number of 1s: " << count << std::endl;return 0;
}

这些位操作函数对需要处理位运算的程序员来说非常实用，提供了更高效、更简洁的位操作支持，适合于处理嵌入式系统和性能敏感的应用场景。

五、原子智能指针

C++20 引入了 std::atomic_shared_ptr 和 std::atomic_weak_ptr，使得智能指针能够以原子的方式操作。这一改进简化了并发编程中智能指针的管理，保证了多线程环境下的指针操作安全。

示例

#include <atomic>
#include <iostream>
#include <memory>
#include <thread>std::atomic<std::shared_ptr<int>> atomic_ptr;void thread1() {auto ptr = std::make_shared<int>(42);atomic_ptr.store(ptr);
}void thread2() {auto ptr = atomic_ptr.load();if (ptr) {std::cout << "Value: " << *ptr << std::endl;}
}int main() {std::thread t1(thread1);std::thread t2(thread2);t1.join();t2.join();return 0;
}

原子智能指针的引入简化了多线程环境下共享资源的管理，确保了数据的线程安全，是并发编程中的一项重要改进。

六、`char8_t` 类型

C++20 引入了 char8_t 类型，用于表示 UTF-8 编码的字符。这一类型使得代码在处理多字节字符时更加清晰和安全，避免了传统 char 类型在编码上的模糊性。

示例

#include <iostream>void print_utf8(const char8_t* text) {while (*text) {std::cout << static_cast<char>(*text);text++;}
}int main() {const char8_t* text = u8"Hello, UTF-8!";print_utf8(text); // 输出：Hello, UTF-8!return 0;
}

char8_t 提供了更强的编码明确性，减少了因编码转换产生的错误和歧义，是现代应用程序处理 UTF-8 编码的理想选择。

七、lambda 表达式的改进

C++20 为 lambda 表达式带来了几项重要改进，包括捕获 this 指针的简化和 template lambda 支持，使得 lambda 更加灵活易用。

1. 捕获 `this` 的改进

在 C++20 之前，lambda 捕获成员变量的方式较为繁琐。C++20 允许直接捕获 *this，避免了冗长的捕获列表。

#include <iostream>struct MyClass {int value = 42;void show() {auto lambda = [*this] { std::cout << value << std::endl; };lambda();}
};int main() {MyClass obj;obj.show(); // 输出：42return 0;
}

2. 模板 lambda

模板 lambda 允许我们定义带模板参数的 lambda 表达式，适合泛型编程场景，使得 lambda 表达式更加灵活。

#include <iostream>int main() {auto add = []<typename T>(T a, T b) {return a + b;};std::cout << add(1, 2) << std::endl;       // 输出：3std::cout << add(1.5, 2.5) << std::endl;   // 输出：4.0return 0;
}

模板 lambda 为泛型编程提供了更简洁的写法，减少了冗长的函数模板定义，让代码更具表现力。

八、扩展的`[[nodiscard]]`属性

C++20 扩展了 [[nodiscard]] 属性，允许对整个类型或函数标记 [[nodiscard]]，表示返回值不可忽略。通过这一属性，可以避免意外忽略重要返回值引起的潜在错误。

示例

#include <iostream>[[nodiscard]] int compute_important_value() {return 42;
}int main() {compute_important_value(); // 警告：忽略了 `nodiscard` 返回值return 0;
}

[[nodiscard]] 属性提高了代码的健壮性，使得重要返回值不会被意外忽略。它适用于那些返回值不可忽略的函数，比如错误处理、资源分配等场景。通过 [[nodiscard]] 属性，C++20 能够进一步减少因忽略关键返回值导致的潜在问题。

九、改进的`std::chrono`库

C++20 对 std::chrono 时间库进行了改进，添加了对历法和时区的支持。这些改进使得处理日期和时间更加方便，尤其是在处理跨时区和复杂日期计算的应用中。

示例

#include <iostream>
#include <chrono>
#include <format>int main() {using namespace std::chrono;// 获取当前的系统时间auto now = system_clock::now();// 格式化输出日期和时间std::cout << std::format("Current time: {:%Y-%m-%d %H:%M:%S}\n", now);// 计算未来的日期auto future_date = now + days(100);std::cout << std::format("100 days later: {:%Y-%m-%d}\n", future_date);return 0;
}

std::chrono 的改进使得日期和时间的处理更加直观，避免了开发者使用外部库来实现类似功能。通过新的时区支持，C++20 让时间计算和显示更加精确和方便。

十、其他改进

除了上面提到的主要特性，C++20 还包含了许多小而实用的改进：

1. `std::source_location`

std::source_location 允许获取源代码的位置（如文件名、行号和函数名），用于日志和调试信息的记录，非常适合用于调试和错误跟踪。

#include <iostream>
#include <source_location>void log(const std::string& message, const std::source_location& location = std::source_location::current()) {std::cout << "Log: " << message<< " (" << location.file_name() << ":" << location.line() << " in " << location.function_name() << ")\n";
}int main() {log("An example message");return 0;
}

2. `std::stop_token` 和 `std::jthread`

std::stop_token 和 std::jthread 简化了线程的停止机制，支持安全的线程中断。std::jthread 自动管理线程的生命周期，避免了线程资源泄漏。

#include <iostream>
#include <thread>
#include <chrono>
#include <stop_token>void task(std::stop_token stop_token) {while (!stop_token.stop_requested()) {std::cout << "Working...\n";std::this_thread::sleep_for(std::chrono::seconds(1));}std::cout << "Task stopped.\n";
}int main() {std::jthread worker(task);  // 使用 jthread 运行线程std::this_thread::sleep_for(std::chrono::seconds(3));worker.request_stop();  // 请求线程停止return 0;
}

3. 匿名结构体和联合体

C++20 支持匿名结构体和联合体，允许在类中嵌套匿名的 struct 或 union，从而简化代码结构。

#include <iostream>struct Point {union {struct {int x, y;};int coords[2];};
};int main() {Point p;p.x = 10;p.y = 20;std::cout << "Point x: " << p.coords[0] << ", y: " << p.coords[1] << std::endl;return 0;
}

匿名结构体和联合体在需要存储多个互斥数据时提供了更便捷的方式，使代码更加紧凑。

总结

C++20 是一次全面的更新，带来了 Concepts、Ranges、Coroutines 等重量级特性，同时通过 constexpr 扩展、std::format、std::span、原子智能指针、std::chrono 改进等大量优化，为开发者提供了更强大的工具链。这些特性不仅提升了 C++ 代码的安全性、性能和可读性，还使得开发体验更加便捷和高效。

通过这些新特性，C++20 不仅解决了长期以来的模板编程复杂性、多线程管理等问题，还引领了现代 C++ 向更加简洁、高效的方向发展。对于 C++ 开发者来说，学习和掌握这些新特性将大大提升编程效率，并为创建更具扩展性和可维护性的代码奠定基础。