C++17 新增特性总结

2025-03-04

本文对 C++ 17 引入的新特性做一个概览, 列举其主要用法. 限于文章篇幅, 本文不对新特性做深入探讨, 有兴趣的读者可以查找相关资料做进一步了解.

语言特性

结构化绑定(Structured Bindings)

结构化绑定允许你将一个结构体, 元组或数组的元素直接绑定到命名变量上, 下面是几个 C++17 结构化绑定的示例:

// struct binding
struct Item {
  int id;
  std::string name;
};

Item item = {1, "item"};
auto [id, name] = item;

std::map<std::string, int> scores = {
    {"Alice", 85}, {"Bob", 90}, {"Charlie", 78}};
// 绑定std::pair
for (const auto& [key, value] : scores) {
  std::cout << key << ": " << value << '\n';
}

// 绑定tuple
auto t1 = std::tuple<int, int, int>{1, 2, 3};
auto [x, y, z] = t1;

带初始化的 `if`/`switch`

在下面的例子中, if语句中声明了一个局部变量it, 并且在if语句块中使用这个变量.

// if 语句中初始化变量
if (auto it = scores.find("Bob"); it != scores.end()) {
  std::cout << "找到了元素 Bob" << std::endl;
}

// 在 switch 语句中初始化变量
switch (auto score = scores["Bob"]; score / 10) {
  case 9:
    std::cout << "Bob 的成绩等级是 A" << std::endl;
    break;
  case 8:
    std::cout << "Bob 的成绩等级是 B" << std::endl;
    break;
  case 7:
    std::cout << "Bob 的成绩等级是 C" << std::endl;
    break;
  default:
    std::cout << "Bob 的成绩等级未知" << std::endl;
}

`inline` 功能增强

C++17 增加了两个新的特性:

在头文件中用inline修饰变量, 而不用担心重复定义的问题.
在类中声明static inline成员变量时, 可以直接初始化.

#pragma once

class sample {
  inline static int default_value = 47; /* C++ 17支持内联定义, 无需分开初始化 */
};

inline int global_uuid = 0; /* C++ 17新特性, 被多个文件include也不会出现冲突 */

更多类初始化的内容: C++ 类成员初始化发展历程(从 C++11 到 C++20)

聚合扩展

在 C++17 之前, 从其他结构派生的结构会禁用聚合初始化, 开发者必须定义构造函数. C++17 引入聚合体扩展后, 聚合体可以拥有基类, 支持使用花括号进行列表初始化, 并且可以省略一些嵌套括号, 使代码更加简洁.

struct Data {
  std::string name;
  double value;
};
struct MoreData : Data {
  bool done;
};
MoreData md1{{"test1", 6.778}, false}; // 使用嵌套括号进行初始化
MoreData md2{"test1", 6.778, false};   // 当基类或子对象只接受一个值时, 可省略嵌套括号

强制省略拷贝

在 C++17 之前, 复制省略(Copy Elision)是一种编译器优化手段, 允许编译器在某些情况下省略对象的复制或移动操作, 但这并非强制要求, 代码仍然需要保证复制构造函数和移动构造函数的可调用性.

而在 C++17 中, 在特定的初始化场景下, 复制省略成为强制规则, 即使类没有定义复制或移动构造函数, 相关的初始化操作也能正常进行.

强制复制省略的场景:

返回临时对象: 当函数按值返回一个临时对象(prvalue)时, 强制复制省略会发生, 直接在调用处初始化目标对象, 而不会进行复制或移动操作.
直接初始化: 使用临时对象直接初始化另一个对象时, 也会触发强制复制省略.

class MCE {
  int x;

  public:
  MCE() { std::cout << "Constructor called" << std::endl; }
  // 显式删除复制构造函数
  MCE(const MCE&) = delete;
  // 显式删除移动构造函数
  MCE(MCE&&) = delete;
  ~MCE() { std::cout << "Destructor called" << std::endl; }
};

auto createObject = []() { return MCE(); };

MCE mce2 = createObject(); // 返回临时对象
MCE mce1 = MCE();          // 直接初始化

lambda 表达式增强

`constexpr` lambda

auto l1 = [](auto x) constexpr { return x * x; };  // OK
constexpr int ci1 = l1(2);

lambda 捕获 `*this`

class C {
 private:
  std::string name;

 public:
  void foo() {
    auto l1 = [*this] { std::cout << name << '\n'; };
  }
};

嵌套的命名空间

// before
namespace Company {
namespace Project {
namespace Component {
class Foo;
}  // namespace Component
}  // namespace Project
}  // namespace Company

// c++ 17
namespace Company::Project::Component {
class Foo;
}

新增 attributes

[[nodiscard]]: 用于标记函数返回值不应该被忽略. 如果忽略带有 [[nodiscard]] 属性的函数返回值, 编译器通常会给出警告, 有助于避免因忽略重要返回值而可能导致的逻辑错误.
```
[[nodiscard]] int openFile(const char* path) {
  int fd = -1;
  // ...
  return fd;
}
```

[[fallthrough]]: 用于在 switch 语句中显式表明允许从一个 case 标签穿透下降到下一个 case 标签, 避免编译器给出警告.

void comment(int place) {
  switch (place) {
    case 1:
      std::cout << "非常 ";
      [[fallthrough]];
    case 2:
      std::cout << "好\n";
      break;
    default:
      std::cout << "一般\n";
      break;
  }
}

[[maybe_unused]]: 用于告诉编译器某个变量, 函数参数, 类成员等可能不会被使用, 从而避免编译器给出未使用变量的警告.

void processData([[maybe_unused]] int value, double factor) {
  // 这里没有使用 value 参数, 但由于 [[maybe_unused]] 标记, 不会产生警告
  double result = factor * 2;
  std::cout << "Result: " << result << std::endl;
}

utf-8 字符字面量

从 C++11 开始有 string 类型的字面量, C++17 引入了 utf-8 字符串字面量.

// u8 char literals
char c = u8'a';          // ASCII
char16_t ch = u'猫';     // 中文字符
char32_t emoji = U'🍌';  // emoji

更多关于字面量的内容: Modern C++ 字面量一网打尽

`noexcept` 限定符成为类型系统的一部分

在 C++17 中, noexcept关键字被引入了类型系统中, 意味着是否有noexcept将影响函数类型.

void f1(int x) noexcept;
void f2(int x);

f1 和f2是不同的类型.

class Base {
  public:
  virtual void foo() noexcept;
};
class Derived : public Base {
  public:
  void foo() override;  // ERROR: does not override
};

表达式求值顺序

C++17 中, 规定了表达式求值顺序如下:

如下形式的表达式中, e1先于e2求值
- e1[e2]
- e1.e2
- e1.*e2
- e1->*e2
- e1 << e2
- e1 >> e2
赋值语句中, 右侧的表达式先求值
- e2 = e1
- e2 += e1
- e2 *= e1
new Type(e)操作符中, 先分配内存, 再计算参数e

样例代码

i = ++i + 2;            // well-defined
i = i++ + 2;            // undefined behavior until C++17
a[i] = i++;             // undefined behavior until C++17
std::cout << i << i++;  // undefined behavior until C++17
i = ++i + i++;          // undefined behavior
int n = ++i + i;        // undefined behavior

放松枚举从整型初始化的限制

在 C++17 之前, 对于具有固定底层类型的枚举, 使用整数值进行直接列表初始化是不允许的, 而 C++17 放宽了这一限制.

// 无作用域枚举, 指定底层类型为char
enum Enum1 : char {};
Enum1 i1{42};     // OK since C++17 (ERROR before C++17)
Enum1 i2 = 42;    // 仍然错误
Enum1 i3(42);     // 仍然错误
Enum1 i4 = {42};  // 仍然错误

// 有作用域枚举, 默认底层类型
enum class Enum2 { mon, tue, wed, thu, fri, sat, sun };
Enum2 s1{0};     // OK since C++17 (ERROR before C++17)
Enum2 s2 = 0;    // 仍然错误
Enum2 s3(0);     // 仍然错误
Enum2 s4 = {0};  // 仍然错误

// 有作用域枚举, 指定底层类型为char
enum class Enum3 : char { mon, tue, wed, thu, fri, sat, sun };
Enum3 s5{0};  // OK since C++17 (ERROR before C++17)

Enum3 s6 = 0;    // 仍然错误
Enum3 s7(0);     // 仍然错误
Enum3 s8 = {0};  // 仍然错误

// 无作用域枚举, 未指定底层类型
enum Enum4 { bit1 = 1, bit2 = 2, bit3 = 4 };
Enum4 f1{0};  // 仍然错误

// 尝试进行窄化转换, 仍然错误
enum Enum5 : char {};
Enum5 i5{42.2};  // 仍然错误

改进`auto`直接初始化行为

auto类型推到的行为在 C++17 中进行了修改:

// C++ 17 之前
auto at1{42};    // 类型为: std::initializer_list<int>
auto at2{1,2,3}; // OK: 类型为: std::initializer_list<int>
// C++17
auto at1{42};       // 类型为int
auto at2{1, 2, 3};  // Error

hexadecimal floating literals

单个参数的 `static_assert`

static_assert 允许只有一个参数.

// C++17 之前
static_assert(std::is_default_constructible<T>::value, "class C: elements must be default-constructible");
// C++17
static_assert(std::is_default_constructible_v<T>);

预处理宏 `__has_include`

检查特定的头文件是否能被包含. 也就是检查系统是否存在该头文件.

#if __has_include(<filesystem>)
#include <filesystem>
#define HAS_FILESYSTEM 1
#elif __has_include(<experimental/filesystem>)
#include <experimental/filesystem>
#define HAS_FILESYSTEM 1
#define FILESYSTEM_IS_EXPERIMENTAL 1
#elif __has_include("filesystem.hpp")
#include "filesystem.hpp"
#define HAS_FILESYSTEM 1
#define FILESYSTEM_IS_EXPERIMENTAL 1
#else
#define HAS_FILESYSTEM 0
#endif

模板编程

类模板参数推导

Class Template Argument Deduction (CTAD) 允许编译器根据传递给构造函数的参数自动推导模板参数类型, 从而简化了模板类的使用. 在此之前, 必须显式指定所有模板参数类型. CTAD 支持多种初始化方式, 并且可以用于函数模板, 类模板和通用库.

容器元素类型的推导: 例如, std::vector v1{1, 2, 3}; 自动推导为 std::vector<int>.

std::vector v1{1, 2, 3};           // std::vector<int>
std::vector v2{"hello", "world"};  // std::vector<const char*>

非类型模板参数的推导: 可以从传递的初始数组中推导元素类型和大小, 例如:

template <typename T, int SZ>
class MyClass {
public:
  MyClass(T (&)[SZ]) {}
};

MyClass mc("hello");  // deduces T as const char and SZ as 6

变参模板的支持: 例如, std::tuple 可以自动推导多个类型:

std::tuple t{42, 'x', nullptr}; // 推导为 std::tuple<int, char, std::nullptr_t>

编译时 if

编译时 if(Compile-Time if) 允许在编译时根据条件选择执行不同的代码分支. 与运行时的 if 语句不同, if constexpr 只会在编译时评估其条件, 并且只有满足条件的分支会被实例化和编译, 不满足条件的分支则会被完全忽略. 这一特性在模板编程中特别有用, 因为它可以避免无效代码路径导致的编译错误.

类型转换和处理

根据传入参数的类型自动选择合适的处理逻辑, 例如字符串, 整数或浮点数的不同处理方式.

template <typename T>
std::string asString(T x) {
  if constexpr (std::is_same_v<T, std::string>) {
    return x;  // 直接返回字符串类型
  } else if constexpr (std::is_arithmetic_v<T>) {
    return std::to_string(x);  // 转换为字符串
  } else {
    return std::string(x);  // 尝试转换为字符串
  }
}

返回值完美转发

当需要对返回值进行处理后再返回时, 可以根据返回类型是否为 void 来决定如何处理.

template <typename Callable, typename... Args>
decltype(auto) call(Callable op, Args&&... args) {
  if constexpr (std::is_void_v<std::invoke_result_t<Callable, Args...>>) {
    // 返回类型是 void
    op(std::forward<Args>(args)...);
    // 执行其他操作...
    return;
  } else {
    // 返回类型不是 void
    decltype(auto) ret{op(std::forward<Args>(args)...)};
    // 执行其他操作...
    return ret;
  }
}

标签调度

可以在一个函数内实现多态行为, 而不需要为每种类型提供重载函数.

template <typename Iterator, typename Distance>
void Advance(Iterator& pos, Distance n) {
  using cat = std::iterator_traits<Iterator>::iterator_category;
  if constexpr (std::is_same_v<cat, std::random_access_iterator_tag>) {
    pos += n;
  } else if constexpr (std::is_same_v<cat, std::bidirectional_iterator_tag>) {
    if (n >= 0) {
      while (n--) {
        ++pos;
      }
    } else {
      while (n++) {
        --pos;
      }
    }
  } else {  // input_iterator_tag
    while (n--) {
      ++pos;
    }
  }
}

更多阅读:

折叠表达式(Fold Expressions)

Fold Expressions (折叠表达式) 提供了一种简洁的方法来对参数包(parameter pack)中的所有元素应用二元操作符. 这项特性极大地简化了模板编程中对变长参数列表的操作, 避免了递归模板实例化带来的复杂性和性能开销.

基本概念

折叠表达式允许使用一个二元操作符将参数包中的所有元素"折叠"成单一结果.
支持两种主要形式: 左折叠(left fold)和右折叠(right fold).
- 左折叠: (... op args), 例如 ((arg1 op arg2) op arg3) op ...
- 右折叠: (args op ...), 例如 arg1 op (arg2 op (arg3 op ...))

应用场景

简单的数值求和: 可以轻松实现对多个参数的加法操作.

template <typename... T>
auto foldSum(T... args) {
  return (... + args);  // 左折叠
}

字符串连接: 通过折叠表达式连接多个字符串或标准库类型对象.

template <typename... T>
std::string foldConcat(T... args) {
  return (... + std::string(args));  // 左折叠
}

类型检查: 用于检查一组类型是否相同(如判断是否为同质类型).

template <typename T1, typename... TN>
constexpr bool isHomogeneous(T1, TN...) {
  return (std::is_same_v<T1, TN> && ...);
}

将字符串作为模板参数

C++17 允许在模板中使用字符串字面量(string literals)作为非类型模板参数. 这项特性扩展了模板编程的能力, 使得可以更灵活地处理字符串常量.

非类型模板参数可以是整型值(包括枚举), 指向对象/函数/成员的指针, 左值引用或 std::nullptr_t 类型.
在 C++17 之前, 不能直接将字符串字面量传递给模板参数, 因为它们需要链接属性(linkage), 而字符串字面量没有链接属性.
C++17 允许具有内部链接(internal linkage)的指针作为非类型模板参数, 从而可以直接在模板中使用字符串字面量.

#include <iostream>

// 定义一个模板类, 接受一个常量字符指针作为模板参数
template <const char* str>
class Message {
 public:
  void print() const { std::cout << str << std::endl; }
};

// 定义字符串变量, 分别具有外部链接, 内部链接
extern const char external[] = "Hello, World!";  // 外部链接
const char internal[] = "Hello, Internal!";      // 内部链接

int main() {
  // 使用具有外部链接的字符串, 所有版本都支持
  Message<external> msg_external;  // all version
  msg_external.print();            // 输出: Hello, World!

  // 使用具有内部链接的字符串(C++11及更高版本)
  Message<internal> msg_internal;
  msg_internal.print();  // 输出: Hello, Internal!

  // 使用无链接的字符串(仅在C++17及以上版本支持)
  static const char hello_world_no_link[] = "Hello, No Link!";  // 无链接
  Message<hello_world_no_link> msg_no_link;
  msg_no_link.print();  // 输出: Hello, No Link!

  return 0;
}

`auto` 作为模板参数

C++17 允许在模板中使用auto关键字来声明非类型的模板参数. 这项特性使得模板可以接受不同类型和值的参数, 从而增强了模板编程的灵活性和通用性.

基本概念

在 C++17 之前, 非类型的模板参数必须是具体类型(如整型, 指针等), 并且类型必须在模板定义时明确指定.
使用auto作为模板参数, 可以让编译器根据实际传递的参数自动推导出其类型和值, 而不需要显式指定类型.
可以使用auto声明非类型模板参数, 支持多种类型, 如整数, 字符, 布尔值等, 但不支持浮点数类型.

应用场景
- 编译时常量表达式的简化: 可以通过auto更简洁地定义编译时常量.
- 变量模板中的应用: 可以在变量模板中使用auto作为模板参数, 进一步增强模板的灵活性.

使用`auto`作为非类型模板参数

通过使用auto, 可以避免为每个可能的类型编写多个模板特化版本.

#include <iostream>

// 定义一个模板类, 使用auto作为非类型模板参数
template<auto N>
class S {
public:
    static void print() {
        std::cout << "Value: " << N << ", Type: " << typeid(N).name() << std::endl;
    }
};

int main() {
    // 使用不同类型的常量初始化模板
    S<42> s1;  // int 类型
    S<'a'> s2; // char 类型
    // S<2.5> s3; // 错误: double 类型不被支持

    s1.print(); // 输出: Value: 42, Type: i
    s2.print(); // 输出: Value: a, Type: c

    return 0;
}

使用`auto`定义编译时常量

#include <iostream>

// 定义一个模板结构体, 使用auto作为模板参数
template <auto v>
struct Constant {
  static constexpr auto value = v;
};

int main() {
  // 使用不同的常量初始化模板
  using IntConstant = Constant<42>;
  using CharConstant = Constant<'x'>;
  using BoolConstant = Constant<true>;

  std::cout << "IntConstant: " << IntConstant::value
            << std::endl;  // 输出: IntConstant: 42
  std::cout << "CharConstant: " << CharConstant::value
            << std::endl;  // 输出: CharConstant: x
  std::cout << "BoolConstant: " << BoolConstant::value
            << std::endl;  // 输出: BoolConstant: 1

  return 0;
}

扩展的 using 声明(Extended Using Declarations)

C++17 允许在类定义中使用逗号分隔的列表来导入多个基类成员. 这项特性简化了代码编写, 减少了冗余, 并提高了代码的可读性和维护性.

功能特性

Using 声明扩展: C++17 允许在一个using声明中通过逗号分隔的方式导入多个基类成员.
变长模板参数包: 可以利用变长模板参数包(variadic template parameter packs)和using声明来泛化地继承操作.

示例 1: 多基类成员导入

可以在派生类中通过一个using声明导入多个基类成员, 而不需要为每个成员单独写一个using声明.

#include <iostream>

class Base {
 public:
  void a() { std::cout << "Base::a\n"; }
  void b() { std::cout << "Base::b\n"; }
  void c() { std::cout << "Base::c\n"; }
};

class Derived : private Base {
 public:
  // 使用逗号分隔的using声明导入多个基类成员
  using Base::a, Base::b, Base::c;
};

int main() {
  Derived d;
  d.a();  // 输出: Base::a
  d.b();  // 输出: Base::b
  d.c();  // 输出: Base::c
}

示例 2: Lambda 重载集

通过使用using声明, 可以从传递的基础类型中"继承"所有函数调用操作符, 从而创建一组 lambda 重载.

#include <iostream>
#include <string>

// 定义一个结构体模板, 用于"继承"所有函数调用操作符
template <typename... Ts>
struct Overload : Ts... {
  using Ts::operator()...;  // 使用using声明使所有操作符可用
};

// 基类型推导指南
template <typename... Ts>
Overload(Ts...) -> Overload<Ts...>;

int main() {
  // 创建一个包含两个lambda表达式的Overload对象
  auto twice =
      Overload{[](std::string& s) { s += s; }, [](auto& v) { v *= 2; }};

  int i = 42;
  twice(i);                         // 调用第二个lambda
  std::cout << "i: " << i << '\n';  // 输出: i: 84

  std::string s = "hi";
  twice(s);                         // 调用第一个lambda
  std::cout << "s: " << s << '\n';  // 输出: s: hihi
}

示例 3: 构造函数继承

可以通过using声明继承基类的所有构造函数, 减少重复代码.

#include <iostream>
#include <string>

template <typename T>
class Base {
  T value{};

 public:
  Base() : value{} {}
  Base(T v) : value{v} {}

  void print() const { std::cout << "Value: " << value << '\n'; }
};

template <typename... Types>
class Multi : private Base<Types>... {
 public:
  // 继承所有基类的构造函数
  using Base<Types>::Base...;

  // 提供一个统一的 print 接口
  void print() const {
    // 使用折叠表达式依次调用每个基类的 print 函数
    (static_cast<Base<Types> const*>(this)->print(), ...);
  }

  // 提供特定类型的 print 函数
  template <typename T>
  void print_specific() const {
    static_cast<Base<T> const*>(this)->print();
  }
};

int main() {
  // 使用Multi<> 类型声明三个不同类型的对象
  using MultiISB = Multi<int, std::string, bool>;

  MultiISB m1 = 42;                    // 调用Base<int>的构造函数
  MultiISB m2 = std::string("hello");  // 调用Base<std::string>的构造函数
  MultiISB m3 = true;                  // 调用Base<bool>的构造函数

  m1.print_specific<int>();          // 输出: Value: 42
  m2.print_specific<std::string>();  // 输出: Value: hello
  m3.print_specific<bool>();         // 输出: Value: 1

  return 0;
}

新增标准库工具

`std::optional`

#include <iostream>
#include <optional>

int main() {
  auto print = [](auto optional) {
    if (optional) {
      std::cout << "optional contains value: " << *optional << std::endl;
    } else {
      std::cout << "optional does not contain a value" << std::endl;
    }
  };

  std::optional<int> optional;  // 空的 optional
  print(optional);

  optional = 42;
  print(optional);

  optional.reset();  // 清空 optional
  print(optional);

  return 0;
}

关于std::optional, std::variant和std::any的更多信息, 可以参考: 现代 C++ 必备知识: 解锁 std::optional, std::variant 和 std::any

`std::variant`

std::variant<int, std::string> var;
auto print = [](auto&& arg) {};
var = 42;
std::cout << "var contains an int: " << std::get<int>(var) << std::endl;

var = "hello";
std::cout << "var contains a string: " << std::get<std::string>(var)
          << std::endl;

// 使用 std::holds_alternative 检查当前存储的类型
if (std::holds_alternative<int>(var)) {
  std::cout << "var is an int" << std::endl;
} else if (std::holds_alternative<std::string>(var)) {
  std::cout << "var is a string" << std::endl;
}

关于std::optional, std::variant和std::any的更多信息, 可以参考: 现代 C++ 必备知识: 解锁 std::optional, std::variant 和 std::any

`std::any`

std::any anyVal;

anyVal = 42;
std::cout << "anyVal contains an int: " << std::any_cast<int>(anyVal)
          << std::endl;

anyVal = "hello";
std::cout << "anyVal contains a string: "
          << std::any_cast<const char*>(anyVal) << std::endl;

// 使用 type() 检查当前存储的类型
if (anyVal.type() == typeid(int)) {
  std::cout << "anyVal is an int" << std::endl;
} else if (anyVal.type() == typeid(std::string)) {
  std::cout << "anyVal is a string" << std::endl;
}

关于std::optional, std::variant和std::any的更多信息, 可以参考: 现代 C++ 必备知识: 解锁 std::optional, std::variant 和 std::any

`std::byte`

std::byte b1{0x1F};    // 初始化为 0x1F
std::byte b2{0b1010};  // 使用二进制初始化

// 使用 std::to_integer 转换为整数
int intVal = std::to_integer<int>(b1);
std::cout << "b1 as int: " << intVal << std::endl;

// 使用位运算
std::byte b3 = b1 & b2;
std::cout << "b1 & b2: " << std::to_integer<int>(b3) << std::endl;

// 使用 |= 运算符
b1 |= b2;
std::cout << "b1 |= b2: " << std::to_integer<int>(b1) << std::endl;

string views

#include <iostream>
#include <string_view>

void print(std::string_view sv) {
  std::cout << "string view: " << sv << std::endl;
}

int main() {
  std::string normalStr = "This is a test";
  print(normalStr);

  const char* cStr = "Another test";
  print(cStr);

  return 0;
}

进一步阅读: 深入理解 C++ std::string_view — 高效字符串操作的利器

`filesystem` 库

// 创建一个目录
fs::path dirPath = "example_dir";
if (!fs::exists(dirPath)) {
  fs::create_directory(dirPath);
  std::cout << "Directory created: " << dirPath << std::endl;
} else {
  std::cout << "Directory already exists: " << dirPath << std::endl;
}

// 创建一个文件并写入内容
fs::path filePath = dirPath / "example.txt";
// 文件属性
fs::file_status status = fs::status(filePath);
std::cout << "File exists: " << fs::exists(status) << std::endl;
std::cout << "Is regular file: " << fs::is_regular_file(status) << std::endl;
std::cout << "File size: " << fs::file_size(filePath) << " bytes"
          << std::endl;

// 检查文件是否存在
if (fs::exists(filePath)) {
  std::cout << "File exists: " << filePath << std::endl;
} else {
  std::cout << "File does not exist: " << filePath << std::endl;
}

关于filesystem库的更多信息, 可以参考: C++17 文件系统库

类型系统(type traits) 扩展

C++17 新增了_v后缀的类型特征，如：

std::is_const_v<T> // 等价于 std::is_const<T>::value

关于 type traits 的更多内容, 请参考: [理解 C++ Type Traits]/posts/understand-cpp-type-traits/

parallel STL algorithms

给 STL 新增了执行策略.

#include <algorithm>
#include <execution>
#include <iostream>
#include <vector>

int main() {
  // 创建一个包含一些整数的向量
  std::vector<int> numbers = {5, 6, 7, 8, 9, 10, 1, 2, 3, 4};

  // 使用并行版本的 std::for_each 对向量中的每个元素进行处理
  std::sort(std::execution::par, numbers.begin(), numbers.end());

  // 输出处理后的向量
  std::cout << "Processed numbers: ";
  for (const auto& num : numbers) {
    std::cout << num << " ";
  }
  std::cout << std::endl;

  return 0;
}

关于 STL 算法执行策略的更多信息, 请参考: C++17 并行计算利器: 深入理解 std::execution 及其性能优化`

子串和子序列的搜索算法

C++17 引入了 Boyer-Moore and Boyer-Moore-Horspool 搜索算法.

std::string text = "ABAAABCD";
std::string pattern = "ABC";

// default_searcher
auto p0 = std::search(text.begin(), text.end(),
                      std::default_searcher{pattern.begin(), pattern.end()});

// boyer_moore_searcher
auto p1 = std::search(text.begin(), text.end(),
             std::boyer_moore_searcher{pattern.begin(), pattern.end()});

// boyer_moore_horspool_searcher
auto p2 = std::search(text.begin(), text.end(),
             std::boyer_moore_horspool_searcher{pattern.begin(), pattern.end()});

other utilities

size(), empty() and data(): 通用版本的, 并非成员函数的

std::vector<int> vec = {1, 2, 3, 4, 5};
std::array<int, 5> arr = {10, 20, 30, 40, 50};
std::string str = "Hello, World!";

std::empty(vec);
std::empty(arr);
std::empty(str);

std::size(vec);
std::size(arr);
std::size(str);

std::data(vec);
std::data(arr);
std::data(str);

std::as_const(): 将参数转为 const 类型

clamp(): 如果数值v在范围[lower, upper]内, 返回v, 否则返回离它最近的值

int value = 15;
int low = 10, high = 20;
// 使用 std::clamp
fmt::println("std::clamp: {}", std::clamp(value, low, high));
// 预期输出: std::clamp: 15

sample(): 取样函数

constexpr std::array v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::vector<int> result(3);  // 抽样结果存储的容器

// 创建随机数引擎
std::random_device rd;
std::mt19937 gen(rd());

// 使用 std::sample
std::sample(v.begin(), v.end(), result.begin(), 3, gen);
fmt::println("std::sample: {}", result);

// 使用 std::ranges::sample
std::ranges::sample(v, result.begin(), 3, gen);
fmt::println("std::ranges::sample: {}", result);

for_each_n(): 迭代器版本

std::vector  v = {1, 2, 3, 4, 5};
// for_each_n (C++17)
std::for_each_n(v.begin(), 3, [](int& n) { n = 2; });
fmt::println("{}", v);  // [2, 2, 2, 1, 1]

多线程和并发

supplementary synchronization primitives
std::shared_mutex/ std::scoped_lock: 参考现代 C++锁介绍
is_always_lock_free

删除的特性

std::auto_ptr
deprecated function objects
std::random_shuffle
std::unexpected
the obsolete iostreams aliases,
trigraphs
the register keyword,
bool increment,
dynamic exception specification

Tags:

C++17

最新帖子
Hugo Shortcode 实现Markdown多标签页代码
C++20 新特性总结
VS Code C++ 开发环境配置
C++17 新增特性总结
C++核心指导原则: 其他杂项

热门帖子
WSL2 编译安装 perf
C++ constexpr, consteval和 constinit简要介绍
Modern C++ Ranges/View库简介
CMake构建C++20 Module实例(使用MSVC)
C++26 新特性预览(Preview)
深入解析 C++ 类型转换
CMake 入门教程: 从基础到实践
C++ 类成员初始化发展历程(从C++11到C++20)
C++23 新特性总结

文章分类	数量
C++	68
开发环境	9
博客搭建	2
书评	1

标签
#core guidelines 16	#c++20 9
#language features 6	#c++23 4
#dev container 4	#modern cpp 4
#c++17 3	#best practice 2
#c++26 2	#compile 2
#constexpr 2	#hugo 2
#std::atomic 2	#asan 1
#attributes 1	#c++ insights 1
#c++字面量 1	#casting 1
#clang 1	#class template 1

相关帖子
C++17 Filesystem 实用指南
C++17并行计算利器: 深入理解std::execution及其性能优化

C++17 新增特性总结

语言特性

结构化绑定(Structured Bindings)

带初始化的 if/switch

inline 功能增强

聚合扩展

强制省略拷贝

lambda 表达式增强

constexpr lambda

lambda 捕获 *this

嵌套的命名空间

新增 attributes

utf-8 字符字面量

noexcept 限定符成为类型系统的一部分

表达式求值顺序

放松枚举从整型初始化的限制

改进auto直接初始化行为

hexadecimal floating literals

单个参数的 static_assert

预处理宏 __has_include

模板编程

类模板参数推导

编译时 if

类型转换和处理

返回值完美转发

标签调度

折叠表达式(Fold Expressions)

将字符串作为模板参数

auto 作为模板参数

使用auto作为非类型模板参数

使用auto定义编译时常量

扩展的 using 声明(Extended Using Declarations)

示例 1: 多基类成员导入

示例 2: Lambda 重载集

示例 3: 构造函数继承

新增标准库工具

std::optional

std::variant

std::any

std::byte

string views

filesystem 库

类型系统(type traits) 扩展

parallel STL algorithms

子串和子序列的搜索算法

other utilities

多线程和并发

删除的特性

带初始化的 `if`/`switch`

`inline` 功能增强

`constexpr` lambda

lambda 捕获 `*this`

`noexcept` 限定符成为类型系统的一部分

改进`auto`直接初始化行为

单个参数的 `static_assert`

预处理宏 `__has_include`

`auto` 作为模板参数

使用`auto`作为非类型模板参数

使用`auto`定义编译时常量

`std::optional`

`std::variant`

`std::any`

`std::byte`

`filesystem` 库