C++17

C++17 是ぜC++規格きかく委員いいん會かい於2017年ねん制定せいてい的てき規格きかく（ISO/IEC 14882），接せっ替がえC++14規格きかく，後ご被かむC++20規格きかく取と代だい。

歷史れきし

在ざいC++規格きかく委員いいん會かい制定せいてい此次的てき三さん年ねん期き規格きかく之の前まえ，C++17規格きかく的てき發布はっぷ日び期き是ぜ不ふ確定かくてい的てき。在ざい這段日び期き中ちゅう，C++17草案そうあん（draft）也被稱たたえ為ためC++1z，正せい如C++11草案そうあん名めいC++0x或あるC++1x，C++14草案そうあん名めいC++1y。C++17規格きかく於2017年ねん3月がつ完成かんせい國際こくさい規格きかく草案そうあん（Draft International Standard DIS）階段かいだん，並なみ於同年どうねん12月がつ完成かんせい最終さいしゅう規格きかく發布はっぷ。17規格きかく對たいC++語法ごほう進行しんこう了りょう加か強きょう，並なみ對たい規格きかく模も板いた庫こ進行しんこう了りょう些許修おさむ改あらため，如給<algorithm>庫くら中ちゅう演算えんざん法ほう增加ぞうか了りょう執行しっこう策略さくりゃくexecution以支援しえん平行へいこう計算けいさん。

新しん功こう能のう

• 靜態せいたい斷言だんげんstatic_assert無む需提供出きょうしゅつ錯資訊
• 移うつり除じょ trigraphs
• 具有ぐゆう模も板ばん形式けいしき的てき模も板ばん（template template）參さん數すう允許いんきょ使用しよう typename（之これ前ぜん僅允許いんきょ使用しよう class）
• std::uncaught_exceptions 取と代だい std::uncaught_exception
• 變へん長ちょう參さん數すう模も板ばん的てきFolding運算うんざん
• 容器ようき存そん取と操作そうさ表示ひょうじ方法ほうほう的てき統一とういつ化か（Uniform container access）
• 連續れんぞく型がた迭代器き（Contiguous Iterators）
• 新しん增ぞう特殊とくしゅ數學すうがく函はこ式しき
• 引進Library Fundamentals TS I中なか的てき內容

類別るいべつ模も板ばん的てき模も板ばん參さん數すう推導

模かたぎ板いた類るい构造式能しきのう自動じどう推導模も板ばん參さん數すう的てき型がた别(Class template argument deduction, CTAD)。例れい如允許いんきょ以pair(5.0, false) 取と代がわpair<double,bool>(5.0, false)

template <typename T = float>
struct MyContainer {
  T val;
  MyContainer() : val{} {}
  MyContainer(T val) : val{val} {}
  // ...
};
MyContainer c1 {1}; // OK MyContainer<int>
MyContainer c2; // OK MyContainer<float>

任にん何なん指定してい變數へんすう或ある變數へんすう模も板ばん的てき初はつ始はじめ化か的てき宣告せんこく，其宣告せんこく的てき型がた别是類別るいべつ模も板ばん（可能かのう是ぜ cv 限定げんてい的てき）。如std::pair p(2, 4.5); // deduces to std::pair<int, double> p(2, 4.5); new表ひょう達たち式しき，如template<class T>struct A{ A(T, T);}; auto y = new A{1, 2}; // allocated type is A<int>

用ようauto宣告せんこく非ひ型かた别模板ばん參さん數すう

依據いきょauto的てき推到規則きそく，在ざい可か允許いんきょ型がた别的非ひ型かた别模板ばん參さん數すう情況じょうきょう下か，可か從したがえ實じつ參さん型がた别推導出どうしゅつ模も板ばん參さん數すう：

template <auto... seq>
struct my_integer_sequence {
  // Implementation here ...
};

// Explicitly pass type `int` as template argument.
auto seq = std::integer_sequence<int, 0, 1, 2>();
// Type is deduced to be `int`.
auto seq2 = my_integer_sequence<0, 1, 2>();

摺すり疊表たたみおもて達たち式しき

摺すり疊表たたみおもて達たち式しき在ざい運算うんざん子こ上じょう執行しっこう模も板ばん參さん數すう包つつみ的てき展開てんかい計算けいさん。

• 單元たんげん摺すり疊たたみ：形かたち如 (... op e) or (e op ...)表ひょう達たち式しき，其中 op 是ぜ摺すり疊たたみ運算うんざん子こ，e 是ぜ未み展開てんかい的てき模も板ばん參さん數すう包つつみ。
• 二元にげん摺すり疊たたみ：形かたち如(e1 op ... op e2)表ひょう達たち式しき， 其中 op 是ぜ摺すり疊たたみ運算うんざん子こ，e1或あるe2 是ぜ未み展開てんかい的てき模も板ばん參さん數すう包つつみ。

template <typename... Args>
bool logicalAnd(Args... args) {
    // Binary folding.
    return (true && ... && args);
}
bool b = true;
bool& b2 = b;
logicalAnd(b, b2, true); // == true

template <typename... Args>
auto sum(Args... args) {
    // Unary folding.
    return (... + args);
}
sum(1.0, 2.0f, 3); // == 6.0

大だい括くく號ごう初はつ始はじめ化か串くし列れつ的てき新しん的てき自動じどう推導規則きそく

以前いぜんauto x {3}; 將はた被ひ推導為ためstd::initializer_list<int>, 現在げんざい推導為ためint。

auto x1 {1, 2, 3}; // error: not a single element
auto x2 = {1, 2, 3}; // x2 is std::initializer_list<int>
auto x3 {3}; // x3 is int
auto x4 {3.0}; // x4 is double

constexpr lambda

auto identity = [](int n) constexpr { return n; };
static_assert(identity(123) == 123);

constexpr auto add = [](int x, int y) {
  auto L = [=] { return x; };
  auto R = [=] { return y; };
  return [=] { return L() + R(); };
};

static_assert(add(1, 2)() == 3);

constexpr int addOne(int n) {
  return [n] { return n + 1; }();
}

static_assert(addOne(1) == 2);

Lambda函はこ式しき中ちゅう按值擷取this指標しひょう

以前いぜんthis指標しひょう在ざいlambda函はこ式しき只ただ能のう按參考さんこう擷取。現在げんざい *this 擷取對象たいしょう的てき副本ふくほん，而 this (C++11)繼續けいぞく擷取參考さんこう。

struct MyObj {
  int value {123};
  auto getValueCopy() {
    return [*this] { return value; };
  }
  auto getValueRef() {
    return [this] { return value; };
  }
};
MyObj mo;
auto valueCopy = mo.getValueCopy();
auto valueRef = mo.getValueRef();
mo.value = 321;
valueCopy(); // 123
valueRef(); // 321

行くだり內變數すう

過去かこ關せき鍵かぎ字じinline可用かよう於函式しき宣告せんこく，現在げんざい也可以用於變數すう宣告せんこく，表示ひょうじ函はこ式しき或ある定義ていぎ可か定義ていぎ（但ただし內容必須ひっす完全かんぜん相しょう同どう）多た次つぎ。這允許いんきょ在ざい標しるべ頭あたま檔中定義ていぎ一いち個こ行ぎょう內變數すう。

• 行くだり內的函はこ式しき或ある變數へんすう必須ひっす在ざい編へん譯やく單元たんげん內可達たち（但ただし不ふ一定いってい在ざい訪問ほうもん點てん之の前まえ）
• 在ざい每まい個こ編へん譯やく單元たんげん中なか都と是これ行ぎょう內宣告せんこく的てき
• 行くだり內變數すう必須ひっす是ぜ靜態せいたい記憶きおく體たい（類るい靜態せいたい成員せいいん或ある命名めいめい空間くうかん作用さよう域いき變數へんすう），不能ふのう用よう於塊作用さよう域いき變數へんすう或ある函はこ式しき作用さよう域いき變數へんすう。

struct S {
  S() : id{count++} {}
  ~S() { count--; }
  int id;
  static inline int count{0}; // declare and initialize count to 0 within the class
};

巢す狀じょう的てき命名めいめい空間くうかん

如下：

namespace A {
  namespace B {
    namespace C {
      int i;
    }
  }
}

//The code above can be written like this:

namespace A::B::C {
  int i;
}

結構けっこう化か繫結

變數へんすう定義ていぎ初はつ始はじめ化か時じ，允許いんきょ形がた如 auto [ x, y, z ] = expr;，其中expr的てき「元もと組くみ類似るいじ的てき對象たいしょう」包括ほうかつstd::tuple, std::pair, std::array等とう聚合結構けっこう。

using Coordinate = std::pair<int, int>;
Coordinate origin() {
  return Coordinate{0, 0};
}

const auto [ x, y ] = origin();
x; // == 0
y; // == 0

std::unordered_map<std::string, int> mapping {
  {"a", 1},
  {"b", 2},
  {"c", 3}
};

// Destructure by reference.
for (const auto& [key, value] : mapping) {
  // Do something with key and value
}

帶おび初はつ始はじめ化か的てき選擇せんたく述じゅつ句く

if和わswitch述じゅつ句く允許いんきょ如下的てき變數へんすう宣告せんこく和わ初はつ始はじめ化か：

{
  std::lock_guard<std::mutex> lk(mx);
  if (v.empty()) v.push_back(val);
}
// vs.
if (std::lock_guard<std::mutex> lk(mx); v.empty()) {
  v.push_back(val);
}

Foo gadget(args);
switch (auto s = gadget.status()) {
  case OK: gadget.zip(); break;
  case Bad: throw BadFoo(s.message());
}
// vs.
switch (Foo gadget(args); auto s = gadget.status()) {
  case OK: gadget.zip(); break;
  case Bad: throw BadFoo(s.message());
}

constexpr if

//适用场景1：简化模も版ばん偏へん特とく化か的てき写うつし法ほう
template <typename T>
constexpr bool isIntegral() {
  if constexpr (std::is_integral<T>::value) {
    return true;
  } else {
    return false;
  }
}
static_assert(isIntegral<int>() == true);
static_assert(isIntegral<char>() == true);
static_assert(isIntegral<double>() == false);
struct S {};
static_assert(isIntegral<S>() == false);

//适用场景2：编写变参模も版ばん函数かんすう
template<int N, int...Ns>
int Sum()
{
  if constexpr(0 == sizeof...(Ns))
    return N;
  else
    return N+Sum<Ns...> ();
}

//使用しよう场景3：替がえ代だいenable_if。编写模も板ばん函数かんすう时，经常要よう使用しようenable_if语句来らい进行静せい态类型がた检查，保ほ证模板ばん输入的てき类型满足某ぼう种要求ようきゅう
template <typename T>
bool IsOdd(T input){
 if constexpr (std::is_integral<T>::value) //
   return static_cast<bool>(input % 2);
}

utf8字面じめん量りょう

如下：

char x = u8'x';

列れつ舉型别變數すう直接ちょくせつ用よう大だい括くく號ごう初はつ始はじめ化か

enum byte : unsigned char {};
byte b {0}; // OK
byte c {-1}; // ERROR
byte d = byte{1}; // OK
byte e = byte{256}; // ERROR

fallthrough, nodiscard, maybe_unused特性とくせい

C++17 引入了りょう3個こ特性とくせい（attribute）: fallthrough, nodiscard, maybe_unused.

//fallthrough指示しじ编译器き直通ちょくつう一いち个switch语句：
switch (n) {
  case 1: 
    // ...
    [[fallthrough]]
  case 2:
    // ...
    break;
}

//nodiscard引发一いち个警告けいこく，当とう具有ぐゆう该特性せい的てき函数かんすう或ある类的返かえし回かい值被忽ゆるがせ略りゃく：
[[nodiscard]] bool do_something() {
  return is_success; // true for success, false for failure
}

do_something(); // warning: ignoring return value of 'bool do_something()',
                // declared with attribute 'nodiscard'

// Only issues a warning when `error_info` is returned by value.
struct [[nodiscard]] error_info {
  // ...
};

error_info do_something() {
  error_info ei;
  // ...
  return ei;
}

do_something(); // warning: ignoring returned value of type 'error_info',
                // declared with attribute 'nodiscard'

//maybe_unused告つげ诉编译器变量或ある参さん数すう可能かのう未み被ひ使用しよう：
void my_callback(std::string msg, [[maybe_unused]] bool error) {
  // Don't care if `msg` is an error message, just log it.
  log(msg);
}

__has_include運算うんざん子こ

__has_include運算うんざん子こ用よう在ざい#if 和わ #elif表ひょう達たち式しき，以檢查是否ひ一個標頭檔或原始檔可否包含。

//下しも例れい有ゆう两个相しょう同どう作用さよう的てき头文件けん，如果主文しゅぶん件けん不能ふのう包含ほうがん， 就使用しようbackup/experimental头文件けん：
#ifdef __has_include
#  if __has_include(<optional>)
#    include <optional>
#    define have_optional 1
#  elif __has_include(<experimental/optional>)
#    include <experimental/optional>
#    define have_optional 1
#    define experimental_optional
#  else
#    define have_optional 0
#  endif
#endif

//也可以用在ざい不同ふどう位置いち、不同ふどう名字みょうじ但ただし具有ぐゆう相しょう同どう地位ちい的てき头文件けん的てき包含ほうがん：
#ifdef __has_include
#  if __has_include(<OpenGL/gl.h>)
#    include <OpenGL/gl.h>
#    include <OpenGL/glu.h>
#  elif __has_include(<GL/gl.h>)
#    include <GL/gl.h>
#    include <GL/glu.h>
#  else
#    error No suitable OpenGL headers found.
# endif
#endif

std::variant

std::variant模も板いた類るい實じつ做了型がた别安全的ぜんてきunion

std::variant<int, double> v{ 12 };
std::get<int>(v); // == 12
std::get<0>(v); // == 12
v = 12.0;
std::get<double>(v); // == 12.0
std::get<1>(v); // == 12.0

std::optional

std::optional類別るいべつ模も板ばん可能かのう包含ほうがん一個值或者可能不包含值：

std::optional<std::string> create(bool b) {
  if (b) {
    return "Godzilla";
  } else {
    return {};//或ある者もの return std::nullopt;
  }
}

create(false).has_value();//返かえし回かいtrue或あるfalse
*create(false);//返かえし回かい值；如果无值，则返回かいT()
create(false).value_or("empty"); // == "empty"
create(true).value(); // == "Godzilla"
// optional-returning factory functions are usable as conditions of while and if
if (auto str = create(true)) {
  // ...
}

std::any

std::any模も板いた類るい是ぜ型がた别安全的ぜんてき包含ほうがん任にん何なん型がた别的值：

std::any x {5};
x.has_value() // == true
std::any_cast<int>(x) // == 5
std::any_cast<int&>(x) = 10;
std::any_cast<int>(x) // == 10

std::string_view

std::string_view類るい是ぜ不ふ擁よう有ゆう字じ元もと序列じょれつ的てき情況じょうきょう可か以讀取よみと其值：

// Regular strings.
std::string_view cppstr {"foo"};
// Wide strings.
std::wstring_view wcstr_v {L"baz"};
// Character arrays.
char array[3] = {'b', 'a', 'r'};
std::string_view array_v(array, std::size(array));

std::string str {"   trim me"};
std::string_view v {str};
v.remove_prefix(std::min(v.find_first_not_of(" "), v.size()));
str; //  == "   trim me"
v; // == "trim me"

std::string_view不ふ提供ていきょうc_str()成員せいいん函はこ式しき。

std::invoke

std::invoke用よう於喚起かんき「可か喚起かんき對象たいしょう」。

template <typename Callable>
class Proxy {
  Callable c;
public:
  Proxy(Callable c): c(c) {}
  template <class... Args>
  decltype(auto) operator()(Args&&... args) {
    // ...
    return std::invoke(c, std::forward<Args>(args)...);
  }
};
auto add = [](int x, int y) {
  return x + y;
};
Proxy<decltype(add)> p {add};
p(1, 2); // == 3

std::apply

std::apply把わstd::tuple參さん數すう應用おうよう於可喚起かんき對象たいしょう：

auto add = [](int x, int y) {
  return x + y;
};
std::apply(add, std::make_tuple(1, 2)); // == 3

std::filesystem

std::filesystem可か操作そうさ檔案、目錄もくろく、路みち徑みち：

const auto bigFilePath {"bigFileToCopy"};
if (std::filesystem::exists(bigFilePath)) {
  const auto bigFileSize {std::filesystem::file_size(bigFilePath)};
  std::filesystem::path tmpPath {"/tmp"};
  if (std::filesystem::space(tmpPath).available > bigFileSize) {
    std::filesystem::create_directory(tmpPath.append("example"));
    std::filesystem::copy_file(bigFilePath, tmpPath.append("newFile"));
  }
}

std::byte

std::byte型がた别既不ふ是ぜ字じ元もと型かた别，也不是ぜ算術さんじゅつ型がた别，實際じっさい上じょう是ぜ列れつ舉型别：

std::byte a {0};
std::byte b {0xFF};
int i = std::to_integer<int>(b); // 0xFF
std::byte c = a & b;
int j = std::to_integer<int>(c); // 0

maps 和わ sets 上じょう更さら有效ゆうこう率りつ地ち移動いどう節點せってん

零れい開ひらき銷的節點せってん操作そうさ：

//Moving elements from one map to another:
std::map<int, string> src {{1, "one"}, {2, "two"}, {3, "buckle my shoe"}};
std::map<int, string> dst {{3, "three"}};
dst.insert(src.extract(src.find(1))); // Cheap remove and insert of { 1, "one" } from `src` to `dst`.
dst.insert(src.extract(2)); // Cheap remove and insert of { 2, "two" } from `src` to `dst`.
// dst == { { 1, "one" }, { 2, "two" }, { 3, "three" } };

//Inserting an entire set:
std::set<int> src {1, 3, 5};
std::set<int> dst {2, 4, 5};
dst.merge(src);
// src == { 5 }
// dst == { 1, 2, 3, 4, 5 }

//Inserting elements which outlive the container:
auto elementFactory() {
  std::set<...> s;
  s.emplace(...);
  return s.extract(s.begin());
}
s2.insert(elementFactory());

//Changing the key of a map element:
std::map<int, string> m {{1, "one"}, {2, "two"}, {3, "three"}};
auto e = m.extract(2);
e.key() = 4;
m.insert(std::move(e));
// m == { { 1, "one" }, { 3, "three" }, { 4, "two" } }

並列へいれつ演算えんざん法ほう

許多きょたSTL演算えんざん法ほう，如copy, find 和わ sort，支援しえん並列へいれつ執行しっこう政策せいさく：seq, par, par_unseq, unseq分別ふんべつ表示ひょうじ"sequentially", "parallel", "parallel unsequenced", "unsequenced".

std::vector<int> longVector;
// Find element using parallel execution policy
auto result1 = std::find(std::execution::par, std::begin(longVector), std::end(longVector), 2);
// Sort elements using sequential execution policy
auto result2 = std::sort(std::execution::seq, std::begin(longVector), std::end(longVector));

另見

• C++
• C++14
• C++11