C++11からC++17を駆け抜けるC++講座

# 初心者C++Advent Calendar 2017

この記事は初心者C++Advent Calendar 2017 15日目の記事です

[<< 14日目|C++を学ぶにあたって参考にした書籍・Webサイト](https://qiita.com/S_H_/items/2a892fefa98ebbf38f28) || 16日目|何か書きます >>

今週3本目、このAdCでも3本目の記事です。期限に間に合わなかったでござる・・・。

今年の初心者AdC++は平和ですね・・・。

# はじめに

みなさま、[ナマステ](http://www.nicovideo.jp/watch/sm25261912)。さて、この記事のタイトルを見て、「時代・・・サトウキビ・・・[忍者](http://www.nicovideo.jp/user/5006073)・・・うぅ、頭が」となった人は私と趣味が似ています・・・って話をするのは何回目だろうか。

先日[ニコニコ(デクレッシェンド)が発表](http://www.nicovideo.jp/mylist/60433191)されましたが、Qiitaはクレッシェンドしていって貰いたいものです(なおデザイン改悪)。
(追記:と、この記事を書いていたら[百花繚乱](http://dic.nicovideo.jp/l/%E7%99%BE%E8%8A%B1%20%E7%B9%9A%E4%B9%B1)氏が登場した[動画と生放送サービスに対する意見交換会](http://live.nicovideo.jp/watch/lv309318824)が開かれましたね。われこそはというエンジニアの皆様はぜひドワンゴへ！(謎の宣伝))

話を戻しまして・・・。

統一初期化についての言及がやたら多かった印象のある[C++初心者Advent Calendar 2015](http://www.adventar.org/calendars/922)では[C99からC++14を駆け抜けるC++講座](https://qiita.com/yumetodo/items/e49a673afd9a3ecb81a8)と題してC++14まで駆け抜けましたが時代はC++17。やっぱり時代の先端まで駆け抜けたいですよね。

なんか結果的に、[C++ Advent Calendar 2017](https://qiita.com/advent-calendar/2017/cpp)19日目の記事
[1 ページで眺める C++17 - 進捗置き場というわけでもない場所](http://azaika.hateblo.jp/entry/2017/12/19/221040)
とネタかぶりした感があります。

# (C++11 ... C++14]

変更点一覧は
[C++14 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp14.html)
にまとまっています。

C++14の変更は項目こそ多くないものの無視できない変更があります。

## 通常関数の戻り値型推論

C++11で導入されたlambda式は

```cpp:C++11
auto f = [](int a){ return a + 3; };
static auto n = f(1);//int型
```

のように戻り値の型を推論できました。しかし通常の関数においては

```cpp:C++11
auto f(int a) -> decltype(a + 3) { return a + 3; }
static auto n = f(1);//int型
```

のように`decltype`を使いreturn文と同じ内容を書く必要があり、極めて冗長でした。

C++14ではこれを推論させることができます。

```cpp:C++14
auto f(int a){ return a + 3; }
static auto n = f(1);//int型
```

- [通常関数の戻り値型推論 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp14/return_type_deduction_for_normal_functions.html)

## ジェネリックラムダ

lambda式の引数の型はlambda式の使われ方からして自明なので推論してほしいと思うことが多々あります。とくに型名が長いときとかとか。

そう思った例として幾つか。

[C++でマイナンバーのチェックデジットを計算する - Qiita](https://qiita.com/yumetodo/items/600ca0df422010cbc4c1)では

```cpp:C++11
#include <string>
#include <utility>
#include <numeric>//std::accumulate()
#include <stdexcept>
#include <cctype>//std::isdigit()
int calc_check_digit(const std::string& num) noexcept(false) {
    if (11 != num.length()) throw std::runtime_error("num.digit must be 11");
    const int remainder = std::accumulate(num.rbegin(), num.rend(), std::pair<int, int>{}, [](const std::pair<int, int>& s, const char& e){
        if(!std::isdigit(e)) throw std::runtime_error("num.digit must be 11");
        const int n = s.second + 1;
        const int p = e - '0';
        const int q = (6 < n) ? n - 5 : n + 1;
        return std::pair<int, int>{s.first + p * q, n};
    }).first % 11;
    return (0 == remainder || 1 == remainder) ? 0 : 11 - remainder;
}
```

のようなコードを書きましたが、`const std::pair<int, int>& s`ってすごく冗長ですよね。

@YukiMiyatake 氏の[BoostAsioで可読性を求めるのは間違っているだろうか](https://www.slideshare.net/chihayatakatuki/boost-asio)では

[![slide 19/31](https://image.slidesharecdn.com/boostasio-150517070248-lva1-app6891/95/boostasio-19-638.jpg?cb=1431846342)](https://www.slideshare.net/chihayatakatuki/boost-asio)


`asio::yield_context yield_child`ってやっぱりすごく冗長ですよね。

ジェネリックラムダはここに`auto`を指定できるようにするものです。

```cpp:C++14
auto plus = [](auto a, auto b) { return a + b; };
```

というジェネリックラムダは

```cpp:C++14
template <class T1, class T2>
auto operator()(T1 a, T2 b) const
{
  return a + b;
}
```

という演算子を持つ関数オブジェクトを生成します。テンプレートと同じ型推論なのでcv修飾子(`const`, `volatile`)、参照、ポインタといった修飾ができます

```cpp:C++14
auto plus = [](const auto& a, const auto& b) { return a + b; };
```

なおもっとも汎用的な`auto&&`を使う場合

```cpp:C++14
[]( auto && a, auto && b ) noexcept(a < b) -> decltype(auto){ return a < b ; }
```

これを

```cpp:P0573提案
[](a,b) => a < b
```

のようにかける提案が出ている。ECMAScript2015のArrow functionやC#3.0のlambdaみたいだ。

<blockquote class="twitter-tweet"><p lang="ja" dir="ltr">=&gt; 待ってた。寧ろ C# 並に簡潔になって欲しい。x =&gt; x * x は [](auto&amp;&amp; x) =&gt; &gt;&gt;x * &gt;&gt;x に変換される的な。構文解析も少し工夫すれば問題にならなそうだし。</p>&mdash; akinomyoga (@akinomyoga) <a href="https://twitter.com/akinomyoga/status/837286805074386944?ref_src=twsrc%5Etfw">March 2, 2017</a></blockquote>

- [ジェネリックラムダ - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp14/generic_lambdas.html)
- [本の虫: C++標準化委員会の文書: P0533R1-P0573r2](https://cpplover.blogspot.jp/2017/11/c-p0533r1-p0573r2.html)
- [P0573R2: Abbreviated Lambdas for Fun and Profit](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0573r2.html)

## [初心者向け]変数テンプレート

C++初心者ならテンプレート扱えるよね。

みんなだいすき`<type_traits>`ヘッダなんかにある`std::is_integral`のような類は使うときに

```cpp:C++14
//static member変数の参照
std::is_integral<T>::value;
//operator()の呼び出し
std::is_integral<T>();
```

のように書くことになるが、

```cpp:C++14
#include <type_traits>
template <class T>
constexpr bool is_integral_v = std::is_integral<int>::value;
```

のように変数テンプレートを定義しておくことで

```cpp:C++14
is_integral_v<T>
```

とかけるようになる。

こんな感じに実質type_traitsのようなものを書くときにしか使わない印象。

なおC++17で自分で変数テンプレート書かなくても

```cpp:C++17
std::is_integral_v<T>
```

とかけるようになりました。

- [変数テンプレート - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp14/variable_templates.html)
- [C++17 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp17.html)

## constexprの制限緩和

C++14最大の変更点と言って過言ではないです。

C++11でconstexprが導入され、コンパイル時計算が**一般的な人類**の手の届くものになりました。

[![slide12/100](https://image.slidesharecdn.com/constexpr-111204124759-phpapp01/95/constexpr-12-728.jpg?cb=1328839990)](https://www.slideshare.net/GenyaMurakami/constexpr-10458089)

>[中３女子でもわかる constexpr](https://www.slideshare.net/GenyaMurakami/constexpr-10458089) from [Genya Murakami](https://www.slideshare.net/GenyaMurakami)

そう、そのはずでした。しかしC++11のconstexprは制約が多く

- return文一つしか書けないので三項演算子で頑張る
- 副作用は作れないので再帰とラッパー関数で頑張る
- 再帰回数には推奨値512回の制約があるので、再帰オーダーを下げるためにindex_tuple や 倍分再帰 などのイディオムを駆使する必要がある。

という事態を招き、例えば次のようなコードが生産されることになりました。

```cpp:C++11
/*=============================================================================
  Copyright (c) 2011-2017 Bolero MURAKAMI
  https://github.com/bolero-MURAKAMI/Sprout

  Distributed under the Boost Software License, Version 1.0. (See accompanying
  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_ALGORITHM_FIND_HPP
#define SPROUT_ALGORITHM_FIND_HPP

#include <iterator>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/iterator/type_traits/category.hpp>
#include <sprout/utility/pair/pair.hpp>

namespace sprout {
	namespace detail {
		template<typename RandomAccessIterator, typename T>
		inline SPROUT_CONSTEXPR RandomAccessIterator
		find_impl_ra(
			RandomAccessIterator const& first, RandomAccessIterator const& last, T const& value,
			typename std::iterator_traits<RandomAccessIterator>::difference_type pivot, RandomAccessIterator const& found
			)
		{
			return found != first ? found
				: pivot == 0 ? (*first == value ? first : last)
				: sprout::detail::find_impl_ra(
					sprout::next(first, pivot), last, value,
					(sprout::distance(first, last) - pivot) / 2,
					sprout::detail::find_impl_ra(
						first, sprout::next(first, pivot), value,
						pivot / 2,
						first
						)
					)
				;
		}
		template<typename RandomAccessIterator, typename T>
		inline SPROUT_CONSTEXPR typename std::enable_if<
			sprout::is_constant_distance_iterator<RandomAccessIterator>::value,
			RandomAccessIterator
		>::type
		find(
			RandomAccessIterator const& first, RandomAccessIterator const& last, T const& value,
			std::random_access_iterator_tag*
			)
		{
			return first == last ? last
				: sprout::detail::find_impl_ra(first, last, value, sprout::distance(first, last) / 2, first)
				;
		}

		template<typename InputIterator, typename T>
		inline SPROUT_CONSTEXPR sprout::pair<InputIterator, bool>
		find_impl_1(
			sprout::pair<InputIterator, bool> const& current,
			InputIterator const& last, T const& value, typename std::iterator_traits<InputIterator>::difference_type n
			)
		{
			typedef sprout::pair<InputIterator, bool> type;
			return current.second || current.first == last ? current
				: n == 1 ? *current.first == value ? type(current.first, true) : type(sprout::next(current.first), false)
				: sprout::detail::find_impl_1(
					sprout::detail::find_impl_1(
						current,
						last, value, n / 2
						),
					last, value, n - n / 2
					)
				;
		}
		template<typename InputIterator, typename T>
		inline SPROUT_CONSTEXPR sprout::pair<InputIterator, bool>
		find_impl(
			sprout::pair<InputIterator, bool> const& current,
			InputIterator const& last, T const& value, typename std::iterator_traits<InputIterator>::difference_type n
			)
		{
			return current.second || current.first == last ? current
				: sprout::detail::find_impl(
					sprout::detail::find_impl_1(
						current,
						last, value, n
						),
					last, value, n * 2
					)
				;
		}
		template<typename InputIterator, typename T>
		inline SPROUT_CONSTEXPR InputIterator
		find(
			InputIterator const& first, InputIterator const& last, T const& value,
			std::input_iterator_tag*
			)
		{
			typedef sprout::pair<InputIterator, bool> type;
			return sprout::detail::find_impl(type(first, false), last, value, 1).first;
		}
	}	// namespace detail

	// 25.2.5 Find
	//
	//	recursion depth:
	//		O(log N)
	//
	template<typename InputIterator, typename T>
	inline SPROUT_CONSTEXPR InputIterator
	find(InputIterator first, InputIterator last, T const& value) {
		typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
		return sprout::detail::find(first, last, value, category());
	}
}	// namespace sprout

#endif	// #ifndef SPROUT_ALGORITHM_FIND_HPP
```

ここに崩壊したかに見えたコンパイル時の世界の魔界は完全にその権威を取り戻した(Doctor X風)。

C++14constexprはこのコンパイル時計算を**再び**一般的な人類の手の届くものにするものです。

このconstexprの制限緩和によって、コンパイル時にできないことは概ね

- I/O
- 動的メモリ（new/delete）
- 例外処理（try-catch）
- RAII（デストラクタを使った後処理）
- ラムダ式
- グローバル変数の参照

になりました。ラムダ式については後述するがC++17で概ね制約がなくなりました。動的メモリについては現在C++標準化委員会にこれを許可する提案が出ています。I/OのうちInputの部分はFile literalなる奇想天外なものが同じくC++標準化委員会に提案されています。

結果として先の魔界じみたコードは、概ね次のような一般的な人類でも読めるものに変貌を遂げたのです。


```cpp:C++14
//Copyright (c) 2013-2014 Bolero MURAKAMI
template<typename InputIterator, typename T>
constexpr InputIterator
find(InputIterator first, InputIterator last, T const& value) {
  for (; first != last; ++first)
    if (*first == value) {
      return first;
    }
  return last;
}
```

もはや普段我々が書く関数と差はほとんどないですね！
[縄文アートグループ展 ARTs of JOMON in Kioicho(12/4～12/25)に出品している岡山の陶芸家な某中３女子](https://twitter.com/bolero_MURAKAMI)でなくても理解できます。
constexprは市民の義務と言えるでしょう。

- [C++14 時代の constexpr プログラミング作法 - ボレロ村上 - ENiyGmaA Code](http://boleros.hateblo.jp/entry/20131203/1386011596)
- [constexprの制限緩和 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp14/relaxing_constraints_on_constexpr.html)
- [ｃonstexpr関数はコンパイル時処理。これはいい。実行時が霞んで見える。cpuの嬌声が聞こえてきそうだ](https://www.slideshare.net/GenyaMurakami/onstexprcpu)
- [中３女子でもわかる constexpr](https://www.slideshare.net/GenyaMurakami/constexpr-10458089)

## 宣言時のメンバ初期化を持つ型の集成体初期化を許可 	

細かいこと抜きにして実用的な話をすると

```cpp:C++11
std::array<int, 3> ar = {{ 1, 2, 3 }};
```

を

```cpp:C++14
std::array<int, 3> ar = { 1, 2, 3 };
```

とかけるようになったという話です。

- [宣言時のメンバ初期化を持つ型の集成体初期化を許可 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp14/brace_elision_in_array_temporary_initialization.html)

## `[[deprecated]]`属性

本来の用途はライブラリ開発者がユーザーに「このAPIは使わないでくれ、そのうち削除する」と伝えるためのものです。
このattributeが付いているとコンパイラは警告なりエラーを吐きます。

これを**悪用して、リファクタリングするときに消したいものにこのattributeをつけて利用されているところを列挙する**という使い方があります。

grepすればいいやん、とかVSのIntelliSenseで呼び出しツリーとか参照見れるでしょ、と思うかもしれませんが、grepだと別の名前空間のやつが引っかかったりして面倒で、VSのはわりとよくバグるというかコンパイラとIntelliSenseで別のバグを同時に引くと解読不能なのでこいつがすごく便利です。

以前から各コンパイラが独自拡張でこの機能を実装していたので、それが標準化されたと思っていいと思います。

- [[[deprecated]]属性 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp14/deprecated_attr.html)

## `std::make_unique()`を追加

なぜC++11に`make_shard`があるのに`make_unique`がないのかという思いでいっぱいですが、C++14で追加されました。

```cpp:C++14
auto p1 = std::make_unique<std::pair<int, int>>(3, 1);
```

これによって**`new`/`delete`は書いてはいけないもの**になりました。代わりに`std::unique_ptr`/`std::shard_ptr`を使いましょう。

なおどのようにスマートポインタを使うべきかは
[C++ スマートポインタのパターン](https://qiita.com/kojiohta/items/596802df9cfa881ad9c4)
というスマートな記事を発見したのでそちらを参照してください。

## `std::exchange()`を追加

これ自体は別に大した関数じゃなくて、値を書き換え、書き換え前の値を返す、というただそれだけの関数です。真の目的は
[非推奨だった bool 型に対するインクリメント演算子を削除(C++17)](https://cpprefjp.github.io/lang/cpp17/remove_deprecated_increment_of_bool.html)
への布石です。

## リテラル演算子

痒いところに手が届く新機能です。

これまで

```cpp:C++11
#include <iostream>
#include <string>
#define STRINGIFY(n) #n
#define TOSTRING(n) STRINGIFY(n)

std::string foo(const char* str1)
{
    return std::string("s1:") + str1 + " in line" + TOSTRING(__LINE__);
}
int main()
{
    std::cout << foo("arikitari") << std::endl;
}
```

とか

```cpp:C++11
#include <chrono>
#include <thread>
int main()
{
    const auto current = std::chrono::high_resolution_clock::now();
    //do something
    std::this_thread::sleep_until(current + std::chrono::seconds(3));
}
```

みたいなコードを書いていたと思いますが、`std::string("s1:")`にしても`std::chrono::seconds(3)`にしても冗長で、`using namespace`とか`using s = std::string`とかするのもだるいですよね。

ところでC++11で、User Defined Literalsという機能が追加されました。こいつを標準ライブラリで追加したのがC++14での変更です。つまり

```cpp:C++14
#include <iostream>
#include <string>
#define STRINGIFY(n) #n
#define TOSTRING(n) STRINGIFY(n)

std::string foo(const char* str1)
{
    using namespace std::string_literals;
    //using namespace std::literals;//これでもいい
    //using namespace std::literals::string_literals;//これでもいいが長い
    //using namespace std;//しないことを強くすすめる
    return "s1:"s + str1 + " in line" + TOSTRING(__LINE__);
}
int main()
{
    std::cout << foo("arikitari") << std::endl;
}
```

とか

```cpp:C++14
#include <chrono>
#include <thread>
int main()
{
    using namespace std::chrono_literals;
    //using namespace std::literals;//これでもいい
    //using namespace std::literals::chrono_literals;//これでもいいが長い
    //using namespace std;//しないことを強くすすめる
    //using namespace std::chorono;//しないことをすすめる
    const auto current = std::chrono::high_resolution_clock::now();
    //do something
    std::this_thread::sleep_until(current + 3s);
}
```

のようにかけるわけです。すっきり。

例は挙げていませんが複素数ライブラリ(`<complex>`)向けにも追加されています。

- [sリテラル - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/reference/string/basic_string/op_s.html)
- [duration - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/reference/chrono/duration.html)
- [complex - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/reference/complex.html)

# (C++14 ... C++17]

変更点一覧は
[C++17 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp17.html)
にまとまっています。

cpprefjpではC++17の新機能解説を現在執筆中ですが、それに加わる人をきっと、多分、おそらく、may be、募集していると思います。
[Issues · cpprefjp/site | is:issue is:open label:TASK C++17](https://github.com/cpprefjp/site/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+label%3ATASK+C%2B%2B17)
この辺を見て書けそうなのがあったらPull Requestを投げてください。
(早く`if constexpr`文の導入背景を調べて追記しないと・・・)

あと @kazatsuyu 氏の
[久々なのでC++17の情報を集めてみる - Qiita](https://qiita.com/kazatsuyu/items/1d46b85f08c6e9a8bcaf)
と内容かぶっているじゃねーか、という話もありますが、もうすこしざっくりした話をします。

## インライン変数

C++ではtemplateを使うと実質その定義をヘッダに書かないといけないので、開き直ってヘッダーオンリーライブラリというのが広く存在します(コンパイル時間は犠牲になった)。

しかしながら、例えばmutexなど外部リンケージを持つ変数を作る必要があることがあり、ヘッダーオンリーでは素直には記述できませんでした。

インライン変数はこれを解決します。

```cpp:C++14ヘッダー
struct X {
  // ヘッダでは変数の宣言のみを行い
  static int foo;
};
```

```cpp:C++14ソース
// 変数fooを定義する
int X::foo;
```

これが

```cpp:C++17
struct X {
  // ソースで変数fooを定義する必要がない
  static inline int foo;
};
```

のようになります。

恩恵としてはヘッダーオンリーのライブラリが増えて気軽に外部ライブラリを使えるようになるんじゃないかと思います。(そんなことよりはようmoduleよこせ)

- [インライン変数 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp17/inline_variables.html)

## 構造化束縛

**個人的にイチオシのC++17新機能です。**

```cpp:C++11
std::pair<int, std::string> f() { return { 2, "s" }; }
int main()
{
    std::pair<int, std::string> p = f();
    int id = p.first;
    std::string message = p.second;
}
```

のように書いていたのが

```cpp:C++17
std::pair<int, std::string> f() { return { 2, "s" }; }
int main()
{
    auto [id, message] = f();
}
```

と書けるようになる機能です。

実際の利用例としては、

```cpp:C++17
//Copyright Cpprefjp CC BY
#include <iostream>
#include <map>
#include <string>

int main()
{
    std::map<std::string, int> m = {
        {"Alice", 3},
        {"Bob", 1},
        {"Carol", 4}
    };

    // mapの各要素をキーと値に分解する。
    // const auto&ではなくauto&にした場合は、
    // const std::string&型のkey変数と、
    // int&型のvalue変数に分解される。
    for (const auto& [key, value] : m) {
        std::cout << key << " : " << value << std::endl;
    }
}
```

のように使えます。

で、こいつのポテンシャル(潜在的能力)が意外に高くて、

```cpp:C++17
#include "print_struct.hpp"
#include <iostream>
struct inner
{
  const char *p;
  int n;
};
struct outer
{
  int m;
  inner i;
};
int main()
{
  outer o{3, {"foo", 88}};
  using namespace print_struct;
  std::cout << o << '\n';
}
```

魔法のヘッダーファイル`print_struct.hpp`をincludeし、`using namespace print_struct;`で`operator<<`を名前探索の対象に含めることで、publicなメンバ変数を含むクラスが`std::cout`で表示できるということができたりします。
[Playful Programming: Serializing structs with C++17 structured bindings](http://playfulprogramming.blogspot.jp/2016/12/serializing-structs-with-c17-structured.html?spref=tw)

- [構造化束縛 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp17/structured_bindings.html)

## `[[maybe_unused]]`属性

デバッグ用に`assert`の呼び出しを書くときに一回変数に受けておきたいということがあるわけですが、そうするとReleaseビルドするときに、「変数~~は利用されていません」みたいに怒られると悲しいですね。なので仕方なく`#ifdef _DENUG`〜〜`#endif`とかする。でもそれって非常に非効率的。これはattributeの出番でしょ！ということで追加されました。

- [[[maybe_unused]]属性 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp17/maybe_unused.html)

## 値のコピー省略を保証

これまでC++の多くのコンパイラはRVO(Return Value Optimization)と呼ばれる最適化を実装してきました。つまり、

```cpp
//copy
#include <iostream>
struct Hoge {
  Hoge(int i = 0) : x(i) {}
  Hoge(const Hoge&) { std::cout << "copy ctor call"; }
  int x;
};
Hoge rvo() {
  return Hoge();
}
int main() {
  Hoge a = rvo();  // copy が呼ばれないかもしれない(RVO)
  Hoge b = a;  // copy が呼ばれる
  return 0;
}
```

このようにコピー/ムーブコンストラクタの呼び出しを省略することがありました。

C++17ではこのRVOを事実上強制し、**コピー/ムーブコンストラクタがなくても**関数の戻り値として使えるようになりました。

なおこれよりさらに進んだNRVOに関しては変化なしなのでその場合はコピー/ムーブコンストラクタが必要です。

## if文とswitch文の条件式と初期化を分離

変数のスコープをなるべく小さくしろというのはよく言われる話で、言語側でも

```cpp:C99_C++11
for(int i = 0; i < 55; ++i){
    //do something
}
```

というように`for`文のなかで変数宣言ができるようになったりしていました。

C++17では`if`文と`switch`文でもそれができるようになりました。

```cpp:C++17
std::string s;
//do something
if(std::size_t pos = s.find_first_of(' '); std::string::npos != pos){
   //do something
}
```

- [if文とswitch文の条件式と初期化を分離 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp17/selection_statements_with_initializer.html)

## `if constexpr`文

これまでC++には2つのif文がありました

- プリプロセス時: `#if`〜`#elif`〜`#else`〜`#endif`
- 実行時: `if`

ここに新たに

- コンパイル時: `if constexpr`

が追加されます。

もはや
[C99からC++14を駆け抜けるC++講座 - Qiita#templateでif](https://qiita.com/yumetodo/items/e49a673afd9a3ecb81a8#template%E3%81%A7if)
で取り上げたクラステンプレートの部分特殊化を利用したコンパイル時条件分岐やSFINAEを利用したコンパイル時条件分岐やオーバーロードを利用したコンパイル時条件分岐(可変長引数などで)は忘れていいものになりました。

- [if constexpr 文 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp17/if_constexpr.html)

## `constexpr`ラムダ

C++11で追加されたlambda式が関数オブジェクトを生成するsyntax sugerであるというのは
[関数の創世から深淵まで駆け抜ける関数とはなんぞや講座 - Qiita](https://qiita.com/yumetodo/items/cdfb41781d32d98be1b4)
で触れましたが、その生成される関数オブジェクトの`operator ()`が、条件を満たすと自動的にconstexpr指定されます、という機能です。

```cpp:C++17
int main()
{
    auto f = []{ return 42 ; } ;

    constexpr int value = f() ; // OK
}
```

なお**一部の**C++erの皆様に申し上げると、SFINAEの文脈では使えません。C++20はよ！

## 畳み込み式(fold式)

これは無視できない新機能ではあるんだけど、魔界過ぎて解説は省略。C++14のconstexpr制限緩和のところで書いた再帰オーダーを下げるというのに大きく貢献するので、[岡山の陶芸家な某中３女子](https://twitter.com/bolero_MURAKAMI)あたりが喜びそうではあります。
がしかし再帰地獄も大概だったけれど、fold式も大概だと私は思うんだ。

まあなんだ、

```cpp:C++17
template<typename ...Args>
auto sum(Args&& ...args) {
    return (... + args);
}
```

みたいな`()`で囲まれて`...`が出てきて、C++11の可変長引数の展開ではなさそうだったらこれだ。

ただ書けなくても読めないとC++17時代こいつを見かける機会は増えるかもしれない。

それは2017年8月のこと。

<blockquote class="twitter-tweet"><p lang="ja" dir="ltr">そうなるとサイズ自動確保のテンプレートが欲しいな。<br><br>sizeof&lt;int,bool,char,int64&gt;::valueって書くと<br>64が帰ってくる。<br>要は1番でかいバイト数を返すメタ関数</p>&mdash; らいパン粉haskell修行者 (@elipmoc101) <a href="https://twitter.com/elipmoc101/status/892349660739719168?ref_src=twsrc%5Etfw">August 1, 2017</a></blockquote>
<blockquote class="twitter-tweet"><p lang="ja" dir="ltr"><a href="https://t.co/yJb8JIAAMN">https://t.co/yJb8JIAAMN</a><br>つまりこういうのが必要と。 <a href="https://t.co/RnlHSK1R94">https://t.co/RnlHSK1R94</a></p>&mdash; yumetodo-レポート辛い (@yumetodo) <a href="https://twitter.com/yumetodo/status/892374990837882881?ref_src=twsrc%5Etfw">August 1, 2017</a></blockquote>
<blockquote class="twitter-tweet"><p lang="ja" dir="ltr">よく考えたらstd::maxはconstexprになっているので使えた<a href="https://t.co/jFHFFnjvWs">https://t.co/jFHFFnjvWs</a></p>&mdash; 白山風露@ᓚᘏᗢ (@kazatsuyu) <a href="https://twitter.com/kazatsuyu/status/892384017063976964?ref_src=twsrc%5Etfw">August 1, 2017</a></blockquote>

```cpp:C++17
#include <iostream>
#include <cstddef>
#include <algorithm>

template<typename ...Types>
constexpr auto max_sizeof_v = []() constexpr {
    std::size_t v = 0;
    return ((v = std::max(sizeof(Types), v)), ..., v);
}();

int main()
{
    std::cout << max_sizeof_v<std::int64_t, int, char, bool> << std::endl;
}
```

https://wandbox.org/permlink/O2gxJuItJuzC1etu

こういうコードにある日突然遭遇するかもしれないから。

なおこの一連のツイートにはオチがあってC++14でもっと短くかけることが判明しているので興味がある人は辿られたし[。](https://wandbox.org/permlink/qVcnV28SAfEGvj2F)

- [久々なのでC++17の情報を集めてみる - Qiita#fold式](https://qiita.com/kazatsuyu/items/1d46b85f08c6e9a8bcaf#fold%E5%BC%8F)
- [畳み込み式 - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/lang/cpp17/folding_expressions.html)

## filesystem

**みなさん、聞きましたか？この現代社会、ファイル/ディレクトリの操作すら標準APIを提供できないクソ言語がここにあったようです！**

やっとかよ、という思いが満載です。ようやくパーミッションとかとか含めたファイル/ディレクトリの操作ができるようになります！

解説するとそれだけで記事が一つ書けるので、江添さんが執筆している

[cpp17book/073-cpp17-lib-filesystem.md at master · EzoeRyou/cpp17book](https://github.com/EzoeRyou/cpp17book/blob/master/073-cpp17-lib-filesystem.md)

に解説は譲ります。

## Parallelism

C++11で`<thread>`が入り、C++でもようやくスレッドを作れるようになったわけですが、これを効率的に使うのは意外と難しかったりします。

例えばもっとも要望が多そうな`for`文をマルチスレッド化したい、という場合(ループ間に依存がない場合)

```cpp:C++11
namespace parallel {
	template<
		typename Index, typename Func,
		typename RawIndexType = Index,
		typename ...Args,
		std::enable_if_t<std::is_unsigned<Index>::value && std::is_integral<RawIndexType>::value, std::nullptr_t> = nullptr
	>
	inline void par_for(Index num, Func&& f, Args&& ...args) {
		const unsigned int thread_num = std::thread::hardware_concurrency();
		if (thread_num < 2) {//thread 非対応
			f(static_cast<RawIndexType>(0), static_cast<RawIndexType>(num), std::forward<Args>(args)...);
		}
		else {
			const auto task_num = num / thread_num;
			const auto task_rest = num % thread_num;
			std::vector<std::thread> th;
			th.reserve(thread_num);
			for (unsigned int i = 0; i < thread_num; ++i) {
				th.emplace_back(
					std::forward<Func>(f),
					static_cast<RawIndexType>((i) ? i * task_num + task_rest : 0),
					static_cast<RawIndexType>((i + 1) * task_num + task_rest),
					std::forward<Args>(args)...
				);
			}
			for (auto&& t : th) t.join();
        }
    }
}
namespace sigmoid_contrast {
	BOOL proc(FILTER* fp, FILTER_PROC_INFO* fpip) // This is the main image manipulation function
	{
		const filter_proxy fc(fp);
#ifdef USECLOCK
		ch::time_point<ch::steady_clock> start_con;
		if (fc.any_of(check::echo_benchmark, check::save_benchmark)) start_con = ch::steady_clock::now();
#endif

		ST.change_param(fc[track::midtone] / 100.0f, static_cast<float>(fc[track::strength]));

		if (fc.none_of(check::R, check::G, check::B)){
			/* Scan Y channel data */
			parallel::par_for(fpip->h, [fpip](int begin, int end) {
				for (int r = begin; r < end; r++){
					for (int c = 0; c < fpip->w; c++){
						PIXEL_YC* const px = fpip->ycp_edit + r* fpip->max_w + c;
						px->y = ST.lookup(px->y);
					}
				}
			});
        }
    }
}
```

(コードは[yumetodo/SigContrastFastAviUtl: Sigmodial/Logit contrast Aviutl plugin. IM is not used.](https://github.com/yumetodo/SigContrastFastAviUtl)より抜粋)

のように書けばいいように見えます(**すでに十分面倒**)。

ところがこれだとスレッドを並列化したい`for`ごとに作る事になります。一般にスレッドを作るコストはそこそこ重いので、高速化のためには一度作ったスレッドを使いまわすようにする必要があります。

そうなると生産者-消費者パターンを実装して・・・となり、おおよそ普通にプログラマが書けるコードではなくなります。

そこでこれまではIntel© TBBなんかを使ってきたのですが(上記コードをそれで書き換えると約5倍高速化)、C++標準でそれはやってほしい。

そういう要望に答えるべくC++17では、`<algorithm>`ヘッダ全般およびその他一部関数で並列化ができるようなオーバーロードを追加しました。

実行ポリシー(`std::execution::seq`, `std::execution::par`, `std::execution::par_unseq`)を定義して、それを引数に渡してあげるとそれに基づいて実行してくれます。

詳細な解説は使いたいアルゴリズム関数のページ、もしくは

[cpp17book/044-cpp17-lib-parallel-algorithm.md at master · EzoeRyou/cpp17book](https://github.com/EzoeRyou/cpp17book/blob/master/044-cpp17-lib-parallel-algorithm.md)

を参照してください。

なお今回のは第一弾にすぎないので第二弾があるっぽいです。

## `std::optional`

Rustなどと違い、C++の`std::optional`はイテレータを持たないので、

```cpp
#include <iostream>
std::optional<int> foo() { return 3; }
int main()
{
    for(auto&& i : foo()){
        //only when optional holds value
        std::cout << i << std::endl;
    }
}
```

のようなことはできません。

- [Shouldn't std::optional be a container? - Google グループ](https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/in38mPp2NiU)
- [Iterating over/transforming std::optional - Google グループ](https://groups.google.com/a/isocpp.org/forum/?fromgroups#!searchin/std-proposals/optional/std-proposals/KeD14jNkuhs/54EB299kBAAJ)

要望はあるみたいだし、[Sprout](https://github.com/bolero-MURAKAMI/Sprout)はそれを実装しているんですけどね～。

<blockquote class="twitter-tweet" data-lang="ja"><p lang="ja" dir="ltr">sprout::optional にコンテナインタフェースを追加しました。<a href="https://t.co/CgbXSNpl5D">https://t.co/CgbXSNpl5D</a><a href="https://t.co/DFw7i4Nby2">https://t.co/DFw7i4Nby2</a></p>&mdash; 狂える中３女子ボレロ村上／陶芸C++er (@bolero_MURAKAMI) <a href="https://twitter.com/bolero_MURAKAMI/status/702792883791749120?ref_src=twsrc%5Etfw">2016年2月25日</a></blockquote>

- [optional - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/reference/optional/optional.html)

## `<iterator>`に`size()`追加

**これで`_countof`とか`numof`とか`NUMOF`とかその手のマクロを作らなくても配列の大きさが求められます！**

- [size - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/reference/iterator/size.html)

## [中級者向け]多相アロケータとメモリプール

C++中級者ならメモリーアロケータの存在くらいは知っているはず。C++17ではこれまでのアロケーター利用の仕様への謝罪と反省の意を込めて(?)`std::pmr`名前空間が追加され、`std::prm::memory_resource`を継承したアロケータを書けばいい感じになるようになりました。

・・・などと知ったかぶって書こうとしましたが、私はC++中級者ではないので理解できていません。

@MitsutakaTakeda 氏のAltPlus Advent Calendar 2017 17日目の記事である
[Polymorphic Allocator in C++17 - Qiita](https://qiita.com/MitsutakaTakeda/items/48980faa9498c46b15b2)

に丸投げします。

## 標準イテレータ全般と`array`の変更操作に`constexpr`を追加

最適化の手法で事前に計算してテーブル引き、なんて手法があります。

C++14constexprのお陰で、その計算をコンパイル時にやりたい、という要求が生まれたわけですが、どういうわけかこれまで`std::array`の変更操作(`operator[]`とか)には`constexpr`が指定されていなかったので、[Sprout](https://github.com/bolero-MURAKAMI/Sprout)を使って

```cpp:C++14
SPROUT_CXX14_CONSTEXPR sprout::array<std::uint8_t, 1000> make_mod_table_ysr() {
    sprout::array<std::uint8_t, 1000> re{};
    for (size_t i = 0; i < 1000; ++i) {
        size_t mod = i % 11;
        re[i] = static_cast<std::uint8_t>(mod <= 1 ? 0 : 11 - mod);
    }
    return re;
}
```

(コードは[C++でマイナンバーのチェックデジットを計算する - Qiita](https://qiita.com/yumetodo/items/600ca0df422010cbc4c1)より抜粋)

と書いてきたわけですが、C++17からはようやくarrayクラスを自分で作らなくてもそれができるようになりました。

この他、イテレータ全般も対応したようです。

## 値を範囲内に収める`clamp()`関数を追加

値を範囲内に丸める処理というのは頻出する割にはこれまでC++標準にそれをする関数はなく、`std::min`/`std::max`を使うか三項演算子で書く必要がありました。

C++17になってようやくこれを行う関数が提案され、無事にC++17に採用されました。

引数の順序で賛否両論あるようですが、**値・最小値・最大値(・比較関数)**の順になりました。

## 所有権を持たない文字列クラスである`basic_string_view`を追加

C++には文字列クラスとして`std::string`があるわけですが、基本的にはアロケーションが発生し、また部分文字列を取る場合には文字列のコピーが発生します。また場合によっては例外も発生します。

高速化のために、このアロケーションやらコピーを避けようと思うと、`std::string`の**メンバー関数の恩恵が受けられず**、極めて冗長なコードを書くことになります。

また関数の引数などで文字列を受け取る時、実行速度を考えるとこれまで`const char*`版と`std::string`の2つのオーバーロードを用意する必要がありましたが、これが`std::string_view`で代替できるようになります。

`std::string_view`は文字列開始位置のポインタと長さを保持します。これによって文字列のコピーをすることなく文字列を参照できるわけですね。

ただし当たり前ですがNULL終端しないので、文字列へのポインタのみしか受け取らないC APIには直接渡せません。長さも一緒に渡せるように変更するなり、ライブラリ作者に要望しましょう。
ex.) DxLibの作者さんに要望を投げた例: [[task]文字列の長さ指定付き関数を追加](http://dxlib.o.oo7.jp/cgi/patiobbs/patio.cgi?mode=view&no=4243)

![slide-1](https://image.slidesharecdn.com/c1zstringview-161105052915/95/boost-21-c1zstringview-1-638.jpg?cb=1478323849)
[**Boost.勉強会 #21 札幌「C++1zにstring_viewが導入されてうれしいので紹介します」**](https://www.slideshare.net/maraigue/boost-21-c1zstringview) from @h_hiro_

## `basic_string::data()`メンバ関数の非const版を追加

これはC-likeなAPIと文字列をやり取りしていた人には朗報です。

[そろそろWindowsでUTF-16とShift-JISの変換方法をC++erらしくまとめようか](https://qiita.com/yumetodo/items/453d14eff41b805d8fc4)
のコードを例に解説します。

```cpp:Win32API
#include <string>
#include <windows.h>
#include <cstring>
std::wstring shift_jis_to_utf_16(const std::string& str)
{
    static_assert(sizeof(wchar_t) == 2, "this function is windows only");
    const int len = ::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, nullptr, 0);
    std::wstring re(len * 2 + 2, L'\0');
    if (!::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, &re[0], len)) {
        //中略
    }
}
```

C++11以前は、`std::basic_string`が所有している文字列を格納しているメモリ領域が連続している保証がありませんでした。

C++11になってこの連続が保証され、`std::basic_string`をバッファとして利用する上記のようなコードが書けるようになりました(変数`re`)。

これの何が嬉しいかというと、自前でメモリー確保してバッファを作ってそれをまたコピーするという作業が不要になってコピー回数とアロケーション回数が減らせる→**高速化できる**ということです。

ところで`std::basic_string`には太古の昔から`data()`というメンバ関数がありました。にもかかわらず文字列を格納しているメモリ領域の先頭へのポインタを取るのに`&re[0]`のように書くのって**なんか変**です。

理由としてはこれまでメンバ関数`data()`が

```cpp
const charT* data() const;          // C++03 まで

const charT* data() const noexcept; // C++11 から
```

のように定義されていて、返却されるポインタがconst修飾されているという問題がありました。

つまり上記の目的のためには`&re[0]`と書くしかありませんでした(`const_cast`するとUBだった)。

今回非const版が追加されたことで

```cpp
CharT* data() noexcept; //C++17から
```

素直に書けるようになりました。

なおC++11時代からそうですが、このポインタをいじって書き込んでいい範囲は`[0...size())`なので、`\0`が書き込まれる場所はいじってはいけません。つまりデカ目に確保してあとで`resize`しましょう。

この件に関しては @yohhoy さんの

- [文字列取得バッファとしてのstd::string - yohhoyの日記](http://d.hatena.ne.jp/yohhoy/20130413/p1)
- [文字列取得バッファとしてのstd::string リターンズ - yohhoyの日記](http://d.hatena.ne.jp/yohhoy/20160327/p1)

が詳しいので詳細はそちらに譲ります。

## ロケール依存なし、フォーマット解析なしの高速な文字列・数値変換関数として、to_chars()とfrom_chars()を追加

これは、この記事を見ているような人に直接恩恵があるわけじゃないですが、間接的に影響があります。

これまでC/C++に標準で提供されていた文字列→数値変換/数値→文字列変換はAPIとしてはたくさんの関数がありましたが、集約されるところ`strtol`系関数/`sprintf`関数に集約され、それ以外はそのラッパーとしての存在でした。

これらはまずロケールに依存しており、数値→文字列変換については`sprintf`なのでフォーマット解析が挟まったりと余計な処理が挟まっていました。

今回の追加によってこれとは別系統の変換手段ができたので、例えば**JSONのシリアライズ/デシリアライズが速くなる**とかライブラリのバグが潰れるとかそういう恩恵があるかなと思います。

## `hypot()`関数の3引数版を追加

皆さん義務教育で3平方の定理とかピタゴラスの定理という名前で習ったアレをやるのが`std::hypot`の処理内容です。直角三角形の斜辺の長さの2乗は他の2辺の長さの2乗和に等しい、というあれです。

何に使うかというとゲームなんかで直交座標系において2点間の距離の計算やベクトルの長さを計算するために使うわけですね。

でもこれまで2次元版しかなかったので3次元版もほしい。そういう要望に答えたのがこの変更です。

- [hypot - cpprefjp C++日本語リファレンス](https://cpprefjp.github.io/reference/cmath/hypot.html)

## 最大公約数と最小公倍数の関数として、`gcd()`と`lcm()`を追加

最大公約数と最小公倍数なんてものは義務教育で習う初歩的なものでたいしてコード量もいらない。

```cpp
// N3845のリファレンス実装例
// 仮にclib名前空間内に置く
namespace clib {

// 任意の整数型で動くテンプレート版のabs
template< class T >
constexpr auto abs( T i ) -> enable_if_t< is_integral<T>{}(), T >
{
    return i < T(0) ? -i : i; }
}

// 二つの実引数が整数型であるかどうかを確認し、また共通の型を返すメタ関数common_int_t
template< class M, class N = M >
using common_int_t = enable_if_t< is_integral<M>{}() and is_integral<N>{}()
, common_type_t<M,N>
> ;

// 最大公約数
template< class M, class N >
constexpr auto gcd( M m, N n ) -> common_int_t<M,N>
{
using CT = common_int_t<M,N>;
return n == 0 ? clib::abs<CT>(m) : gcd<CT,CT>(n, m % n);
}

// 最小公倍数
template< class M, class N >
constexpr auto lcm( M m, N n ) -> common_int_t<M,N>
{ return abs((m / gcd(m,n)) * n); }
```

しかし、だからこそてんでんばらに書くのではなく、標準化されるべきです。というわけで追加されました。

**なお競技プログラミングなどで`using namespace std;`してきた人で自前で`gcd()`/`lcm()`書いていた人は名前衝突で死にます**。

## `std::iterator`クラスを非推奨化

cpprefjpの

>このクラスを使用しても、イテレータ定義は簡単にならなかった

という言葉にすべてが集約されるよね。どうせみんなイテレータ作るのに一応継承してたけど自前でイテレータの要件満たすための型定義書いてたでしょ。**いらんかったよね。**

昨年の初心者C++ AdCの記事である
[イテレータの解説をするなんて今更佳代 - Qiita](https://qiita.com/yumetodo/items/245e94a0e85db9bf5cbb)
でも結局自分で型定義し直しています。

そんなことよりはようイテレータがもっとかんたんに書ける仕組みを、syntax sugarをよこせ！

## `<codecvt>`を非推奨化。

**みなさん、聞きましたか？この現代社会、文字コード変換すら標準APIを提供できないクソ言語がここにあるようです！**

せっかくC++11で問題は山積みながら入ったと思ったらこれだよ！これだからアルファベット至上主義者共は・・・(なぞのとばっちり

というわけでiconvのような外部ライブラリ使うとかUnicode変換くらいなら自前で書くかしましょう。

・・・何を言ってるのかわからねーと思うが、俺もわからねぇ！[ニコニコ(く)](http://www.nicovideo.jp/tag/Niconico(%E3%81%8F%E3%81%9D)%E3%81%B8%E3%81%AE%E5%8F%8D%E5%BF%9C%E3%82%B7%E3%83%AA%E3%83%BC%E3%82%BA)よかよっぽどクソでしょ。まじでありえねー。

# C++の未来

C++はC++標準化委員会(WG21)でその仕様が議論され、規格化され、最終的にISO/IECで標準化され、我々が使うコンパイラなんかはこれに従って実装されます。

そのC++標準化委員会がC++に追加する大きな機能のロードマップは

[Current Status : Standard C++](https://isocpp.org/std/status)で見ることができます。

執筆時点で確認したら

![loadmap](https://isocpp.org/files/img/wg21-timeline-2017-11.png)

となっていますね。

2D graphicsというのが見えると思いますが、これは将来GUIを標準化しようという茨の道へと進むことを暗示しているのでしょうか。

Networkingというのはboost.asio相当のものになると思われます。はやく標準入りしてほしいです。

## C++20

C++11でリジェクトされ、内容を縮小して再提案されたC++17でも入らずにいたConceptはC++20に入りそうです。**やっとかよ！**。


# 追記

<blockquote class="twitter-tweet"><p lang="ja" dir="ltr">C++14からだね</p>&mdash; キュアいなむのみたま (@range_v3) <a href="https://twitter.com/range_v3/status/941917865506095104?ref_src=twsrc%5Etfw">December 16, 2017</a></blockquote>

C++11からC++17という部分に対する指摘が来ました。意図としては(C++11 ... C++17]という半開区間だったんですががが。

# License

[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/deed.ja)

<a href="https://commons.wikimedia.org/wiki/File:CC-BY_icon.svg#/media/File:CC-BY_icon.svg"><img src="https://upload.wikimedia.org/wikipedia/commons/thumb/1/16/CC-BY_icon.svg/1200px-CC-BY_icon.svg.png" alt="CC-BY icon.svg" width="88px"></a>