C++17 - 重大更新
C++17：重大更新
C++17 带来了许多重要的新特性，显著提升了 C++ 的表达力和安全性。
结构化绑定
// 解构 pair
std::pair<int, std::string> p{42, "hello"};
auto [id, name] = p;
// 解构 tuple
std::tuple<int, double, std::string> t{1, 3.14, "world"};
auto [x, y, z] = t;
// 解构数组
int arr[3] = {1, 2, 3};
auto [a, b, c] = arr;
// 解构结构体
struct Point {
int x;
int y;
};
Point pt{10, 20};
auto [px, py] = pt;
// 在范围 for 循环中使用
std::map<std::string, int> m{{"a", 1}, {"b", 2}};
for (const auto& [key, value] : m) {
std::cout << key << ": " << value << "\n";
}if 和 switch 初始化语句
// 传统方式
std::map<int, std::string> m;
auto it = m.find(42);
if (it != m.end()) {
// 使用 it
}
// C++17 方式
if (auto it = m.find(42); it != m.end()) {
// 使用 it
}
// 配合结构化绑定
std::map<int, std::string> m{{1, "one"}, {2, "two"}};
if (auto [it, inserted] = m.emplace(3, "three"); inserted) {
std::cout << "Inserted: " << it->second << "\n";
}
// switch 初始化语句
switch (auto it = m.find(42); auto result = it->second) {
case "found":
break;
}constexpr if
template<typename T>
auto getValue(T t) {
if constexpr (std::is_pointer_v<T>) {
return *t;
} else {
return t;
}
}
int x = 42;
std::cout << getValue(x) << "\n"; // 42
std::cout << getValue(&x) << "\n"; // 42折叠表达式
// 参数包展开
template<typename... Args>
auto sum(Args... args) {
return (args + ...); // 右折叠
}
// 使用
int total = sum(1, 2, 3, 4, 5); // 15
// 左折叠
template<typename... Args>
auto printAll(Args... args) {
(std::cout << ... << args) << "\n";
}
printAll(1, " ", 2, " ", 3); // 1 2 3
// 空参数包
template<typename... Args>
void log(Args... args) {
((std::cout << args << "\n"), ...);
}内联变量
// 头文件中定义静态成员变量
struct MyClass {
static inline int value = 42; // C++17
static inline std::vector<int> data = {1, 2, 3};
};
// 全局变量
inline constexpr int MAX_SIZE = 1000;
// 不再需要在 .cpp 文件中定义类模板参数推导（CTAD）
std::pair p{42, "hello"}; // std::pair<int, const char*>
std::tuple t{1, 2.0, "three"}; // std::tuple<int, double, const char*>
// 推导指引
template<typename T>
struct MyContainer {
MyContainer(T val) : value_(val) {}
T value_;
};
MyContainer c{42}; // MyContainer<int>
// 容器推导
std::vector v{1, 2, 3}; // std::vector<int>嵌套命名空间
// C++17 之前
namespace outer::inner {
void func() {}
}
// 等同于
namespace outer {
namespace inner {
void func() {}
}
}属性改进
// [[nodiscard]]：忽略返回值会警告
[[nodiscard]] int compute() {
return 42;
}
// compute(); // 警告：返回值被忽略
// [[maybe_unused]]：抑制未使用警告
[[maybe_unused]] int x = 42;
// [[fallthrough]]：显式表示 switch 穿透
switch (value) {
case 1:
doSomething();
[[fallthrough]];
case 2:
doSomethingElse();
break;
}
// [[nodiscard("reason")]] 自定义消息
[[nodiscard("Connection must be closed")]]
Connection connect();UTF-8 字符字面量
// UTF-8 字符字面量
char8_t c1 = u8'A'; // UTF-8 编码
// UTF-8 字符串字面量
auto str = u8"Hello, 世界!"; // const char8_t*
// Unicode 编码
char16_t c2 = u'汉'; // UTF-16
char32_t c3 = U'中'; // UTF-32std::optional
#include <optional>
std::optional<int> divide(int a, int b) {
if (b == 0) {
return std::nullopt; // 表示无值
}
return a / b;
}
auto result = divide(10, 2);
if (result) {
std::cout << *result << "\n"; // 5
}
// 使用 value_or 提供默认值
int value = divide(10, 0).value_or(-1); // -1
// 直接构造
std::optional<std::string> opt("hello");std::variant
#include <variant>
std::variant<int, double, std::string> var;
var = 42;
std::cout << std::get<int>(var) << "\n"; // 42
// 使用 std::visit
auto visitor = [](auto&& arg) {
std::cout << arg << "\n";
};
std::visit(visitor, var);
// 使用 std::holds_alternative 检查类型
if (std::holds_alternative<int>(var)) {
std::cout << "Contains int\n";
}
// 获取索引
std::cout << var.index() << "\n"; // 0std::any
#include <any>
std::any a = 42;
a = 3.14;
a = std::string("hello");
// 检查类型
if (a.type() == typeid(std::string)) {
std::cout << std::any_cast<std::string>(a) << "\n";
}
// 使用 std::any_cast
try {
int value = std::any_cast<int>(a); // 抛出异常
} catch (const std::bad_any_cast& e) {
std::cout << "Bad cast: " << e.what() << "\n";
}std::string_view
#include <string_view>
// 避免字符串拷贝
void printString(std::string_view sv) {
std::cout << sv << "\n";
}
std::string str = "hello";
const char* cstr = "world";
printString(str); // OK
printString(cstr); // OK
printString("test"); // OK
// 子串操作
std::string_view sv = "Hello, World!";
std::cout << sv.substr(0, 5) << "\n"; // Hello
std::cout << sv.starts_with("Hello") << "\n"; // truestd::byte
#include <cstddef>
// 字节类型，用于访问原始内存
std::byte b{42};
std::byte data[4];
data[0] = std::byte{0x12};
data[1] = std::byte{0x34};
// 转换为整数
int value = std::to_integer<int>(data[0]); // 18
// 内存操作
std::memset(data, std::byte{0}, sizeof(data));std::invoke
#include <functional>
// 调用函数指针
int add(int a, int b) { return a + b; }
int result = std::invoke(add, 3, 4); // 7
// 调用成员函数
struct Calculator {
int multiply(int a, int b) { return a * b; }
};
Calculator calc;
int product = std::invoke(&Calculator::multiply, calc, 3, 4); // 12
// 调用 lambda
auto lambda = [](int a, int b) { return a * b; };
int lambdaResult = std::invoke(lambda, 5, 6); // 30std::apply
#include <tuple>
int add(int a, int b, int c) { return a + b + c; }
auto t = std::make_tuple(1, 2, 3);
int result = std::apply(add, t); // 6
// 访问 tuple 元素
std::apply([](auto&... args) {
((std::cout << args << "\n"), ...);
}, t);std::make_from_tuple
#include <tuple>
struct Point {
int x;
int y;
int z;
};
auto t = std::make_tuple(1, 2, 3);
Point p = std::make_from_tuple<Point>(t); // Point{1, 2, 3}std::clamp
#include <algorithm>
int value = 75;
int minVal = 0;
int maxVal = 100;
int clamped = std::clamp(value, minVal, maxVal); // 75
int clamped2 = std::clamp(-10, minVal, maxVal); // 0
int clamped3 = std::clamp(150, minVal, maxVal); // 100
// 带比较函数
auto clamped4 = std::clamp(value, minVal, maxVal, std::greater<int>());std::reduce/std::transform_reduce
#include <numeric>
#include <execution>
std::vector<int> vec = {1, 2, 3, 4, 5};
// 并行归约
int sum = std::reduce(std::execution::par, vec.begin(), vec.end());
// 先转换后归约
auto squaredSum = std::transform_reduce(
std::execution::par,
vec.begin(), vec.end(),
0LL,
std::plus<>{},
[](int x) { return x * x; }
); // 55 (1+4+9+16+25)std::filesystem
#include <filesystem>
namespace fs = std::filesystem;
// 创建目录
fs::create_directory("test");
fs::create_directories("a/b/c"); // 递归创建
// 遍历目录
for (const auto& entry : fs::directory_iterator(".")) {
std::cout << entry.path() << "\n";
std::cout << "Is file: " << entry.is_regular_file() << "\n";
}
// 检查文件
if (fs::exists("file.txt")) {
std::cout << "File size: " << fs::file_size("file.txt") << "\n";
}
// 路径操作
fs::path p = "/home/user/documents/file.txt";
std::cout << "Filename: " << p.filename() << "\n";
std::cout << "Extension: " << p.extension() << "\n";
std::cout << "Parent: " << p.parent_path() << "\n";
// 相对路径
std::cout << "Relative: " << fs::relative(p) << "\n";std::scoped_lock
#include <mutex>
std::mutex mtx1, mtx2;
// C++17 之前：手动 lock
std::lock(mtx1, mtx2);
std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);
// C++17：scoped_lock 自动管理多个锁，完全替代 std::lock_guard
std::scoped_lock lock(mtx1, mtx2);
// 自动以避免死锁的方式获取所有锁
// 析构时自动释放__has_include
#if __has_include(<optional>)
#include <optional>
#endif
#if __has_include(<filesystem>) && __has_include(<version>)
#include <filesystem>
#define HAS_FILESYSTEM 1
#else
#define HAS_FILESYSTEM 0
#endif并行算法
#include <algorithm>
#include <execution>
std::vector<int> vec(1000000);
std::iota(vec.begin(), vec.end(), 0);
// 执行策略
std::sort(std::execution::par, vec.begin(), vec.end()); // 并行
std::sort(std::execution::seq, vec.begin(), vec.end()); // 顺序
std::sort(std::execution::par_unseq, vec.begin(), vec.end()); // 并行+向量化
// 并行查找
auto it = std::find(std::execution::par, vec.begin(), vec.end(), 42);
// 并行变换
std::transform(std::execution::par, vec.begin(), vec.end(), vec.begin(),
[](int x) { return x * 2; });std::shared_mutex
#include <shared_mutex>
class ThreadSafeCache {
mutable std::shared_mutex mtx_;
std::unordered_map<std::string, std::string> cache_;
public:
// 读操作：使用共享锁
std::string read(const std::string& key) const {
std::shared_lock<std::shared_mutex> lock(mtx_);
auto it = cache_.find(key);
return it != cache_.end() ? it->second : "";
}
// 写操作：使用独占锁
void write(const std::string& key, const std::string& value) {
std::unique_lock<std::shared_mutex> lock(mtx_);
cache_[key] = value;
}
};常用特性总结
最常用的 C++17 特性：
- 结构化绑定
std::optionalstd::variantstd::string_viewstd::invoke- if 初始化语句
std::filesystem[[nodiscard]]属性
Related Articles
2025-08-08
cpp concept
C++20引入的concept是C++模板编程的一项重大特性，用于定义对模板参数的约束，提高模板代码的可读性、错误诊断和维护性。以下是对C++20 concept的详细讲解，包括其背景、语法、用途、设计理念以及实际应用。 1. 背景和动机 在C++20之前，模板编程虽然强大，但存在以下问题： 缺乏明确的约束：模板参数的类型要求通常通过文档或代码中的隐式假设来表达。如果模板的使用不符合要求，编译器会在实例化时产生难以理解的错误信息。 错误信息复杂：模板实例化失败时，编译器通常会输出冗长且晦涩的错误信息，难以快速定位问题。 代码可读性差：开发者需要通过模板元编程或SFINAE（Substitution Failure Is Not An Error）等技术间接约束模板参数，这增加了代码复杂度和学习成本。 concept的引入解决了这些问题，它允许开发者显式地定义模板参数的语义要求，使代码更清晰、错误信息更友好，同时提高编译器的诊断能力。 2. 什么是Concept？ concept是一个命名的约束集合，用于描述模板参数必须满足的条件。它可以看作是对类型或值的语义要求的一种形式化表...
2023-06-21
cpp的lambda和bind
基本表达式 [capture](parameters) -> return-type {body} 当没有返回类型时, 可以省略 -> return-type 变量捕获与lambda闭包实现 [] 不截取任何变 [&] 截取外部作用域中所有变量，并作为引用在函数体中使用 [=] 截取外部作用域中所有变量，并拷贝一份在函数体中使用 [=, &foo] 截取外部作用域中所有变量，并拷贝一份在函数体中使用，但是对foo变量使用引用 [bar] 截取bar变量并且拷贝一份在函数体重使用，同时不截取其他变量 [x, &y] x按值传递，y按引用传递 [this] 截取当前类中的this指针。如果已经使用了&或者=就默认添加此选项。 lambda 的底层实现 lambda 其实是c++的语法糖，是通过c++编译器生成class来实现的，看一个简单的例子。 #include <functional> using namespace std; int main(int argc, char* argv[]) { ...
2025-08-13
c++ 中的类型擦除
C++ 中的类型擦除（Type Erasure）详解 类型擦除（Type Erasure）是 C++ 中一种高级编程技术，它允许我们在运行时处理不同类型的值，而无需在编译时知道具体的类型信息。这种技术本质上是将类型信息“擦除”或隐藏起来，通过动态多态或其他机制来统一处理多种类型，从而实现更灵活的泛型编程。类型擦除在标准库中被广泛使用，例如 std::function、std::any 和 std::variant 等组件都依赖于它。 下面我将从概念、原理、实现方式、优缺点、实际应用和示例代码等方面详细说明。内容基于 C++11 及后续标准(包括 C++17 和 C++20 的相关改进） 1. 什么是类型擦除？为什么需要它？ 定义：类型擦除是一种设计模式，它通过将具体类型的信息隐藏在抽象接口后面，来实现对多种类型的统一处理。简单来说，就是让代码在编译时“忘记”具体的类型，只保留运行时所需的接口或行为，从而允许存储和操作异构类型的值。 为什么需要类型擦除？ 泛型编程的局限：C++ 的模板（template）是静态的泛型机制，它在编译时生成具体代码，但无法处理运行时动态类型（...
2025-11-04
c++ std::print
概述 C++23 引入了 std::print 和 std::println，这是现代 C++ 对格式化输出的重大改进。相比传统的 printf，这些新函数提供了类型安全、性能优异且易于使用的格式化输出方案。 基本用法 简单输出 #include <print> int main() { // 基本输出 std::print("Hello, World!\n"); // 带换行的输出 std::println("Hello, World!"); return 0; } 格式化输出 #include <print> #include <string> int main() { int age = 25; std::string name = "Alice"; // 格式化输出 std::print("Name: {}, Age: {}\n", name, age); // ...
2025-11-04
C++ std::print
1. 概述 C++23 引入了 std::print 和 std::println，这是现代 C++ 对格式化输出的重大改进。相比传统的 printf，这些新函数提供了类型安全、性能优异且易于使用的格式化输出方案。 2. 基本用法 简单输出 #include <print> int main() { // 基本输出 std::print("Hello, World!\n"); // 带换行的输出 std::println("Hello, World!"); return 0; } 格式化输出 #include <print> #include <string> int main() { int age = 25; std::string name = "Alice"; // 格式化输出 std::print("Name: {}, Age: {}\n", name, age); ...
2023-06-26
C++ 字符串
C++ std::string 的内存分配与 SSO std::string 是 C++ STL 最常用容器。先搞清它在哪里存数据。 重载全局 new/delete 观察： #include <string> #include <iostream> #include <cstdlib> using namespace std; void* operator new(std::size_t size) { cout << "[Allocating " << size << " bytes]\n"; return malloc(size); } int main() { for (int i = 1; i <= 17; ++i) { cout << i << ":" << string(i, '*') << "\n"; } string(16, '*').append(...
CPP
