C++11 标志着现代 C++ 的开端,C++14 在 11 的基础上查缺补漏,并未加入许多新特性,而 C++17 作为 C++11 后的第一个大版本,标志着现代 C++ 逐渐走向成熟。现在整理一下在工作中经常使用的一些特性,这些特性大体上分为三类:语法糖
、性能提升
和类型
。
语法糖
这里所说的语法糖,并不是严格意义上编程语言级别的语法糖,还包括一些能让代码更简洁更具有可读性的函数和库:
结构化绑定
在使用 C++17 编程的过程中发现最为便利的语法糖是结构化绑定。结构化绑定是指将 array、tuple 或 struct 的成员绑定到一组变量上的语法,常用的场景是在遍历 map/unordered_map 时不用再声明一个中间变量,然后获取相应的 key 和 value。
// C++17 之前
for (const auto& kv : map) {
const auto& key = kv.first;
const auto& value = kv.second;
......
}
// C++17
for (const auto& [key, value] : map) {
// 直接使用 key 和 value
......
}
严格来说,结构化绑定的结果并不是变量,C++ 标准称之为别名,这也导致它们不允许被 lambda 捕获,但是 gcc 并没有遵循 C++ 标准,所以以下代码在 gcc 可以编译,clang 可能编译不过:
for (const auto& [key, value] : map) {
[&key, &value] {
std::cout << key << " : " << value << std::endl;
}();
}
在 clang 环境下,可以在 lambda 表达式捕获时显式引入一个引用变量则可以通过编译:
for(const auto& [key, value]: map){
[&key = key, &value = value]{
std::cout << key << ": " << value << std::endl;
}();
}
另外这条限制在 C++20 中已经被删除,所以在 C++20 标准中 gcc 和 clang 都可以捕获结构化绑定的对象了。
std::tuple 的隐式推导
在 C++17 之前,构造std::pair/tuple
时必须指定数据类型或使用std::make_pair/make_tuple
函数,C++17 为 std::pair/std::tuple
新增了推导规则,可以不再显示指定类型。
// C++17 之前
std::pair<int, std::string> p1{3.14, "pi"};
auto p1 = std::make_pair(3.14, "pi");
// C++17
std::pair p3{3.14, "pi"};
if constexpr
if constexpr 语句是编译期的 if 判断语句,在 C++17 以前做编译期的条件判断往往通过复杂 SFINAE机制或模版重载实现,if constexpr 大大简化了这类编程问题。比如想实现一个函数将不同类型的输入转化为字符串,在 C++17 之前可以写三个函数去实现,而在 C++17 中只需要一个函数就可以搞定。
// C++17 之前
template <typename T>
std::string convert(T input){
return std::to_string(input);
}
// const char* 和 string 进行特殊处理
std::string convert(const char* input){
return input;
}
std::string convert(std::string input){
return input;
}
// C++17
template <typename T>
std::string convert(T input) {
if constexpr (std::is_same_v<T, const char*> ||
std::is_same_v<T, std::string>) {
return input;
} else {
return std::to_string(input);
}
}
if 初始化语句
C++17 支持在 if 的判断语句之前增加一个初始化语句,有助于提升代码的可读性。且对于 lock/iterator 等涉及并发或 RAII 的类型更容易保证程序的正确性。
// C++ 17
std::map<int, std::string> m;
std::mutex mx;
extern bool shared_flag; // guarded by mx
int demo() {
// 最常用的,在 map 中查找 key,如果存在则返回想要的信息
if (auto it = m.find(10); it != m.end()) {
return it->second.size();
}
if (char buf[10]; std::fgets(buf, 10, stdin)) {
m[0] += buf;
}
if (std::lock_guard lock(mx); shared_flag) {
// 逻辑处理
}
if (int s; int count = Fun(&s)) {
// 逻辑处理
}
if (const auto keywords = {"if", "for", "while"};
std::ranges::any_of(keywords, [&tok](const char* kw) { return tok == kw; })) {
std::cerr << "Token must not be a keyword \n";
}
}
性能提升
std::shared_mutex
shared_mutex
是 C++ 的原生读写锁实现,有共享和独占两种锁模式,适用于并发高的读场景下。在 C++17 之前,只能自己通过独占锁和条件变量自己实现读写锁或使用 C++14 加入的性能较差的 std::shared_timed_mutex
。以下是通过 shared_mutex
实现的线程安全计数器:
#include <iostream>
#include <mutex> // 对于 std::unique_lock
#include <shared_mutex>
#include <thread>
class ThreadSafeCounter {
public:
ThreadSafeCounter() = default;
// 多个线程/读者能同时读计数器的值。
unsigned int get() const {
std::shared_lock<std::shared_mutex> lock(mutex_);
return value_;
}
// 只有一个线程/写者能增加/写线程的值。
void increment() {
std::unique_lock<std::shared_mutex> lock(mutex_);
value_++;
}
// 只有一个线程/写者能重置/写线程的值。
void reset() {
std::unique_lock<std::shared_mutex> lock(mutex_);
value_ = 0;
}
private:
mutable std::shared_mutex mutex_;
unsigned int value_ = 0;
};
int main() {
ThreadSafeCounter counter;
auto increment_and_print = [&counter]() {
for (int i = 0; i < 3; i++) {
counter.increment();
std::cout << std::this_thread::get_id() << ' ' << counter.get() << '\\n';
// 注意:写入 std::cout 实际上也要由另一互斥同步。省略它以保持示例简洁。
}
};
std::thread thread1(increment_and_print);
std::thread thread2(increment_and_print);
thread1.join();
thread2.join();
}
// 解释:下列输出在单核机器上生成。 thread1 开始时,它首次进入循环并调用 increment() ,
// 随后调用 get() 。然而,在它能打印返回值到 std::cout 前,调度器将 thread1 置于休眠
// 并唤醒 thread2 ,它显然有足够时间一次运行全部三个循环迭代。再回到 thread1 ,它仍在首个
// 循环迭代中,它最终打印其局部的计数器副本的值,即 1 到 std::cout ,再运行剩下二个循环。
// 多核机器上,没有线程被置于休眠,且输出更可能为递增顺序。
std::string_view
std::string_view
顾名思义是字符串的 "视图",类成员变量包含两个部分:字符串指针和字符串长度,std::string_view 涵盖了 std::string 的所有只读接口。std::string_view 对字符串不具有所有权,且兼容 std::string 和 const char* 两种类型。
C++17 之前,处理只读字符串往往使用 const std::string&
,std::string_view
有两点性能优势:
(1) 兼容两种字符串类型,减少类型转换和内存分配。如果传入的是字符串是 const char*
,而函数的参数是 const std::string&,此时
需要进行一次内存分配,将字符串拷贝到堆上,而使用 std::string_view
则可以避免这个问题。
(2) 在处理子串时,std::string::substr
需要进行拷贝和分配内存,而std::string_view::substr
则不需要,在处理大文件解析时,性能优势非常明显。
// from <https://stackoverflow.com/a/40129046>
// author: Pavel Davydov
// string_view 的 remove_prefix 比 const std::string& 的快了 15 倍
string remove_prefix(const string &str) {
return str.substr(3);
}
string_view remove_prefix(string_view str) {
str.remove_prefix(3);
return str;
}
static void BM_remove_prefix_string(benchmark::State& state) {
std::string example{"asfaghdfgsghasfasg3423rfgasdg"};
while (state.KeepRunning()) {
auto res = remove_prefix(example);
// auto res = remove_prefix(string_view(example)); for string_view
if (res != "aghdfgsghasfasg3423rfgasdg") {
throw std::runtime_error("bad op");
}
}
}
std::map/unordered_map try_emplace
在向 std::map/unordered_map
中插入元素时,往往使用 emplace
,emplace
的操作是如果元素 key 不存在,则插入该元素,否则不插入。但是在元素已存在时,emplace
仍会构造一次待插入的元素,在判断不需要插入后,立即将该元素析构,因此进行了一次多余构造和析构操作。C++17 加入了 try_emplace
,避免了这个问题。同时 try_emplace 在参数列表中将 key 和 value 分开,因此进行原地构造的语法比 emplace
更加简洁。
std::map<std::string, std::string> m;
// emplace的原地构造需要使用std::piecewise_construct,因为是直接插入std::pair<key, value>
m.emplace(std::piecewise_construct,
std::forward_as_tuple("c"),
std::forward_as_tuple(10, 'c'));
// try_emplace可以直接原地构造,因为参数列表中key和value是分开的
m.try_emplace("c", 10, 'c')
同时,C++17 还给 std::map/unordered_map
加入了 insert_or_assign
函数,可以更方便地实现插入或更新语义。
类型系统
C++17 进一步完备了 C++ 的类型系统,终于加入了类型擦除容器(Type Erasure)和代数数据类型(Algebraic Data Type)。
std::any
std::any
是一个可以存储任何可拷贝类型的容器,C 语言中通常使用 void*
实现类似的功能,与 void*
相比,std::any
具有两点优势:
(1) std::any
更安全:在类型 T 被转换成 void*
时,T 的类型信息就已经丢失了,在转换回具体类型时程序无法判断当前的 void*
的类型是否真的是 T,容易带来安全隐患。而 std::any
会存储类型信息,std::any_cast
是一个安全的类型转换。
(2) std::any
管理了对象的生命周期,在 std::any
析构时,会将存储的对象析构,而 void*
则需要手动管理内存。std::any
应当很少是程序员的第一选择,在已知类型的情况下,std::optional
,std::variant
和继承都是比它更高效、更合理的选择。只有当对类型完全未知的情况下,才应当使用 std::any
,比如动态类型文本的解析或者业务逻辑的中间层信息传递。
std::optional
std::optional<T>
代表一个可能存在的 T 值。常用于可能失败的函数的返回值中,比如工厂函数。在 C++17 之前,往往使用 T*
作为返回值,如果为 nullptr
则代表函数失败,否则 T*
指向了真正的返回值。但是这种写法模糊了所有权,函数的调用方无法确定是否应该接管 T*
的内存管理,而且 T*
可能为空的假设,如果忘记检查则会有 Segment Fault 的风险。注意:空为 nullopt。
// C++17 之前
ReturnType* func(const std::string& in) {
ReturnType* ret = new ReturnType;
if (in.size() == 0)
return nullptr;
// ...
return ret;
}
// C++17 更安全和直观
std::optional<ReturnType> func(const string& in) {
ReturnType ret;
if (in.size() == 0)
return nullopt;
// ...
return ret;
}
std::optional<std::string> op_test(int a) {
if (a < 10) return "";
return std::to_string(a);
}
std::optional<std::string> op_temp = op_test(1);
if (op_temp.value().empty()) cout << "op_temp == nullptr" <<endl;
op_temp = op_test(100);
if (!op_temp.value().empty()) cout << "op_temp str: " << op_temp.value() << endl;
std::variant
std::variant<T, U, ...>
代表一个多类型的容器,容器中的值是制定类型的一种,对应 Rust 的 enum
。是一种类型安全的 union
,所以也叫做 tagged union
。与 union
相比有两点优势:
(1) 可以存储复杂类型,而 union 只能直接存储基础的 POD 类型,对于如 std::vector
和 std::string
就等复杂类型则需要用户手动管理内存。
(2) 类型安全,variant 存储了内部的类型信息,所以可以进行安全的类型转换,C++17 之前往往通过 union
+enum
来实现相同功能。
通过使用 std::variant<T, Err>
,用户可以实现类似 Rust 的 std::result
,即在函数执行成功时返回结果,在失败时返回错误信息,上文的例子则可以改成:
std::variant<ReturnType, Err> func(const string& in) {
ReturnType ret;
if (in.size() == 0)
return Err{"input is empty"};
// ...
return {ret};
}
需要注意的是,C++17 只提供了一个库级别的 variant 实现,没有对应的模式匹配(Pattern Matching)机制,而最接近的 std::visit
又缺少编译器的优化支持,所以在 C++17 中s td::variant
并不好用,跟 Rust 和函数式语言中出神入化的 Sum Type 还相去甚远,但是已经有许多围绕 std::variant
的提案被提交给 C++ 委员会探讨,包括模式匹配,std::expected
等等。
总结一下,C++17 新增的三种类型给 C++ 带来了更现代更安全的类型系统,它们对应的使用场景是:
std::any
适用于之前使用void*
作为通用类型的场景。
std::optional
适用于之前使用nullptr
代表失败状态的场景。
std::variant
适用于之前使用union
的场景。