実引数（argument）と、仮引数（parameter）

引数には、ふたつの種類がある。実引数とは、関数やマクロ、throw文、テンプレートに、実際に渡す引数のことをいう。仮引数とは、関数宣言や関数の定義、例外ハンドラーのcatch句、マクロ、テンプレート仮引数のことをいう。たとえば、関数の場合、

// xは仮引数
void f( int x ) ;

int main()
{
// 0は実引数
    f(0) ;
// argは実引数
    int arg = 0 ;
    f( arg ) ;
}

このように、関数の宣言や定義などの引数を、仮引数といい、関数の呼び出しの際に指定する引数を、実引数という。仮引数と実引数は、厳密に区別される。

静的な型（static type）と、動的な型（dynamic type）

静的な型とは、実行しなくても、その意味が分かる型のことである。動的な型は、実行しなければ、その意味が決定出来ない型のことである。

シグネチャー（signature）

シグネチャーとは、ある関数に対する、その関数の名前、引数のリストの型、戻り値の型、テンプレート仮引数のことである。また、メンバー関数の場合は、そのクラスや、CV修飾、リファレンス修飾も含まれる。また、その関数の属する名前空間も含まれる。シグネチャーは、その関数を特定するために用いられる。

ill-formedプログラムと、well-formedプログラム

well-formedプログラムとは、文法上正しいプログラムである。ill-formedプログラムとは、well-formedではないプログラム、すなわち、文法上、間違ったプログラムである。多くの実装では、ill-formedプログラムは、コンパイルエラーとなる。

実装可能な機能（conditionally-supported）

実装可能な機能とは、規格上、実装してなくてもよい機能や動作のことである。

実装定義の動作（implementation-defined behavior）

実装定義の動作とは、well-formedではあるが、その意味が、実装によって変わるということである。

未定義の動作（undefined behavior）

未定義の動作とは、そのプログラムの意味が、規格上定義されていないということである。その動作は実装によって異なり、あるいはエラーとなるかもしれないし、あるいは問題なく結果が予測できる動作となるかもしれない。一般に、エラーとなる場合が多い。未定義の動作を含むプログラムを書く場合は、そのコードの意味が、目的の実行環境で、明確に定義されているかどうかを確認するべきである。

未規定の動作（unspecified behavior）

未規定の動作も、具体的な意味が、実装によって異なると言う点で、未定義の動作と変わらない。ただし、未規定の動作は、規格上、推奨される動作が決められていることも多く、多くの実装で、エラーにならない、何らかの意味のあるコードになると言う点で、未定義の動作よりは、安全である。ただし、これも、目的の実行環境での意味がどうなるのかを、正しく把握しておく必要がある。

基本ソース文字セット

基本ソース文字セット（basic source character set）とは、ソースファイルで使うことができる文字のことである。印字可能な文字は、以下の通り。

a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
0 1 2 3 4 5 6 7 8 9
_ { } [ ] # ( ) < > % : ; . ? * + - / ^ & | ~ ! = , \ " '

上記に加えて、スペース、水平タブ、垂直タブ、フォームフィード、改行も使うことができる。

たとえば、ASCIIでいえば、@（アットマーク）や`（グレイヴ・アクセント）のような文字は、使われていない。

ユニバーサル文字名

ユニバーサル文字名（UCN：universal character name）とは、ISO/IEC 10646で定義されている文字コードのことである。この文字コードは、ユニバーサル文字セットと呼ばれている。また、厳密には同じではないが、俗に、Unicodeと呼ばれることもある。UnicodeはUnicodeで、別の規格があるのだが、実用上、どちらもコードポイントやエンコード方式に、差がないため、よく混同される。本書では、ユニバーサル文字セットや、UTFエンコードに関する解説は行わない。

Nを16進数の一文字とすると、\uNNNNは、UCSにおけるコードポイント、0000NNNNで表される文字という意味になり、\UNNNNNNNNは、NNNNNNNNで表される文字と同じ意味になる。

\u3042      あ
\u3043      い
\U00003044  う

このユニバーサル文字名は、リテラルやエスケープシーケンスではなく、もっと根本的に、文字と同等に扱われる。つまり、対応するユニバーサル文字として認識される。ユニバーサル文字名は、ソースコードのあらゆる場所で使うことができる。ソースコードのある場所に、ユニバーサル文字名を記述した場合、その場所に、対応するユニバーサル文字を記述したのと、全く同じ扱いがなされる。

ただし、生文字列リテラルの中では、ユニバーサル文字名は使えない。サロゲートの範囲のコードポイント(0xD800–0xDFFF)を指定することはできない。文字列リテラルの中では、ユニバーサル文字は実装により自動的にエンコードされるので、サロゲートコードポイントを明示的に使う必要はない。もし文字としてサロゲートコードポイントを使う必要があるならば、エスケープシーケンス\xが使える。文字リテラルや文字列リテラルの中以外では、コントロール文字の範囲のコードポイント(0x00–0x1F と 0x7F–0x9F)と、基本ソース文字セットに該当するコードポイントを指定することはできない。

R"(\u3042)" ; // ユニバーサル文字名ではなく、文字通りに解釈されることに注意
u8"\u00E3\u0081\u0082" ; // OK、u8"あ"と同じ

u"\ud842\udfb7" ; // エラー、サロゲートコードポイントを明示的に使うことはできない
u"\U00020bb7" ; // OK、u"𠮷"と同じ

int \u0041 = 0 ; // エラー、ここで基本ソース文字セットは使えない
int \u3042 = 0 ; // OK

予約語

予約語とは、C++の実装や標準ライブラリの実装のために予約されていて、使ってはならない名前のことである。ユーザーコードで予約語を使った場合、プログラムの動作は保証されない。

以下のいずれかの条件に当てはまる名前は、あらゆる利用を予約されている。

• ひとつのアンダースコアに大文字から始まる名前
• アンダースコアが二つ連続している、いわゆるダブルアンダースコアを含む名前

以下のコードは、すべて予約名を使っているので、エラーである。

int _A ;    // アンダースコアに大文字から始まる名前は、予約されている。
int __a ;   // ダブルアンダースコアを含む名前は、予約されている。
int ___a ;  // 三つの連続したアンダースコアも、ダブルアンダースコアを含むので、使えない。
int a__b ;  // 先頭以外でも、どこかにダブルアンダースコアが含まれている場合、使えない。
int a__ ; // ダブルアンダースコアを含む
int __ ; // ダブルアンダースコアを含む

ひとつのアンダースコアから始まる名前は、グローバル名前空間で、利用を予約されている。ただし、グローバル名前空間との名前の衝突が、時として、意外な結果をもたらすこともあるので、言語のルールの詳細を把握していない限り、利用はおすすめできない。

// エラー、グローバル名前空間
int _a ;

// OK
namespace NS { int _a ; }

int main()
{
    int _a ; // OK
}

ひとつのアンダースコアだけの名前は、予約語ではない。

int _ ; // OK
int __ ; // エラー、ダブルアンダースコア

簡単にまとめると、アンダースコアから始まる名前は、使うべきではない。ダブルアンダースコアを含む名前は、あらゆる使用を禁止されている。

名前の衝突を防ぐため、しばしばC++の理解の浅い者によってアンダースコアが用いられるが、予約語と衝突した場合、コード自体の動作が保証されなくなってしまうので、名前の衝突を防ぐ目的でアンダースコアを使ってはならない。名前の衝突を防ぐためには、名前空間という言語機能がある。

整数リテラル（Integer literals）

整数リテラルには、10進数リテラル、8進数リテラル、16進数リテラルがある。C++には、2進数リテラルは存在しない。

十進数リテラルには、0123456789の文字を使うことができる。

8進数リテラルには、01234567の文字を使うことができる。プレフィクス、0から始まる整数リテラルは、8進数リテラルである。

16進数リテラルには、0123456789, abcdef, ABCDEFの文字を使うことができる。大文字と小文字は、区別されない。プレフィクス、0xから始まる整数リテラルは、16進数リテラルである。

// 10進数リテラル
1234 ;

// 8進数リテラル
01234 ; // 10進数では、668

// 16進数リテラル
0x1234 ; // 10進数では、4660

0xというプレフィクスが、16進数リテラルを表すのは、他のプログラミング言語でも、よくあることだ。しかし、C++では、8進数リテラルのプレフィクスが変わっている。これは、注意を要する。

// if ( x == 8 ) と同じ。
if ( x == 010 )

C++の8進数リテラルは、10進数と区別しにくいので、気をつける必要がある。

整数リテラルには、後ろにサフィックスをつけることができる。このサフィックスは、大文字小文字が区別されない。

サフィックス、u、Uは、整数リテラルの型が、unsignedであることを示す。

// signed int
auto type1 = 0 ;

// unsigned int
auto type2 = 0u ;
auto type3 = 0U ;

サフィックス、l、Lは、型がlong intであることを示す。サフィックス、ll、LLは、型がlong long intであることを示す。

// long int
auto type1 = 0l ;
auto type2 = 0L ;
// long long int
auto type3 = 0ll ;
auto type4 = 0LL ;

unsignedであることを示すサフィックスと、long int、またはlong long intであることを示すサフィックスは、組み合わせることができる。順番は、どちらでもいい。

// unsigned long int
auto type1 = 0ul ;
auto type2 = 0lu ;

整数リテラルの型の決定は、複雑である。もし、10進数の整数リテラルの値が、intの範囲で表現できない場合は、long intが使われる。long intでも表現できない場合は、long long intが使われる。8進数と16進数の整数リテラルの場合は、unsigned int, unsigned long int, unsigned long long intも、考慮に入れられる。

ただし、l, Lというサフィックスが指定されている場合は、long int以降が使われる。u, Uが指定されている場合は、unsignedな整数型に限られる。

いずれの型でも、整数リテラルの値を表現できない場合は、ill-formedである。

浮動小数点数リテラル（Floating literals）

浮動小数点数のリテラルは、10進数で記述する。

1.0 ;
123456789.0 ;
3.14 ;
0.00000001 ;

浮動小数点数リテラルには、e, Eに続けて、指数（exponent）を指定することができる。指数を指定すると、小数に、10の指数乗をかけた値になる。

// 1 × 101 = 1 × 10 = 10
1e1 ;
1E1 ; // Eでも同じ意味
1e+1 ; // 指数には符号を指定できる。

// 0.12345 × 102 = 0.12345 × 100 = 12.345
0.12345e2 ;

// 12345 × 10-2 = 12345 × 0.01 = 123.45
12345e-2

// 123 × 100 = 123 × 1 = 123
123e0 ;

浮動小数点数リテラルの型は、非常に簡単である。サフィックス、f, Fが指定されているリテラルの型は、float、サフィックスが指定されていない型は、double、サフィックス、l, Lが指定されている型は、long doubleである。このサフィックスは、大文字小文字が区別されない。

// float
auto f1 = 1.0f ;
auto f2 = 1.0F ;

// double
auto d1 = 1.0 ;
auto d2 = 1.0 ;

// long double
auto l1 = 1.0l ;
auto l2 = 1.0L ;

もし、リテラルの値を、リテラルの型で、完全に表現できない場合は、最も近い値に丸められる。値をどのようにして丸めるかは、実装依存である。もし、リテラルの値を、リテラルの型で表現できない場合は、エラーとなる。

文字リテラル（Character literals）

文字リテラルとは、ある一文字を表すリテラルのことである。文字リテラルは、以下のように記述する。

'x'     通常の文字リテラル（ordinary character literal）
u'x'    char16_t型の文字リテラル
U'x'    char32_t型の文字リテラル
L'x'    wchar_t型の文字リテラル。

プレフィクスのついていない、'x'は、通常の文字リテラル（ordinary character literal）である。型は、charである。このリテラル内に書かれている一文字の値が、そのまま、リテラルの値になる。通常の文字リテラルの具体的な値については、実装依存である。

プレフィクス、Lのついている文字リテラル、L'X'は、ワイド文字リテラルである。型は、wchar_tである。このリテラル内に書かれている一文字の値が、そのまま、リテラルの値になる。ワイド文字リテラルの具体的な値については、実装依存である。

プレフィクス、uのついている文字リテラル、u'x'は、char16_t型の文字リテラルである。これは、一文字のユニバーサル文字セット内の、16bitで表現できるコードポイントに当たる文字を使うことができる。このエンコード方式は、UTF-16と呼ばれている。文字リテラルは、16bitで表せる一文字しか使えないので、サロゲートペアは使えない。もちろん、文字列リテラルでは、サロゲートペアもサポートされている。

プレフィクス、Uのついている文字リテラル、U'x'は、char32_t型の文字リテラルである。これは、一文字の任意のユニバーサル文字セット内の文字を使うことができる。このエンコード方式は、UTF-32と呼ばれている。

// 型はchar、値は実装依存。
auto ordinary_c = 'x' ;
// 型はwchar_t、値は実装依存。
auto wide_c = L'x' ;
// 型は、char16_t、値は、0x3042。
auto u16_c = u'あ' ;
// 型は、char32_t、値は、0x00003042。
auto u32_c = U'あ' ;

改行 new-line NL(LF) \n
水平タブ horizontal tab HT \t
垂直タブ vertical tab VT \v
バックスペース backspace BS \b
キャリッジリターン carriage return CR \r
フォームフィード form feed FF \f
アラート文字、ベル文字 alert BEL \a
バックスラッシュ backslash \ \\
疑問符 question mark ? \?
単一引用符 single quote ' \'
二重引用符 double quote " \"

'\n' ;  // 改行
'\\' ; // バックスラッシュ

// 二重引用符と疑問符は、そのまま使える。
'"' ;   '\"' ;
'\?' ;  '?' ;


// エラー、バックスラッシュはエスケープシーケンスの始まりとみなされるため、使えない。
'\' ;

文字列リテラル（String literals）

文字列リテラル（String Literal）には、通常の文字列リテラル、UTF-8文字列リテラル、char16_t文字列リテラル、char32_t文字列リテラルが存在する。また、それぞれの文字列リテラルに対して、生文字列リテラル（Raw String Literal）という書き方ができる。

文字列リテラルの文法は、以下の通りである。

エンコーディングプレフィクスopt " 文字列 "

文字列リテラルは、文字列の内容で初期化される。ただし、文字列の一番最後には、null文字が付加される。

// 以下の二行のコードは同じ意味である。
char s[4] = { 'a', 'b', 'c', '\0' } ;
char s[] = "abc" ;

文字列リテラルでは、文字リテラルと同じ、エスケープシーケンスが使える。ただし文字リテラルと違い、二重引用符は、そのまま使うことができないので、エスケープシーケンス、\"で表さなければならない。単一引用符、'は、そのまま使うことができる。それ以外は、文字リテラルのエスケープシーケンスと、違いはない。

文字列リテラルの型は、要素数nの、constな文字型の配列である。要素数は、文字列リテラル内の文字型の数 + 1である。+ 1は、null文字が付加されるためである。エスケープシーケンスや、ユニバーサル文字名は、一文字として認識される。文字型の数と、文字数とは、同じではない。なぜならば、エンコード方式によっては、ひとつの文字を、複数の文字型で表現するからである。これについては、後述する。

"abcdefg" ;
"hello" ;

// const char [4]
"abc" ;
u8"abc" ;
// const char [1]
"" ;
u8"" ;

// const char16_t [4]
u"abc" ;
// const char16_t [1]
u"" ;

// const char32_t [4]
U"abc" ;
// const char32_t [1]
U"" ;

// const wchar_t [4]
L"abc" ;
// const wchar_t [1]
L"" ;

文字列リテラルの型は、配列であるので、標準変換の、配列からポインターへの型変換で、ポインターへ、暗黙のうちに変換できる。しかし、C++11では、以前のC++にあった、互換性のための機能が、削られているので、注意を要する。

// エラー
char * ptr = "abc" ;
// OK
char const * ptr = "abc" '

なぜか。文字列リテラルの型は、constな文字型の配列である。constは、暗黙のうちに消しさることはできない。たとえば、int型の場合、これは、従来のC++でも、エラーである。

int const a[4] = {0} ;
// エラー
int * ptr = a ;

今までは、互換性のためだけの理由で、文字型の配列に限り、constを暗黙のうちに消しさることが、特別に許されていた。しかし、そもそも、文字列リテラルへの変更は、未定義である。

// エラー、未定義動作
"abc"[0] = 'd' ;

このため、C++では、文字列リテラルは、constな文字型の配列であることが、1993年に決定された。本来、この時点で、constではない文字型へのポインターへの変換は、廃止されるべきであった。しかし、char *に文字列リテラルを代入している既存のコードが、あまりにも多いため、仕方なく、特別なルールを付け加えた。それが、この、文字型の配列に限り、constを消すことができるというルールである。

constを暗黙のうちに消し去ることができると、C++の型システムに穴があいてしまう。いままでは、互換性の問題から、仕方なくこのルールがあったが、C++11では、とうとう、この忌々しい穴は塞がれた。もし、どうしても、既存のコードを利用したい場合は、いくつか方法がある。

// 既存の汚いコードの関数
void f( char * ) ;

// 配列を確保して、渡す。
char temp[] = "abc" ;
f( temp ) ;

// const_castを使用する（非推奨）
f( const_cast<char *>("abc") ) ;

そもそも、constではないポインターということは、そのポインターの参照先が、変更されるかもしれないということを意味している。つまり、この関数f()は、ポインターの参照先を書き換えるかもしれない。しかし、文字列リテラルの変更は、そもそも未定義である。したがって、f()には、書き換えられる配列を確保して、そのポインターを渡すのが、正しい。const_castは、f()が、既存のコードであり、今更修正できず、なおかつ、ポインターの参照先を変更しないと保証できる場合に限り、const_castを使うべきである。

これから書くコードは、もちろん、constをつけるべきである。本来、変更できないオブジェクトを、非constなポインターで参照できるということが、そもそも間違っている。C++11では、このような暗黙の型変換は存在しない。

char abc[] = u8"abc" ;
char abc[4] = { 0x61, 0x62, 0x63, 0x00 } ;

char str[] = u8"あ" ;
char str[4] = { 0xe3, 0x81, 0x82, 0x00 } ;

char16_t str[] = u"あ" ;
char16_t str[2] = { 0x3042, 0x0000 } ;

char utf8[] = u8"𠮷" ;
char utf8[5] = { 0xf0, 0xa0, 0xae, 0xb7, 0x00 } ;

char16_t utf16[] = u"𠮷" ;
char16_t utf16[3] = { 0xd842, 0xdfb7, 0x0000 } ;

char32_t utf32[] = U"𠮷" ;
char32_t utf32[2] = { 0x00020bb7, 0x00000000 } ;

aaa
bbb
ccc
\\\
"""

"aaa\nbbb\nccc\n\\\\\\\n\"\"\""

エンコーディングプレフィクスopt R " デリミターopt ( 文字列 ) デリミターopt "

// ""と同じ
R"()" ;

// "aaa\nbbb\nccc\n\\\\\\\n\"\"\""と同じ
R"(aaa
bbb
ccc
\\\
""")" ;

R"delimiter( )" )delimiter" ;

// エラー、@という字は、基本ソース文字セットには存在しない。
R"@()@" ;

// エラー、17文字以上書くことはできない。
R"12345678901234567()12345678901234567" ;

u8R"()" ;
uR"()" ;
UR"()" ;
LR"()" ;

// "1\n2\n3456"
R"(1
2
3)"
"456" ;

boolリテラル（Boolean literals）

boolリテラルは、bool型の真偽を表現するリテラルである。trueとfalseという、二つの値がある。

bool t = true ;
bool f = false ;

ポインターリテラル（Pointer Literals）

C++には、nullポインターを表すリテラルが存在する。nullptrである。これは、あらゆるポインター型の、nullポインターを表す。

void * pointer_to_void = nullptr ;
int * pointer_to_int = nullptr ;

従来のC++では、NULLというマクロを使ったり、0を使ったりしてきた。しかし、マクロは問題が多いし、0にも、問題がある。nullポインターは、その内部表現の、すべてのビットが0であることを意味するのではない。ポインターが、何も参照していないということを表す、概念上のものである。そこで、nullptrという、nullポインターを表すポインターリテラルが存在する。従来のNULLや、単なる0のかわりに、nullptrを使うべきである。

ユーザー定義リテラル（User-defined literals）

ユーザー定義リテラル（User-defined literal）とは、リテラルを、関数として定義できるようにする機能のことである。整数、浮動小数、文字、文字列に対するユーザー定義リテラルが存在する。

// ユーザー定義整数リテラル
123_x ;
// ユーザー定義浮動小数リテラル
1.23_x ;
// ユーザー定義文字リテラル
'a'_x ;
// ユーザー定義文字列リテラル
"abc"_x ;

ユーザー定義リテラルは、演算子のオーバーロードとして、定義する。詳しくは、ユーザー定義リテラル（User-defined literals）を参照のこと。

宣言（Declaration）と定義（Definition）の違い

宣言とは、ある名前が、その翻訳単位で、何を意味するのかということを、明示するためにある。

定義とは、名前の指し示すものを、具体的に記述することである。宣言と定義は、多くの場合、同時に行われることが多いので、あまり意識しづらい。

// これは関数の宣言
void f( ) ;

// これは関数の宣言と定義
void f( ) { }

以下の例は、関数を宣言だけして、具体的な定義をせずに、使っている。

// 関数の宣言
int f( int ) ;

int main()
{
    int x = f( 0 ) ;
}

これは、問題がない。なぜならば、関数を使うには、引数や戻り値の型などが決まってさえいればよいからだ。この場合、その関数を指し示す名前として、fが使われている。この関数 int f( int )の、具体的な実装、つまり、「定義」は、同じ翻訳単位になくても構わない。つまり、int f( int )は、別のソースコードで定義されているかもしれない。

定義ではない宣言

すべての定義は、宣言である。宣言は、定義ではない場合もある。定義ではない宣言は、以下の通りである。

// 宣言
void f( int ) ;

// 宣言と定義
void f( int ) { }

// 宣言
extern int x ;

// 宣言と定義
int x ;

// 宣言
extern "C" void f() ;


extern "C"
{
// これは、宣言と定義
    void f() { }
    int x ;

// 宣言
    void g() ;
    extern int y ;
}

// クラス名の宣言
class C ;

// クラスの宣言と定義
class C { } ;

class C
{
// 宣言
    static int x ;
} ;

// 定義
int C::x ;

// 宣言
enum E ;

// 宣言と定義
enum E { up, down } ;

// 宣言
typedef int type ;

namespace NS { void f(){} } 

// 宣言
using NS::f ;
using namespace NS ;

また、static_assert宣言、アトリビュート宣言、空宣言は、定義ではない。

static_assert( true, "" ) ; // 宣言
[[ ]] ; // 宣言
 ; // 宣言

宣言領域とスコープ（Declarative regions and scopes）

宣言された名前には、その名前が有効に使える範囲が存在する。これを、宣言範囲（declarative region）、スコープ（scope）という。

int x ;

void f()
{
    int y ;

    {
        int z ;
    }
// ここではもう、zは使えない。
}
// ここではもう、yは使えない。

// xは、ここでも使える。

ある名前は、スコープの中ならば、必ず同じ意味であるとは限らない。名前は上書きされる場合がある。

void f()
{ // ブロック1
    int x ; // #1
    { // ブロック2
        int x ; // #2
        x = 0 ; // #2が使われる。
    }
    x = 0 ; // #1が使われる。
}

この例では、ブロック1で宣言されたxは、ブロック2では、別の変数を指し示すxに、隠されている。

このように、スコープがネストする場合、外側のスコープの名前が、内側のスコープの名前に隠されてしまうことがある。

宣言場所（Point of declaration）

スコープには、いくつもの種類がある。これを詳しく説明する前に、まず、宣言された名前は、どこから有効なのかということを、明らかにしておかなければならない。この、名前が有効になる始まりの場所を、宣言場所（Point of declaration）という。名前は、宣言のすぐ直後から有効になる。

int x ; // 宣言場所
// ここから、xが使える。

宣言場所は、初期化子よりも、前である。

int x /*ここから名前xは有効*/ = x  ;

この例では、xという変数を宣言して、その変数の値で初期化している。このコードに実用的な意味はない。初期化子の中から、宣言された名前は使えるということを示すためだけの例である。

// エラー
int x[x /*ここでは、まだxは未定義*/ ] ;

この例は、エラーである。なぜなら、配列の要素数を指定する場所では、xは、まだ定義されていないからだ。これらの例は、通常は気にすることはない、些細な詳細である。一般に、宣言文のすぐ後から使えると考えておけばいい。

ブロックスコープ（Block scope）

ブロックのスコープは、そのブロックの中である。これを、ブロックスコープと呼ぶ。よく、ローカル変数と呼んでいるものは、ブロックスコープの中で宣言された変数のことである。

void f()
{ // ブロック1
int x ;
    { // ブロック2
    int y ;
        { // ブロック3
        int z ;
        // x, y, zが使える
        }
    // x, yが使える。
    }
// xが使える。
}

// ここで使える変数名はない。

ブロックはネストできるので、ネストされたブロックの中で、外側のスコープと同じ名前の変数を使いたい場合は、注意が必要である。

void f()
{
    int x ;
    {
        int x ; // 外側のスコープのxは隠される。
    }
}

関数の仮引数名は、関数本体の一番上のブロックスコープの終わりまで、有効である。

void f( int x )
{

// xはここまで有効
}
// これ以降、xは使えない。

関数プロトタイプのスコープ（Function prototype scope）

関数のプロトタイプ宣言にも、スコープがある。関数のプロトタイプ宣言のスコープは、その宣言の終わりまでである。

auto f( int x ) -> decltype(x) ;

この例では、仮引数の名前が、decltypeに使われている。

関数のスコープ（Function scope）

ブロックスコープではなく、関数自体にも、関数のスコープが存在する。これは、ある関数全体のスコープである。ただし、この関数のスコープが適用されるのは、ラベル名だけである。

void f()
{
    {
        label : ;
    }

    goto label ; // labelは、ここでも有効
}

このように、ラベル名には、関数のスコープが適用される。

名前空間のスコープ（Namespace scope）

名前空間のスコープというのは、少しややこしい。まず、名前空間の本体は、もちろんスコープである。

namespace NS
{
    int x ;
// xが使える。
}
// ここでは、xは使えない。

この、名前空間の中の名前（上の例では、x）を、名前空間のメンバー名という。メンバー名のスコープは、名前空間の終わりまでである。

ところが、名前空間の本体の定義は、複数書くことができる。

namespace NS
{
    int x ;
// xが使える。
}
// ここでは、xは使えない。


namespace NS
{
    // ここでも、xが使える。
    int y = x ;
}

メンバー名は、その宣言された場所から、後続するすべての同名の名前空間の中で使うことができる。この例の場合、二つめの名前空間NSの定義の中でも、一つめの名前空間NSの定義で宣言されたメンバー名である、xを使うことができる。

名前空間のメンバーは、スコープ解決演算子、::を使って、参照することもできる。

namespace NS
{
    using type = int ;
}

// 名前空間NSの、typeという名前を参照している。
NS::type x ;

// グローバル名前空間
int x ;

namespace NS
{ // 名前空間、NS

}

// ここは、グローバル名前空間

namespace 
{ // 無名名前空間

}

// ここも、グローバル名前空間

// xの範囲は、翻訳単位の終わりまで続く。

クラスのスコープ（Class scope）

クラスのスコープは、少し変わっている。ブロックスコープなどは、名前の有効な範囲は、名前を宣言した場所から、スコープの終わりまでである。

void f()
{
// ここでは、xは使えない。

int x ; // xを宣言

// ここでは、xを使える。
}

クラスでは、これが変わっている。

先に、名前が宣言されていなくても、クラス内の関数からは、その名前を使うことができる。

class C
{
    void f()
    { // 関数の中で、名前を使うことができる。
        type x ;
        value = 0 ;
    }

    type y ;    // エラー。typeは宣言されていない。

    using type = int ;  // typeの宣言場所

    type z ; // OK

    int value ;         // valueの宣言場所
} ;

また、クラスのメンバー関数を、クラスの外部で定義する場合でも、その関数の中から、クラス内で宣言された名前を使うことができる。

class C
{
    void f() ;
    int x ;
} ;

void C::f()
{ // クラス外部で定義されたメンバー関数の中で、クラス内で宣言された名前を使える。
    x = 0 ;
}

その他にも、クラス内の名前を、クラス外で使うことができる場合が存在する。

class C
{
public :
    int x ;
    using type = int ;
} ;

int main()
{
    C c ;
    C * p = &c ;
    // クラスのメンバーアクセス演算子の後に続けて、名前を使える。
    c.x = 0 ;
    p->x = 0 ;

    // スコープ解決演算子の後に続けて、名前を使える。
    C::type value ;
}

このように、クラススコープの名前は、宣言した場所から、ある区間まで有効というルールではない。このため、クラスのスコープには特別なルールがある。

• クラスのメンバーの宣言が全てわかったあとに、クラス宣言を再評価して、プログラムの意味が変わるとエラー
• クラス内のメンバーの宣言の順番を変えた際に、プログラムの意味が変わると、エラー

これは、例をあげて説明したほうが分かりやすい。今仮に、このルールがないものとする。とすると、以下のようなコードが書けてしまう。

// コード1
using type = int ; // #1

class C
{
    type x ; // このtypeは、#1の::type
    using type = float ; // #2
} ;

クラスCの宣言の順番を変えると、以下のコードになる。

// コード2
using type = int ; // #1

class C
{
    using type = float ; // #2
    type x ; // このtypeは、#2の、C::type
} ;

このように、メンバーの宣言の順番を変えることによって、プログラムの意味が変わってしまうと、意図せぬバグを生む原因となる。そのため、このようなコードは、エラーである。

enumのスコープ（Enumeration scope）

scoped enumは、enumスコープ（enumeration scope）を持つ。このスコープの範囲は、enumの宣言内だけである。

enum class E { x, y, z } ;
// ここで、x, y, zは使えない。
x ; // エラー
E::x ; // OK

この理由は、scoped enumは、強い型付けを持つenumだからだ。詳しくは、enumを参照のこと。

テンプレート仮引数のスコープ（Template Parameter Scope）

テンプレート仮引数にも、スコープがある。テンプレート仮引数のスコープは、それほど意識する必要はない。

template <
typename T, // これ以降、Tを使える。
typename U = T >
class C { } ; // テンプレート仮引数のスコープ、ここまで

ただし、テンプレート仮引数名は、基本的に、隠すことができない。

template < typename T >
class C
{
    using T = int ; // エラー

    // エラー
    template < typename T >
    void f() ;

} ;

「基本的に」というのは、隠すことができる場合も存在するからだ。

struct Base{ using T = type ; } ;

template < typename T >
struct Derived : Base
{
    T x ; // Base::Tが使われる。テンプレート仮引数ではない。
} ;

といっても、これはよほど特殊な例であり、通常は、テンプレート仮引数名は、隠せないと考えても、問題はない。

名前隠し（Name hiding）

ネストされたスコープの内側で、同じ名前が宣言されると、外側の名前は、隠される。

void f()
{ // 外側のスコープ
    int x ;
    { // 内側のスコープ
        int x ; // 外側のスコープのxを隠す。
        x = 0 ; // 内側のx
    }
    x = 0 ; // 外側のx
}

派生クラスでは、基本クラスの名前は隠される。

struct Base { using type = char ; } ;

struct Derived : Base
{
    using type = int ;

    type x ; // int
} ;

クラスやenumの名前は、変数やデータメンバーの名前によって、隠される。

class ClassName {} ;

void f()
{
    ClassName ClassName ; // OK、ClassName型の変数、ClassName

    ClassName x ; // エラー、ClassNameは、ここでは変数名を指す。

    class ClassName x ; // OK、明示的にクラス名であると指定している。
}

このように、クラス名と変数名を同じにするのは、非常に分かりにくい問題を引き起こすので、あまりおすすめできない。

Qualified 名前探索（Qualified name lookup）

Qualified nameとは、qualified（修飾）という名前通り、スコープ解決演算子（::）を使った名前のことである。

int g ;

namespace NS { int x ; }

struct C { static int x ; } ;
int C::x ;

enum struct E { e } ;

int main()
{
    // これらはQualified name lookup
    NS::x ; // NSという名前空間のx
    C::x ;  // Cというクラスのx
    E::e ; // Eというenumのメンバー、e
    ::g ;   // グローバル名前空間のg
    
}

このような名前に対する名前探索を、Qualified name lookupという。

スコープ解決演算子（::）の左側には、クラス名か、名前空間名か、enum名を書くことができる。左側に何も書かない場合、グローバル名前空間が使われる。Qualified name lookupでは、名前は、スコープ解決演算子で指定された、クラスや名前空間、enum内の名前から、探索される。

スコープ解決演算子は、ネストできる。

namespace N1 { namespace N2 {
    int x ;
} }

N1::N2::x ;

Unqualified 名前探索（Unqualified name lookup）

Unqualified（非修飾） name lookupは、Qualified name lookup以外を指す。これはつまり、スコープ解決演算子を使わない名前に対する、名前探索である。

int g ;

namespace NS { int x ; }

int main()
{
    g ; // グローバル変数のg

    int g ;
    g ; // ローカル変数のg

    {
        using namespace NS ;
        x ; // NS::xと同じ
    }

    {
        using NS::x ;
        x ; // NS::xと同じ
    }
}

Unqualified nameに対する名前探索を、Unqualified name lookupという。Unqualified name lookupでは、その名前が使われている場所で、明示的に修飾しなくても、見つかる名前が探される。これは、例えばグローバル名前空間内の名前であったり、クラス内であれば、クラスのメンバーであったりする。また、using directiveや、using declarationの影響をうける。

ADL（Argument-dependent name lookup）

Unqualified nameに対して、関数呼び出しをする場合、特別なルールがある。このルールを、ADL(Argument-dependent name lookup)という。

namespace NS
{
    class C {} ;
    void f( C ) {}
}

int main()
{
    NS::C c ;
    f(c) ; // NS::fを呼ぶ
}

このコードでは、通常は見つからないはずの、NSという名前空間内の関数であるfが、Unqualified nameなのにもかかわらず、見つかる。これを、実引数に依存する名前探索（Argument-dependent name lookup）と呼ぶ。しばしば、ADLと略される。また、Andrew Koenigさんが、名前空間の導入によって、特に演算子のオーバーロードで、ADLのような必要性を意見したため、Koenig lookupとも呼ばれることがある。Andrew Koenigさんが、ADLの具体的な仕組みを考案したわけではない。誰がADLの原案を考えだしたのかは、歴史に埋もれて忘れ去られているが、そのような歴史的な経緯と誤解により、Koenig lookupと呼ばれている。

このADLというルールは、一見すると、非常に奇妙なルールである。このような仕組みは、非常に厄介な問題を引き起こすのではないか。事実、ADLは時として、問題になることがある。それでもADLが存在するのは、利点があるからだ。

整数を表現するクラス、Integerを考える。名前の衝突を防ぐため、このクラスは、libという名前空間の中に入れたい。また、整数として分かりやすく使うために、演算子をオーバーロードしたい。Integerクラスは、以下のように使えるものとする。

int main()
{
    lib::Integer x ;
    // 演算子のオーバーロードによる、分かりやすい加算のコード。
    x + x ;
}

さっそく、このIntegerを実装してみよう。

namespace lib
{
    // クラス
    class Integer { /*実装*/ } ;
    // 演算子のオーバーロード
    Integer operator + ( Integer const &, Integer const &)
    {
        // 実装
        return Integer() ;
    }
}

もしここで、ADLがない場合、operator +()の呼び出しが、困ったことになる。なぜなら、Unqualified lookupでは、lib名前空間の中の名前を探してはくれない。つまり、operator +は、見つからないのである。

lib::Integer x ;
// エラー、operator + が見つからない。
x + x ;

ではどうするか。これは、Qualified lookupを使うしかない。

lib::operator +( x, x ) ;

このコードは動く。確かに動くが、これでは、せっかく演算子をオーバーロードした意味がない。そもそも、演算子をオーバーロードする理由とは、x + x という、分かりやすい使い慣れたコードを書くためだからだ。

このため、Unqualified nameに対する、関数呼び出しには、Unqualified name lookupに加えて、ADLという仕組みで、名前が探索されるようになっている。

namespace NS
{
    class A {} ; class B {} ; class C {} ; class D {} ;
    void f( A, B, C, D ) {}
}

int main()
{
    NS::A a ; NS::B b ; NS::C c ; NS::D d ;
    f( a, b, c, d ) ;
}

namespace A { class C {} ; }
namespace B
{
    class C {} ;
    void f( A::C, B::C ) {}
}

int main()
{
    A::C ac ; B::C bc ;
    f( ac, bc ) ;
}

namespace NS
{
    class A {} ;
    class B : A {} ;
    class C : B {} ;

    void f( C ) {}
}

int main()
{
    NS::C c ;
    f( c ) ;
}

namespace NS
{
    template < typename T > class C {} ;
}

namespace lib
{
    class type {} ;

    template < typename T >
    void f( NS::C<T> ) {}
}

int main()
{
    NS::C< lib::type > c ;

    // 関連クラスは、NS::C< lib::type >と、lib::type。
    // 関連名前空間は、NSと、lib。
    f(c) ; // lib::fを呼び出す。
}

namespace NS
{
    enum struct E { value } ;
    void f( E ) {}
}

int main()
{
    f( NS::E::value ) ; // NS::fを呼び出す。
}

namespace NS
{
    class C {} ;

    void f( C ) {}
    void g( C ) {}
}

void g( NS::C ) {}

int main()
{
    NS::C c ;
    

    f(c) ;      // ADLで、NS::fを呼ぶ
    NS::f(c) ;  // Qualified name lookupが行われる

    ::g(c) ;    // Qualified name lookupが行われる
    NS::g(c) ;  // Qualified name lookupが行われる
    
    
    g(c) ;      // エラー。::g、NS::gのどちらの名前か、曖昧。
}

namespace NS
{
    class C {} ;
    void f( C ) {}
}

int f ;

struct Caller
{
    void f( NS::C ) {}

    void g()
    {
        NS::C c ;
        f(c) ; // Caller::fが呼ばれる。ADLは行われない。
    }
} ;

int main()
{
    NS::C c ;

    f(c) ; // エラー。fはint型の変数
}

namespace NS
{
class C {} ;

void f( C ) {}
}

namespace lib { void f( NS::C ) {} }

int main()
{
    NS::C c ;

    {
        void f( NS::C ) ; // ブロックスコープの関数宣言
        f(c) ; // ::fを呼び出す。ブロックスコープの宣言が見つかったので、ADLは行われない。
    }

    {
        using namespace lib ;
        f(c) ; // エラー、ADLも行われるので、曖昧になる。
    }

    {
        using lib::f ;
        f(c) ; // エラー、ADLも行われるので、曖昧になる。
    }
}

// ブロックスコープの関数宣言で参照される、グローバル名前空間のf
void f( NS::C ) {}

namespace NS
{
class C {} ;
void f( C ) {}
}

void f( NS::C ) {}

int main()
{
    NS::C c ;

    f(c) ; // エラー。曖昧

    (f)(c) ; // OK、ADLは適用されない。::fを呼び出す。
}

main関数（Main function）

プログラム中にある、mainという名前のひとつのグローバル関数から、プログラムは開始する。freestanding環境でmainの定義を必要とするかどうかは実装依存である。ホスト環境と違い、freestanding環境では、開始と終了も実装依存となる。

main関数は特別な扱いを受ける。C++の実装は、mainを予め定義してはならない。main関数はオーバーロードできない。戻り値の型はintであるが、main関数自体の型は実装依存となる。

規格では、C++の実装は、以下の二つの形のmain関数を受け付けるように規定されている。

• 関数で、仮引数が()で、intを返すもの

  int main() ;
  auto main() -> int ;
  

• 関数で、仮引数が( int, charへのポインターへのポインター )で、intを返すもの

  int main( int, char ** ) ;
  // 仮引数に配列型を書くと、ポインター型になる。
  int main( int, char *[] ) ;
  

2つ目の形では、慣習的に、関数の1つ目の仮引数はargcと呼ばれていて、2つ目の仮引数はargvと呼ばれている。argcはプログラムの実行される環境で、プログラムに渡された引数の数を表す。argcがゼロでなければ、引数はargv[0]から、argv[argc-1]まで、null終端されたマルチバイト文字列の先頭文字へのポインターを指す。argv[0]は、プログラムが実行された時のプログラムの名前か、あるいは""となる。argcの値が負数になることはない。argv[argc]の値は0となる。

#include <iostream>

int main( int argc, char ** argv )
{
    std::cout << "Number of arguments: " << argc << std::endl ;
    std::cout << "program name: " << argv[0] << std::endl ;

    // 残りの引数
    for ( std::size_t i = 1 ; argv[i] != nullptr ; ++i )
    {
        std::cout << argv[i] << std::endl ;
    }
}

main関数は、プログラム中で使われてはならない。「使う」というのは、呼び出すことはもちろん、アドレスやリファレンスを取ることも含まれる。

auto ptr = &main ; // エラー

mainのリンケージは実装依存である。mainをdelete定義したり、inline, static, constexprなどと宣言することはエラーとなる。

mainという名前は、これ以外には予約されていない。つまり、クラス名やenum名や、クラスのメンバーをmainと名付けることは問題ないし、グローバル名前空間以外の名前空間でmainという名前を使うことも問題はない。

例えば、以下のコードは完全に合法なコードである。

class main { } ;
namespace ns
{
    int main() { return 0 ; }
}

int main( ) { }

3つのmainという名前は、それぞれ別のエンティティを指す。

std::exitなどのような方法を使い、ブロックから抜け出さずにプログラムを終了させた場合、自動ストレージ上のオブジェクトは破棄されない。もし、std::exitがstaticやスレッドストレージ上のオブジェクトを破棄中に呼ばれたならば、プログラムの挙動は未定義である。

main関数の中のreturn文は、プログラムからの離脱の効果があり、自動ストレージ上のオブジェクトは破棄され、return文のオペランドの値が、std::exitへの実引数として渡される。もし、main関数の最後に到達しても、return文がない場合は、以下の文を実行したものと同等の効果になる。

return 0 ;

これはmain関数だけの特別な仕様である。

非ローカル変数の初期化（Initialization of non-local objects）

非ローカル変数には二種類ある。staticストレージ上の変数と、スレッドストレージ上の変数である。staticストレージ上の非ローカル関数は、プログラムの開始にともなって初期化される。スレッドストレージ上の非ローカル関数は、スレッドの実行にともなって初期化される。初期化は以下の手順で行われる。

staticストレージ上とスレッドストレージ上の変数は、他の初期化に先んじて、必ずゼロ初期化される。

変数に定数初期化子(constant initializer)がある場合、定数初期化(constant initialization)が行える場合は、行われる。定数初期化子とは、初期化子が定数式となる式の場合である。

ゼロ初期化と定数初期化をまとめて、静的初期化(static initialization)と呼ぶ。これ以外の初期化はすべて、動的初期化(dynamic initialization)である。静的初期化は、動的初期化の前に行われる。

staticストレージ上の非ローカル変数の動的初期化の順序があるものと、順序のないものがある。

明示的に特殊化されたクラステンプレートのstaticデータメンバーの初期化は、順序がある。暗黙、明示的に実体化された特殊化のstaticデータメンバーの初期化は、順序がない。

template < typename T >
struct S
{
    static int data ;
} ;

// 実行時関数
int init()
{
    static int count = 0 ;
    return count++ ;
}

// 動的初期化される
template < typename T >
int S<T>::data = init() ;

// 明示的実体化
extern template struct S< int > ;
extern template struct S< short > ;

// 明示的特殊化
template < >
int S<double>::data = init() ;
template < >
int S<float>::data = init() ;

int main( )
{
    S<long> s1 ;
    S<long long int> s2 ;
}

クラステンプレートSのshort, int, long, long long intに対する特殊化は、暗黙や明示的に実体化されているので、staticデータメンバーdataの初期化の順序はない。そのため、値がどうなるかは、規格上定めることができない。

一方、floatとdoubleについての特殊化は、明示的に特殊化されているので、順序があり、doubleの特殊化がfloatの特殊化より先んじることが保証されている。

この他のstaticストレージ上の非ローカル変数は順序がある。

順序がある変数は、ひとつの翻訳単位の中では、定義されている順番通りに初期化される。

int init()
{
    static int count = 0 ;
    return count++ ;
}

int x = init() ; // 0
int y = init() ; // 1
int z = init() ; // 2

この他、規格では、挙動が変わらない場合、実装は動的初期化を静的初期化にしてもよいであるとか、main関数に処理が移った時点で初期化が完了している必要はないなどということを規定している。これは実装の選択や最適化を許すためのもので、コードから見える挙動は変わらない。

終了（Termination）

main関数からreturnするか、std::exitを呼び出した場合、staticストレージ上の初期化されたオブジェクトのデストラクターが呼び出される。スレッドの初期関数からreturnするか、std::exitを呼び出した場合、スレッドストレージ上の初期化されたオブジェクトのデストラクターが呼び出される。

終了時のオブジェクトの破棄中に、すでに破棄されたオブジェクトを参照した場合、挙動は未定義である。

確保関数(allocation function)

確保関数は、クラスのメンバー関数か、グローバル関数でなければならない。グローバル名前空間以外の名前空間で確保関数を宣言したり、グローバル名前空間でstaticとして確保関数を宣言すると、プログラムはエラーとなる。

確保関数の戻り値の型はvoid *でなければならない。最初の仮引数は、std::size_t型で、デフォルト実引数があってはならない。最初の引数には、確保関数が確保すべきストレージのサイズが渡される。

確保関数はテンプレート宣言できるが、戻り値の型と最初の仮引数は、前述通りでなければならない。確保関数のテンプレートは、二つ以上の仮引数を持たねばならない。

確保関数は、要求されたサイズ以上のストレージを確保できたならば、そのストレージの先頭アドレスを返す。ストレージの中身の値については、未規定である。

確保関数の返すポインターは、どの基本アライメント要求も満たすアドレスでなければならない。

確保関数がストレージの確保に失敗した場合、登録されているnewハンドラーがあれば呼び出す。確保関数が無例外指定されている場合は、nullポインターを返す。そうでなければstd::bad_alloc型の例外がthrowされる。

解放関数(deallocation function)

解放関数はクラスのメンバー関数か、グローバル関数でなければならない。グローバル名前空間以外の名前空間で解放関数を宣言したり、グローバル名前空間でstaticとして解放関数を宣言すると、プログラムはエラーとなる。

解放関数の戻り値の型はvoid、最初の仮引数は、void *でなければならない。

C++14では、解放関数が2個の仮引数を持ち、第二引数がstd::size_t型である場合、2つ目の仮引数には、確保したストレージのサイズが渡される。

解放関数から例外を投げて抜けだした場合、挙動は未定義である。

解放関数の1つ目の実引数がnullポインターでなければ、解放関数はポインターの指し示すストレージの解放を行う。

安全なポインター(Safely-derived pointers)

C++11にはガベージコレクションはないが、将来ガベージコレクションを追加することを見越して、安全なポインター(safely-derived pointer)というものを定義している。

ガベージコレクションとは、動的ストレージの明示的な解放をしなくても良くなる言語機能である。

ガベージコレクションの実装方法としては、プログラム中のポインターの値を検証し、どこからも参照されていない動的ストレージを探しだす方法がある。もし、あるストレージを参照する方法がなければ、そのストレージはもはや使われていないのだから、解放しても問題がないということになる。

しかし、C++は、ポインターに対する低級な操作を提供している。厳密には未定義の挙動になるが、ポインターの値をreinterpret_castでそのまま整数型に型変換して、整数型として演算したりできる。このような、ポインターの内部表現を変更して、後から元の内部表現に戻すような処理と、プログラム中の全ポインターの値を検証して、どこからも参照されていないストレージを探しだすというガベージコレクションの機能は、相性が悪い。

そのため、C++11では、どういうポインターの操作は安全なのかということについて、色々と定義している。その詳細は、本書では解説しない。

サブオブジェクトの有効期間

サブオブジェクトのストレージの有効期間は、その完全なオブジェクトの有効期間に同じ。

基本型(Fundamental types)

文字(char)のオブジェクトは、基本文字セットをすべて表現できる大きさを持つ。基本文字セットの文字が文字オブジェクトに格納されている場合、文字オブジェクトの整数の値と、その文字の文字リテラルの値は、等しくなる。

char c = 'A' ;
c == 'A' ; // true

char型が負数を表現できるかどうかは、実装依存である。

char c = static_cast<char>(-1) ; // 実装依存

文字型は、明示的にunsignedかsignedで宣言できる。char, signed char, unsigned charは、それぞれ別の型として区別される。この3つの型を、ナロー文字型(狭い文字型、narrow character type)と呼ぶ。

ひとつのchar, signed char, unsigned char型のオブジェクトは同じ大きさのストレージを占め、アライメント要求も同じである。つまり、3つの型が同じオブジェクト表現を持つ。

ナロー文字型では、オブジェクト表現を構成するすべてのビット列が、値表現として使われる。符号なしなナロー文字型では、オブジェクト表現のすべてのビット列が、値表現の数値を表現するのに使われる。この点で、ナロー文字型は、他の型にはない独自の特徴を持つ。慣習的にナロー文字型は任意のバイト列を表現するのに使われている。

char型のオブジェクトの値は、signed charかunsigned charのどちらかの値と等しい。どちらと等しくなるのかは、実装に委ねられている。

char c = 'A' ;
signed char sc = 'A' ;
unsigned char uc = 'A' ;

この例では、規格準拠の実装では、cの値は、scかucのどちらかと必ず等しくなる。どちらと等しいのかは規定されていない。

標準符号つき整数型(standard signed integer type)には、5種類ある。

signed char
short int
int
long int
long long int

この並び順は、小さい順である。標準符号つき整数型は、少なくともこの順序における、前の型の値と同じかそれ以上の大きさのストレージを占める。

この他に、実装依存の拡張符号つき整数型(extended signed integer type)がある。これは、具体的には規格で定義されないが、実装が独自に提供する符号付きの整数型を指す。標準符号つき整数型と、拡張符号つき整数型をひっくるめて、符号つき整数型(signed integer type)と呼ぶ。

素のintは、実行環境のアーキテクチャにとって自然なサイズとなる。

それぞれの標準符号つき整数型に対応する、標準符号なし整数型(standard unsigned integer type)が存在する。

unsigned char
unsigned short int
unsigned int
unsigned long int
unsigned long long int

それぞれ、対応する標準符号つき整数型と、同じ大きさのストレージ、同じアライメント要求を持つ。つまり、符号つきの整数型と対応する符号なしの整数型は、それぞれおなじオブジェクト表現を持つ。

sizeof( int )   ==  sizeof( unsigned int ) ;    // true
alignof( int )  ==  alignof( unsigned int ) ;   // true

標準符号つき整数型と同じように、標準符号なし整数型にも、実装依存の拡張符号なし整数型(extended unsigned integer type)が存在する。これも、それぞれ対応する拡張符号つき整数型とおなじ大きさのストレージとアライメント要求を持つ。

標準符号なし整数型と拡張符号なし整数型をひっくるめて、符号なし整数型(unsigned integer type)と呼ぶ。

符号つき整数型と対応する符号なし整数の型の、値表現は同じである。

標準符号つき整数型と標準符号なし整数型をひっくるめて、標準整数型(standard integer type)と呼ぶ。拡張符号つき整数型と拡張符号なし整数型をひっくるめて、拡張整数型(extended integer type)と呼ぶ。

C++の整数型は、C言語の標準規格で定義されている要件と同じ要件を満たす。つまり、CとC++はこの点において互換性がある。

符号なし整数は、モジュロの2ⁿの法(laws of arithmetic modulo 2ⁿ)に従う。nは整数型の値表現のビット数である。これは、符号なし整数型は、絶対にオーバーフローしないことが規格上保証されていることを意味する。何故ならば、もしある符号なし整数型で表現できる値を超えたとしたならば、その結果は、表現できる最大値での剰余になるからだ。

例えば、規格準拠のC++実装では、以下のコードのnとmの値は、保証されている。

int main()
{
    // nの値は、unsigned intで表現できる最大値
    unsigned int max = std::numeric_limits<unsigned int>::max() ;

    unsigned int n = max + 1 ; // nの値は0
    unsigned int m = max + 2 ; // mの値は1
}

wchar_tは、内部型(underlying type)と呼ばれる、何らかの整数型と同じサイズ、符号、アライメント要求を持つ。この内部型は、実装に委ねられている。

wchar_t型のひとつのオブジェクトは、実装がサポートするロケールの文字セットの任意の一文字を表現できる。

wchar_tは、少なくとも、規格上はそうなっている。しかし、現実的には、そのような固定長の文字コードは、サポートするロケールと文字セットを大幅に限定しなければ、存在しない。たとえば、ある実装では、wchar_tは16bitのUTF-16の1単位を表現するようになっている。しかし、UTF-16の1単位は、Unicodeの文字セットの任意の一文字を表現できない。ある実装では32bitのUTF-32の1単位を表現するようになっているが、UTF-32も、1単位で任意の1文字を表せる文字のエンコード方式ではない。wchar_tの内部型が規格で規定されていないことにより、wchar_tの仕様は、移植性の問題を引き起こす。

char16_t型は内部型uint_least16_t型と、char32_t型は内部型uint_least32_t型と、それぞれ等しい大きさ、符号、アライメント要求を持つ。

bool型の取り得る値は、trueかfalseである。bool型には、signed, unsigned short, longといった変種は存在しない。

bool, char, char16_t, char32_t, wchar_t、符号付き整数型と符号なし整数型をひっくるめて、整数型(integral typeもしくはinteger type)と呼ぶ。

整数型の内部表現は、何らかの純粋な二進数であると規定されている。規格は、整数型の内部表現について実装依存を認めている。例えば、現実の例をだすと、2の補数だとか1の補数だとか、符号の表現方法だとか、エンディアンなど、整数をビット列で表現するには、様々な実装方法が考えられる。C++の規格は、その詳細を規定しない。

浮動小数点数型(floating point type)には、float, double, long doubleがある。doubleは少なくともfloatと同等以上の精度があり、long doubleはdoubleと同等以上の精度がある。

浮動小数点数型が値を表現する方法は、実装依存である。整数型と浮動小数点数型をひっくるめて、演算型(arithmetic type)と呼ぶ。

void型は、空の値を持つ。値を表現しない型のようなものだ。void型は常に不完全な型であり、完全にする方法はない。

void型は、関数が戻り値を返さない場合に、戻り値の型として使われる。

// 戻り値を返さない関数
void f() { }

あらゆる式は、明示的にvoid型か、CV修飾子つきのvoid型に型変換できる。

// int型の値0をvoid型の空の値に変換
static_cast<void>(0) ;

void型の式が使える場所は、以下の通り。

• 式文
• コンマ式のオペランド
• 条件演算子の2つ目と3つ目のオペランド
• typeidのオペランド
• noexcept
• decltype
• 戻り値の型がvoidの関数の本体のreturn文の中の式
• void型、CV修飾子つきのvoid型への型変換のオペランド

#include <typeinfo>

// 呼び出すとvoid型の式になる関数
void f() { }

void g()
{
    f() ; // 式文
    f() , f() ; // コンマ式のオペランド
    true ? f() : f() ; // 条件演算子
    typeid( f() ) ; // typeid
    noexcept( f() ) ; // noexcept演算子
    using type = decltype( f() ) ; // decltype
    return f() ; // return文
    static_cast<void>( f() ) ; // void型への型変換
}

std::nullptr_t型の値は、nullポインター定数である。nullポインター定数には、nullptrという特別なキーワードのリテラルがある。sizeof(std::nullptr_t)はsizeof(void*)と等しくなる。

たとえ、あるC++の実装で、これらの異なる型として認識される基本型の内部表現が同じだったとしても、型は異なるものと認識される。

複合型(Compound types)

複合型とは、ポインターや配列やポインターの配列のように、複数の型が組み合わさって成り立っている型のことである。

複合型は以下の通り。

• 配列
• 関数
• ポインター
• リファレンス
• クラス
• union
• enum
• 非staticなクラスのメンバーへのポインター

これらの複合型は、再帰的に適用できる。例えば、ある型へのポインター、ある型へのポインターへのポインター、ある型へのポインターへのポインターの配列、などといったように。構築された型のオブジェクトのバイト数が、std::size_tで表現可能な範囲を超える場合は、エラーとなる。

voidへのポインターと、オブジェクト型へのポインターをひっくるめて、オブジェクトポインター型(object pointer type)と呼ぶ。

ある型Tのオブジェクトへのポインターのことを、「T型へのポインター」という。C++の規格の文面で単に「ポインター」という場合、メンバーへのポインターは含まない。ただし、staticメンバーへのポインターは、メンバーへのポインターではなく、ポインターに含まれることに注意。

不完全な型へのポインターは使えるが、そのポインターを使ってできることは制限される。

オブジェクトポインター型の有効な値は、メモリー上のある1バイトへのアドレスを表現しているか、nullポインターである。たとえば、T型のオブジェクトが、アドレスAに配置されていて、アドレスAの値となるポインターがあった場合、そのポインターは、オブジェクトを指し示している（ポイントしている）と呼ばれる。

ポインター型の値の表現方法は実装依存である。レイアウト互換な型へのCV修飾されたポインターとCV修飾されていないポインターは、同じ値表現と同じアライメント要求を持つ。

CV修飾されているか、CV修飾されていない、void型へのポインターは、型の分からないオブジェクトを指し示すのに使うことができる。void型へのポインターは特別な扱いになっていて、どのようなオブジェクトポインターをも保持できると規定されている。cv void *型のオブジェクトは、cv char *と同じ値の表現とアライメント要求を持つ。

CV修飾子(CV-qualifiers)

複合型(Compound types)と基本型(Fundamental types)で説明されている型は、CV非修飾型(cv-unqualified type)である。CV非修飾な完全型、不完全型、voidには、三種類のCV修飾された型がある。const修飾された型、volatile修飾された型、const-volatile修飾された型だ。

• constオブジェクトとは、オブジェクトの型が、const Tとなるか、あるいはそのようなオブジェクトのサブオブジェクトである。
• volatileオブジェクトとは、オブジェクトの型が、volatile Tとなるか、あるいはそのようなオブジェクトのサブオブジェクトである。
• const volatileオブジェクトとは、オブジェクトの型が、const volatile Tとなるか、あるいはそのようなオブジェクトのサブオブジェクトである。

ある型のCV修飾された型と、CV非修飾の型は、異なる型である。ただし、同じ表現とアライメント要求を持つ。

CV修飾子には、半順序が存在する。これは、よりCV修飾されている型を比較して決定できる。

その順序は以下の通り。

CV非修飾    <   const
CV非修飾    <   volatile
CV非修飾    <   const volatile
const       <   const volatile
volatile    <   const volatile

lvalueとrvalue(Lvalues and rvalues)

lvalueとrvalueという用語は、C++の祖先であるC言語のそのまた祖先である、BCPLの頃から、慣習的に使われていた用語である。その本来の意味は、代入式の左右のオペランドに記述することができる値という意味であった。lvalueは代入式の左(left)に書くことができる値(value)であるからして、left valueであり、rvalueは右(right)に書けるのでright valueということだ。

int x ;
x = 0 ;

この例で、xは代入式の左辺に書けるのでlvalueであり、0は右辺に書けるのでrvalueである。

今日では、lvalueとrvalueは、その本来の意味を失い、全く別の意味で使われるようになっている。式の値を分類する用語として使われている。

C++11では、式は、glvalueとrvalueの二種類に分けることができる。これは更に細分化でき、値は三種類の値に分類することができる。lvalueとxvalueとprvalueである。glvalueはlvalueとxvalueに細分化できる。rvalueはprvalueとxvalueに細分化できる。

分類名の意味は、以下のとおりである。

lvalue

lvalueは、関数かオブジェクトである。

lvalueは、名前付きの変数が指し示すオブジェクトや、ポインターを経由して指し示すオブジェクトなどが該当する。

lvalueの名前の由来は、歴史的経緯でleft value(左辺値)であるが、C++では歴史的経緯の意味とは関係がない。

xvalue

xvalueは、オブジェクトである。xvalueのオブジェクトは大抵、その寿命が近いか、あるいは寿命に関心がないことを表現するために使われる。これにより、もしオブジェクトがxvalueであるならば、ムーブしても問題はないということを表現するために使われる。

xvalueは、一部の式の結果や、rvalueリファレンスへの明示的なキャストなどが該当する。

xvalueの名前の由来は、eXpiring value(消失値)である。これは、xvalueというのは寿命が近かったり、寿命に関心がなく、消失しても問題のない値であるという意味から名付けられた。

glvalue

glvalueは、lvalueとxvalueの総称である。

glvalueの名前の由来は、generalized lvalue(一般化lvalue)である。

rvalue

rvalueは、xvalueとprvalueの総称である。xvalueの他には、一時オブジェクトや、リテラルの値(123や3.14やtrueなど)や、特定のオブジェクトに関連付けられていない値などが該当する。

rvalueの名前の由来は、歴史的経緯で、right value(右辺値)であるが、C++では歴史的経緯の意味とは関係がない。

prvalue

prvalue(pure rvalue)は、rvalueのうちxvalueではないものである。これには、一時オブジェクトやリテラルの値や、特定のオブジェクトに関連付けられていない値などが該当する。例えば、関数呼び出しの戻り値で、型がリファレンスではないものもある。

C++03までは、リファレンスは、単に「リファレンス」と呼ばれていた。C++11でいうlvalueリファレンスを意味した。C++03のリファレンスには、rvalueは束縛できなかった。

int f() { return 0 ; }

int main()
{
    int & lvalue_ref = f() ; // エラー
}

ただし、constなlvalueリファレンスは、rvalueを束縛できるという例外的なルールがある。

int f() { return 0 ; }

int main()
{
    int const & lvalue_ref = f() ; // OK
}

C++にムーブの概念を持ち込むにあたって、rvalueを非constなリファレンスで束縛したいという需要が生まれた。そのため、従来のリファレンスを、lvalueリファレンスとし、新しくrvalueリファレンスを追加することになった。

int f() { return 0 ; }

int main()
{
    int && lvalue_ref = f() ; // OK
}

rvalueリファレンスは、rvalueのみを束縛できるリファレンスである。rvalueである以上、寿命がすぐに尽きるか、あるいは、プログラマーはそのオブジェクトの寿命に関心を持たないと明示的に意思表示したとみなすことができる。

そのため、rvalueリファレンスで束縛できたということは、その値の保持する所有権を横取りしても問題がないということになる。

class owner
{
private :
    int * ptr ;
public :
    owner( int value )
        : ptr( new int( value ) )
    { }

    // コピーコンストラクター
    owner( owner const & lref )
        : ptr( new int( *lref.ptr ) ) 
    { }

    // ムーブコンストラクター
    owner( owner && rref )
        : ptr ( rref.ptr )
    {
        rref.ptr = nullptr ;
    }

    ~owner( )
    {
        delete ptr ;
    }
} ;


owner f()
{
    return owner(123) ;
}

int main()
{
    owner o = f() ;
}

rvalueリファレンスの導入により、ストレージなどの確保、解放が必要なリソースや、あるいはファイルやスレッドなどのコピーという概念が存在しないリソースの所有権を、ムーブ(移動)することが可能になった。

このコピーと対をなすムーブという新しい概念は、ムーブセマンティクス(Move Semantics)と呼ばれるプログラミング技法として知られている。プログラミング技法は本書の範疇ではないので、詳しくは解説しない。

アライメント(Alignment)

オブジェクト型には、アライメント要求(alignment requirements)というものが存在する。これは、オブジェクトが構築されるストレージのアドレスに対する制約である。

アライメント(alignment)とは、メモリ上で連続したオブジェクトを構築するときのアドレスの値に対する、実装依存の整数値である。

アライメント指定子を使うことによって、より厳格なアライメントを要求することができる。詳細はアライメント指定子を参照。

// アライメント8を要求
alignas( 8 ) char[64] ;

alignof式を使うことによって、型のアライメント要求を得ることができる。詳細はalignof式を参照。

// int型のアライメント要求を取得
constexpr std::size_t align_of_int = alignof( int ) ;

以下の例は、連続したメモリ上に確保された二つのint型のオブジェクトの先頭アドレスを表示している。結果は実装により異なる。

#include <cstdio>
int main()
{
    int ai[2] ;
    std::printf(
        "a[0]: %p\n"
        "a[1]: %p",
        &ai[0], &ai[1] ) ; 
}

基本アライメント(fundamental alignment)とは、実装がどのような文脈でもサポートしているアライメントの最大値であり、その値は、alignof( std::max_align_t )に等しい。

以下の例は、基本アライメントの数値を出力するコードである。結果は実装により異なる。

#include <cstddef>
#include <iostream>

int main()
{
    std::cout << "fundamental alignment is "
              << alignof( std::max_align_t )
              << std::endl ;
}

ある型のアライメント要求は、その型が完全なオブジェクトとして使われるか、あるいはサブオブジェクトとして使われるかで、変わる可能性がある。

struct B { long double d ; } ;
struct D : virtual B { char c ; } ;

たとえば、上の例のDを、完全なオブジェクトとして使った場合、サブオブジェクトとしてBを含むので、long doubleのアライメント要求も考慮してアラインされる。しかし、もしDが、別のオブジェクトのサブオブジェクトであり、その別のオブジェクトが、Bをvirtual基本クラスとして持つ場合、

D2 : virtual B, D { char c ; } ;

ある実装では、Bのサブオブジェクトは別のオブジェクトのサブオブジェクトとなるかもしれず、DはBをサブオブジェクトとして持たないかもしれない。そのような場合、サブオブジェクトとしてのDのアライメント要求は、Bのアライメント要求に影響されないかも知れない。

これは実装による。alignofの結果は、オペランドの型が完全なオブジェクトとして使われた場合のアライメント要求を返す。

拡張アライメント(extended alignment)は、alignof( std::max_align_t )よりも大きいアライメントである。拡張アライメントがサポートされるかは実装依存である。また、サポートされたとしても、すべての文脈でサポートされないかもしれない。もし、ある文脈で拡張アライメントがサポートされない場合、実装はそのようなコードをエラーにしなければならない。

#include <cstddef>
void f()
{
    // この文脈でこの拡張アライメントがサポートされる場合、OK
    // サポートされない場合、エラー
    alignas( alignof( std::max_align_t ) * 2 ) char buf[64];
}

拡張アライメントを持つ型のことを、アライン超過型(over-aligned type)という。

// アライン超過型の例
struct
alignas( alignof( std::max_align_t ) * 2 )
S { } ;

// これもアライン超過型
struct S2
{
    S s ; 
} ;

アライメントは、std::size_t型の値で表現される。妥当なアライメントは、alignof式で返される基本型のアライメントと、実装依存のアライメントである。実装依存のアライメントはサポートされていない可能性もある。アライメントは、必ず、負数ではない2の乗数でなければならない。1, 2, 4, 8, 16のような数値は、実装がサポートしていれば、妥当なアライメントである。3, 5, 6, 7, 9のような数値は、妥当なアライメントではない。

アライメントには、順序がある。この順序は、低い方は「より弱い」(weaker)アライメントといい、高い方は「より強い」(stronger)アライメントとか、「より厳格」(stricter)なアライメントという。より厳格なアライメントは、アライメントの数値としての値が高い。あるアライメント要求を満たすアドレスは、そのアライメント要求より弱いアライメント要求も満たす。

完全型のアライメント要求は、alignof式のオペランドに型を与えることで取得できる。

狭い文字型(char, signed char, unsigned char)は、もっとも弱いアライメント要求を持つ。これにより、狭い文字型を、アラインされたメモリ領域のための内部型として使うことができる。

#include <new>

struct S
{
    int i ;
    double d ;
} ;

void f()
{
    // Sを構築するメモリ領域
    alignas(S) char buf [ sizeof(S) ] ;

    // placement newでSを構築
    S * ptr = new( buf ) S ;

    // 疑似デストラクター呼び出し
    ptr->~S() ;
}

アライメントは比較することができ、その結果は常識的なものである。

• 二つのアライメントの数値が等しい場合、アライメントは等しい
• 二つのアライメントの数値が異なる場合、アライメントは等しくない
• 二つのアライメントのうち、数値の大きいほうが、より厳格なアライメントである

標準ライブラリには、バッファー上で指定されたアライメント要求を満たすアドレスのポインターを返すとか、指定したアライメント要求を満たすアドレスのストレージを確保するライブラリがある。標準ライブラリは本書の範疇ではないので解説しない。

もしある実装で、拡張アライメントがその文脈でサポートされない場合、プログラムはエラーとなる。アライメント要求を指定して動的ストレージを確保する標準ライブラリは、指定されたアライメントに従えない場合、その挙動は確保失敗になる。

:: 演算子

:: 演算子は、ある名前のスコープを指定する演算子である。このため、非公式に「スコープ解決演算子」とも呼ばれている。しかし、公式の名前は、:: 演算子(operator ::)である。::に続く名前のスコープは、::の前に指定されたスコープになる。

// スコープはグローバル
int x = 0;

// スコープはNS名前空間
namespace NS { int x = 0; }

// スコープはCクラス
struct C { static int x ; } ;
int C::x = 0 ;


int main()
{ // スコープはmain()関数のブロック
    int x = 0 ;

    x ; // ブロック

    ::x ; // グローバル
    NS::x ; // NS名前空間
    C::x ; // クラス
}

このように、::に続く名前のスコープを指定することができる。スコープが省略された場合は、グローバルスコープになる。

式の結果は、::に続く名前が、関数か変数の場合はlvalueに、それ以外はprvalueになる。

括弧式（parenthesized expression）

括弧式とは、括弧である。これは、式を囲むことができる。括弧式の結果は、括弧の中の式とまったく同じになる。これは主に、ひとつの式の中で、評価する順序を指定するような場合に用いられる。あるいは、単にコードを分かりやすく、強調するために使っても構わない。

(0) ; // 括弧式

// 1 + (2 * 3) = 1 + 6 = 7
1 + 2 * 3 ;
// 3 * 3 = 9
(1 + 2 ) * 3

ほとんどの場合、括弧式の有無は、括弧の中の式の結果に影響を与えない。ただし、括弧式の有無によって意味が変わる場合もある。例えば、decltype指定子だ。

ラムダ式の基本的な使い方

ラムダ式を、通常の関数のように使う方法を説明する。まず、ラムダ式の構造は、以下のようになっている。

[ /*ラムダキャプチャー*/ ] // ラムダ導入子
( /*仮引数リスト*/ ) // 省略可能
-> void // 戻り値の型、省略可能
{} // 複合文

これを、通常の関数定義と比較してみる。

auto // 関数宣言
func // 関数名
() // 引数リスト
-> void // 戻り値の型
{} // 関数の定義

ラムダ式は、関数オブジェクトである。通常の関数のように、引数もあれば、戻り値もある。もちろん、通常の関数のように、何も引数に取らないこともできるし、戻り値を返さないこともできる。

// 通常の関数
auto f() -> void {}
// ラムダ式
[]() -> void {} ;

ラムダ式を評価した結果は、prvalueの一時オブジェクトになる。この一時オブジェクトを、クロージャーオブジェクト（closure object）と呼ぶ。クロージャーオブジェクトの型は、クロージャー型（closure type）である。クロージャー型はユニークで、名前がない。これは実装依存の型であり、ユーザーは具体的な型を知ることができない。このクロージャーオブジェクトは、関数オブジェクトと同じように振舞う。

auto f = []() ->void {} ;

ラムダ式は関数オブジェクトなので、通常の関数と同じように、operator ()を適用することで呼び出すことができる。

// 通常の関数
auto f() -> void {}

int main()
{
    f() ; // 関数の呼び出し

    // ラムダ式
    auto g = []() -> void {} ;
    g() ; // ラムダ式の呼び出し

    // ラムダ式を直接呼び出す
    []() -> void {}() ;
}

仮引数リストと、戻り値の型は、省略できる。従って、最小のラムダ式は、以下の通りになる。

[]{}

仮引数リストを省略した場合は、引数を取らないということを意味する。戻り値の型を省略した場合は、ラムダ式の複合文の内容によって、戻り値の型が推測される。複合文が以下の形になっている場合、

{ return 式 ; }

戻り値の型は、式に lvalueからrvalueへの型変換、 配列からポインターへの型変換、関数からポインターへの型変換を適用した結果の型になる。

それ以外の場合は、void型になる。

注意しなければならないことは、戻り値の型を推測させるためには、複合文は必ず、{ return 式 ; }の形でなければならない。つまり、return文ひとつでなければならないということだ。return文以外に、複数の文がある場合、戻り値の型はvoidである。

// エラー、戻り値の型はvoidだが、値を返している
[]
{
    int x = 0 ;
    return x ;
}() ;


// OK、戻り値の型を、明示的に指定している。
[] -> int
{
    int x = 0 ;
    return x ;
}() ;

いくつか例を挙げる。

// 戻り値の型はint
auto type1 = []{ return 0 ; }() ;

// 戻り値の型はdouble
auto type2 = []{ return 0.0 ; }() ;

// 戻り値の型はvoid
[]{ }() ;
[]
{
    int x = 0 ;
    x = 1 ;
}() ;

ラムダ式の引数は、通常の関数と同じように記述できる。

int main()
{
    auto f = []( int a, float b ) { return a ; }
    f( 123, 3.14f ) ;
}

複合文は、通常の関数の本体と同じように扱われる。

int main()
{
    // 通常の関数と同じように文を書ける
    auto f =
        [] { 
            int x = 0 ;
            ++x ;
        };
    f() ;

    auto g = []
    { // もちろん、複数の文を書ける
        int x = 0 ;
        ++x ; ++x ; ++x ;
    } ;

    g() ;
}

クロージャーオブジェクトは、変数として保持できる。

#include <functional>

int main()
{
    // auto指定子を使う方法 
    auto f = []{} ;
    f() ;

    // std::functionを使う方法
    std::function< void (void) > g = []{} ;
    g() ;
}

ラムダ式は、テンプレート引数にも渡せる。

template < typename Func >
void f( Func func )
{
    func() ; // 関数オブジェクトを呼び出す
}

int main()
{
    f( []{ std::cout << "hello" << std::endl ; } ) ;
}

ラムダ式の使い方の例を示す。例えば、std::vectorの全要素を、標準出力に出力したいとする。

#include <iostream>
#include <vector>

struct Print
{
    void operator () ( int value ) const
    { std::cout << value << std::endl ; }
} ;

int main()
{
    std::vector<int> v = { 1, 2, 3, 4, 5 } ;
    std::for_each( v.begin(), v.end(), Print() ) ;  
}

この例では、本質的にはたった一行のコードを書くのに、わざわざ関数オブジェクトを、どこか別の場所に定義しなければならない。ラムダ式を使えば、その場に書くことができる。

#include <vector>
#include <algorithm>

int main()
{
    std::vector<int> v = { 1, 2, 3, 4, 5 } ;
    std::for_each( v.begin(), v.end(),
        [](int value){ std::cout << value << std::endl ; } ) ;  
}

#include <iostream>

template < typename Func >
void call( Func func )
{
    func() ; // helloと表示する
}

int main()
{
    std::string str = "hello" ;
    // main関数のローカル変数strを、ラムダ式の中で使う
    auto f = [=]{ std::cout << str << std::endl ; } ;
    f() ;
    // もちろん、他の関数に渡せる。
    call( f ) ;
}

int main()
{
    int x = 0 ;

    // コピーキャプチャー
    [=] { x ; }
    // リファレンスキャプチャー
    [&] { x ; }
}

int main()
{
    int x = 0 ;

    [=]
    { // コピーキャプチャー
        int y = x ; // OK、読むことはできる
        x = 0 ; // エラー、書き換えることはできない
    } ;

    [&]
    { // リファレンスキャプチャー
        int y = x ; // OK
        x = 0 ; // OK
    } ;
}

int main()
{
    int x = 0 ;

    [=]() mutable
    {
        int y = x ; // OK
        x = 0 ; // OK
    } ;
}

#include <functional>

int main()
{
    std::function< void ( void ) > f ;
    std::function< void ( void ) > g ;


    {
        int x = 0 ;
        f = [&]{ x ; } ; // リファレンスキャプチャー
        g = [=]{ x ; } ; // コピーキャプチャー
    }

    f() ; // エラー、xの寿命は、すでに尽きている。

    g() ; // OK
}

int main()
{ // 関数の最も外側のブロックスコープ
    int x ;
    {
        int y ;

        // xもyもキャプチャーできる。
        [=]{ x ; y ; } ;
    }
}

// グローバルスコープの変数
int x = 0 ;

int main()
{
    // キャプチャーする必要はない
    []{ x ; } ;
}

int main()
{
    int a = 0 ;
    int b = 0 ;

    [ a, &b ]{} ;
}

int main()
{
    int a = 0 ; int b = 0 ; int c = 0 ; int d = 0 ; 

    // デフォルトはコピーキャプチャー
    [=]{ a ; b ; c ; d ; } ;
    // デフォルトはリファレンスキャプチャー
    [&]{ a ; b ; c ; d ; } ;

    // aのみリファレンスキャプチャー
    [=, &a]{} ;

    // aのみコピーキャプチャー
    [&, a]{} ;

    // a, bのみリファレンスキャプチャー
    [=, &a, &b]{} ;

    // デフォルトキャプチャーを使わない
    [a]{} ;
}

int main()
{
    int a = 0 ; int b = 0 ;

    // エラー、デフォルトキャプチャーと同じ
    [=, a]{} ;
    // OK
    [=, &a]{} ;

    // エラー、デフォルトキャプチャーと同じ
    [&, &a]{} ;
    // OK
    [&, a]{} ;
}

int main()
{
    int x = 0 ;
    // エラー
    [x, x]{} ;
}

struct Sum
{
    int sum ;
    Sum() : sum(0) { }
    void operator ()( int value ) { sum += value ; }
} ;

int main()
{
    std::vector<int> v = {1,2,3,4,5} ;
    Sum sum = std::for_each( v.begin(), v.end(), Sum() ) ;

    std::cout << sum.sum << std::endl ;
}

int main()
{
    std::vector<int> v = {1,2,3,4,5} ;
    int sum = 0 ;
    for ( auto iter = v.begin() ; iter != v.end() ; ++iter )
    {
        sum += *iter ;
    }

    std::cout << sum << std::endl ;
}

int main()
{
    std::vector<int> v = {1,2,3,4,5} ;
    int sum = 0 ;
    std::for_each( v.begin(), v.end(),
        [&]( int value ){ sum += value ; }
    ) ;

    std::cout << sum << std::endl ;
}

ラムダ式の詳細

using type = decltype([]{}) ; // エラー
sizeof([]{}) ; // エラー

// OK
auto f = []{} ;

int main()
{
    int a = 0 ; int b = 0 ;
    auto f = [a, &b](){ a ; b ; } ;
    f() ;
}

class Closure // 本来、ユーザー側から使える名前は存在しない
{
private :
    // aはコピーキャプチャー、bはリファレンスキャプチャー
    int a ; int & b ;
public :    
    Closure(int & a, int & b )
        : a(a), b(b) { }

    // コピーコンストラクターが暗黙的に定義される
    Closure( Closure const & ) = default ;
    // ムーブコンストラクターが暗黙的に定義される可能性がある
    Closure( Closure && ) = default ;

    // デフォルトコンストラクターはdelete定義される
    Closure() = delete ;
    // コピー代入演算子はdelete定義される
    Closure & operator = ( Closure const & ) = delete ;
    
    

    inline void operator () ( void ) const
    { a ; b ; }
} ;

int main()
{
    int a = 0 ; int b = 0 ;
    auto f = Closure(a, b) ;
    f() ;
}

int main()
{
    int x = 0 ;
    // エラー
    [x]() { x = 0 ; } ;
    // OK
    [x]() mutable { x = 0 ; } ;
}

ラムダ式の仮引数リストには、デフォルト引数を指定できない。

// エラー
[](int x = 0){} ;

ラムダ式は、例外指定できる。

[]() noexcept {} ;

ラムダ式に例外指定をすると、クロージャーオブジェクトのoperator ()に、同じ例外指定がなされたものと解釈される。

クロージャーオブジェクトには、コピーコンストラクターが暗黙的に定義される。ムーブコンストラクターは、可能な場合、暗黙的に定義される。デフォルトコンストラクターと、コピー代入演算子は、delete定義される。これはつまり、初期化はできるが、コピー代入はできないということを意味する。

// 初期化はできる。
auto f = []{} ;

// OK fはラムダ式ではないので可能
using closure_type decltype(f) ;
// OK 初期化はできる
closure_type g = f ;

// エラー、デフォルトコンストラクターは存在しない
closure_type h ;
// エラー、コピー代入演算子は存在しない。
h = f ;

関数ポインターへの変換

ラムダキャプチャーを使わないラムダ式のクロージャーオブジェクトは、同一の引数と戻り値の関数ポインターへの変換関数を持つ。

void (*ptr1)(void) = []{} ;
auto (*ptr2)(int, int, int) -> int = [](int a, int b, int c) -> int { return a + b + c ; };

// 呼び出す。
ptr1() ; ptr2(1, 2, 3) ;

ラムダキャプチャーを使っているクロージャーオブジェクトは、関数ポインターに変換できない。

int main()
{
    int x = 0 ; 
    // エラー、変換できない
    auto (*ptr1)(void) -> int = [=] -> int{ return x ; } ;
    auto (*ptr2)(void) -> int = [&] -> int{ return x ; } ;
}

変数をキャプチャーしないラムダ式というのは、関数オブジェクトではなく、単なる関数に置き換えることができるので、このような機能が提供されている。この機能は、まだテンプレートを使っていない既存のコードやライブラリとの相互利用のために用意されている。

ラムダ式のネスト

ラムダ式はネストできる。

[]{ // 外側のラムダ式
    []{} ; // 内側のラムダ式
} ;

この時、問題になるのは、変数のキャプチャーだ。内側のラムダ式は、外側のラムダ式のブロックスコープから見える変数しか、キャプチャーすることはできない。

int main()
{
    int a = 0 ; int b = 0 ;
    [b]{ // 外側のラムダ式
        int c = 0 ;
        [=]{ // 内側のラムダ式
            a ; // エラー、aはキャプチャーできない。
            b ; // OK
            c ; // OK
        } ;
    } ;
}

外側のラムダ式が、デフォルトキャプチャーによって、暗黙的に変数をキャプチャーしている場合は、内側のラムダも、その変数をキャプチャーできる。

int main()
{
    int a = 0 ;
    [=]{ // 外側のラムダ式
        [=]{ // 内側のラムダ式
            a ; // OK
        } ;
    } ;
}

thisのキャプチャー

基本的にラムダ式は、そのラムダ式が使われているブロックスコープのローカル変数しかキャプチャーできない。しかし、実は、データメンバーを使うことができる。

struct C
{
    int x ;
    void f()
    {
        [=]{ x ; } ; // OK、ただし、これはキャプチャーではないことに注意
    }
} ;

このように、非staticなメンバー関数のラムダ式では、データメンバーを使うことができる。しかし、これは、データメンバーをキャプチャーしているわけではない。その証拠に、データメンバーを直接キャプチャーしようとすると、エラーになる。

struct C
{
    int x ;
    void f()
    {
        [x]{} ; // エラー、データメンバーはキャプチャーできない
    }
} ;

では、どうしてデータメンバーが使えるのか。一体何をキャプチャーしているのか。実は、これはthisをキャプチャーしているのである。ラムダ式は、thisをキャプチャーできる。

struct C
{
    int x ;
    void f()
    {
        [this]{ this->x ; } ;
    }
} ;

ラムダ式の関数の本体では、thisは、クロージャーオブジェクトへのポインターではなく、ラムダ式が使われている非staticなメンバー関数のthisをキャプチャーしたものと解釈される。thisは、必ずコピーキャプチャーされる。というのも、そもそもthisはポインターなので、リファレンスキャプチャーしても、あまり意味はない。

struct C
{
    int x ;
    void f()
    {
        [this]{} ; // OK
        [&this]{} ; // エラー、thisはリファレンスキャプチャーできない
    }
} ;

ラムダ式にデフォルトキャプチャーが指定されていて、データメンバーが使われている場合、thisは暗黙的にキャプチャーされる。デフォルトキャプチャーがコピーでもリファレンスでも、thisは必ずコピーキャプチャーされる。

struct C
{
    int x ;
    void f()
    {
        [=]{ x ; } ; // thisをコピーキャプチャーする
        [&]{ x ; } ; // thisをコピーキャプチャーする
    }
} ;

thisのキャプチャーは、注意を要する。すでに述べたように、データメンバーは、キャプチャーできない。ラムダ式でデータメンバーを使うということは、thisをキャプチャーするということである。データメンバーは、thisを通して使われる。これは、データメンバーは参照で使われるということを意味する。ということは、もし、クロージャーオブジェクトのoperator ()が呼ばれた際に、thisを指し示すオブジェクトが無効になっていた場合、エラーとなってしまう。

struct C
{
    int x ;
    std::function< int (void) > f()
    {
        return [this]{ return x ; } ;
    }
} ;

int main()
{
    std::function< int (void) > f ;
    {
        C c ;
        f = c.f() ;
    }// cの寿命はすでに終わっている

    f() ; // エラー
}

データメンバーをコピーキャプチャーする方法はない。そもそも、何度も述べているように、データメンバーはキャプチャーできない。では、上の例で、どうしてもデータメンバーの値を使いたい場合はどうすればいいのか。この場合、一度ローカル変数にコピーするという方法がある。

struct C
{
    int x ;
    std::function< int (void) > f()
    {
        int x = this->x ;
        return [x]{ return x ; } ; // xはローカル変数のコピー
    }
} ;

もちろん、同じ名前にするのが紛らわしければ、名前を変えてもいい。

ラムダ式でデータメンバーを使う際には、キャプチャーしているのは、実はthisなのだということに注意しなければならない。

パラメーターパックのキャプチャー

可変引数テンプレートの関数パラメーターパックも、キャプチャーリストに書くことができる。その場合、通常と同じように、パック展開になる。

template < typename ... Types > void g( Types ... args ) ;

template < typename ... Types >
void f( Types ... args )
{
    // 明示的なキャプチャー
    [args...]{ g( args... ) ; } ;
    [&args...]{ g( args... ) ; } ;

    // 暗黙的なキャプチャー
    [=]{ g( args... ) ; } ;
    [&]{ g( args... ) ; } ;   
}

添字（Subscripting）

式 [ 式 ]
式 [ 初期化リスト ]

operator []は、添字と呼ばれる式である。これは、配列の要素にアクセスするために用いられる。どちらか片方の式は、Tへのポインター型でなければならず、もう片方は、unscoped enumか、整数型でなければならない。式の結果は、lvalueのTとなる。式、E1[E2] は、*((E1)+(E2)) と書くのに等しい。

int x[3] ;
// *(x + 1)と同じ
x[1] ;

この場合、xには、配列からポインターへの型変換が適用されている。

「どちらか片方の式」というのは、文字通り、どちらか片方である。たとえば、x[1]とすべきところを、1[x]としても、同じ意味になる。

int x[3] ;
// どちらも同じ意味。
x[1] ;
1[x] ;

もっとも、通常は、一つめの式をポインター型にして、二つ目の式を整数型にする。ユーザー定義のoperator []では、このようなことはできない。

ユーザー定義のoperator []の場合、[]の中の式に、初期化リストを渡すことができる。これは、どのように使ってもいいいが、例えば以下のように使える。

struct C
{
    int data[10][10][10] ;
    int & operator []( std::initializer_list<std::size_t> list )
    {
        if ( list.size() != 3 ) { /* エラー処理 */ }

        auto iter = list.begin() ;
        std::size_t const i = *iter ; ++iter ;
        std::size_t const j = *iter ; ++iter ;
        std::size_t const k = *iter ;
        
        return data[i][j][k] ;
    }
} ;

int main()
{
    C c ;
    c[{1, 2, 3}] = 0 ;
}

初期化リストを使えば、オーバーロードされたoperator []に、複数の引数を渡すことができる。

関数呼び出し（Function call）

関数呼び出し（function call）の文法は、以下の通り。

式 ( 引数のリスト )

関数呼び出しには、通常の関数呼び出しと、メンバー関数呼び出しがある。

通常の関数を呼び出す場合、式には、関数へのlvalueか、関数へのポインターが使える。

void f( void ) { } 
void g( int ) { } 
void h( int, int, int ) { } 

int main()
{
    // 「関数へのlvalue」への関数呼び出し
    f( ) ;
    g( 0 ) ;
    h( 0, 0, 0 ) ;

    // 関数への参照
    void (&ref)(void) = f ;

    // 「関数へのlvalue」への関数呼び出し
    ref() ;

    // 関数ポインター
    void (*ptr)(void) = &f ;

    // 関数ポインターへの関数呼び出し
    ptr() ;
}

staticなメンバー関数は、通常の関数呼び出しになる。

struct C { static void f(void) {} } ;

int main()
{
    void (*ptr)(void) = &C::f ;
    ptr() ; // 通常の関数呼び出し
}

メンバー関数を呼び出す場合、式には、関数のメンバーの名前か、メンバー関数へのポインター式が使える。

struct C
{
    void f(void) {}

    void g(void)
    {
        // メンバー関数の呼び出し
        f() ;
        this->f() ; 
        (*this).f() ;

        // メンバー関数へのポインター
        void (C::* ptr)(void) = &C::f ;
        // 関数呼び出し
        (this->*ptr)() ;
    }
} ;

関数呼び出し式の結果の型は、式で呼び出した関数の戻り値の型になる。

void f() ;
int g() ;

// 式の結果の型はvoid
f() ;
// 式の結果の型はint
g() ;

関数呼び出しの結果の型は、戻り値の型になる。これはtypeidやsizeofやdecltypeのオペランドの中でも、同様である。

// 関数fの戻り値の型はint
// すなわち、fを関数呼び出しした結果の型はint
int f() { return 0 ; }

int main()
{
    // sizeof(int)と同じ
    sizeof( f() ) ;
    // typeid(int)と同じ
    typeid( f() ) ;
    // int型の変数xの宣言と定義。
    decltype( f() ) x ;
}

関数が呼ばれた際、仮引数は対応する実引数で初期化される。非staticメンバー関数の場合、this仮引数もメンバー関数を呼び出した際のオブジェクトへのポインターで初期化される。

仮引数に対して、具体的な一時オブジェクトが生成されるかどうかは、実装依存である。たとえば、実装は最適化のために、一時オブジェクトの生成を省略するかもしれない。

仮引数が参照の場合をのぞいて、呼ばれた関数の中で仮引数を変更しても、実引数は変更されない。ただし、型がポインターの場合、参照を通して参照先のオブジェクトが変更される可能性がある。

void f( int x, int & ref, int * ptr )
{
    x = 1 ; // 実引数は変更されない
    ref = 1 ; // 実引数が変更される
    *ptr = 1 ; // 実引数は、ポインターの参照を通して変更される
    ptr = nullptr ; // 実引数のポインターは変更されない
}

int main()
{
    int x = 0 ; // 実引数
    int * ptr = &x ;
    f( x, x, ptr ) ;
}

実引数の式が、どのような順番で評価されるかは決められていない。ただし、呼び出された関数の本体に入る際には、式はすべて評価されている。

#include <iostream>
 
int f1(){ std::cout << "f1" << std::endl ; return 0 ; }
int f2(){ std::cout << "f2" << std::endl ; return 0 ; }
int f3(){ std::cout << "f3" << std::endl ; return 0 ; }

void g( int, int, int ){ }

int main( )
{
    g( f1(), f2(), f3() ) ; // f1, f2, f3関数呼び出しの順番は分からない
}

この例では、関数f1, f2, f3がどの順番で呼ばれるのかが分からない。したがって、標準出力にどのような順番で文字列が出力されるかも分からない。ただし、関数gの本体に入る際には、f1, f2, f3は、すべて呼び出されている。

関数は、自分自身を呼び出すことができる。これを再帰呼び出しという。

void f()
{
    f() ; // 自分自身を呼び出す、無限ループ
}

ただし、main関数だけは特別で、再帰呼び出しをすることができない。

int main()
{
    main() ; // エラー
}

関数形式の明示的型変換（Explicit type conversion (functional notation)）

型名 ( 式リスト )
型名 初期化リスト

関数形式の明示的型変換（Explicit type conversion (functional notation)）とは、関数呼び出しのような文法による、一種のキャストである。

struct S
{
    S( int ) { }
    S( int, int ) { }
} ;

int main()
{
    int() ;
    int{} ;

    S( 0 ) ;
    S( 1, 2 ) ;
}

型名として使えるのは、単純型指定子か、typename指定子である。単純型指定子でなければならないということには、注意しなければならない。たとえば、ポインターやリファレンス、配列などを直接書くことはできない。ただし、typedef名は使える。

int x = 0 ;
// これらはエラー
int *(&x) ;
int &(x) ;

// typedef名は使える
using type = int * ;
type(&x) ;

単純型指定子の中でも、autoとdecltypeは、注意が必要である。まず、autoは使えない。

auto(0) ; // エラー

decltypeは使える。ただし、非常に使いづらいので、使うべきではない。

// int型をint型にキャスト
// int(0) と同じ
decltype(0)(0) ;

たとえば、以下のコードはエラーである。

int x ;
decltype(x)(x) ; // エラー

これは、文法が曖昧だからだ。詳しくは、曖昧解決を参照。何が起こっているかというと、decltype(x)(x)は、キャストではなく、変数の宣言だとみなされている。decltype(x)は、intという型である。

// decltype(x)(x) と同じ
// decltype(x)(x) → int (x) → int x
int x ;

このため、decltypeを関数形式のキャストで使うのは、問題が多い。使うならば、typedef名をつけてから使うか、static_castを使うべきである。

int x ;
using type = decltype(x) ;
type(x) ;

static_cast< decltype(x) >(x) ;

typename指定子も使うことができる。

template < typename T >
void f()
{
    typename T::type() ; // OK
}

式リストが、たったひとつの式である場合、キャストと同じ意味になる。

// int型からshort型へのキャスト
short(0) ;
// int型からdouble型へのキャスト
double(0) ;

struct C { C(int) {} } ;
// 変換関数による、int型からC型へのキャスト
C(0) ; 

型名がクラス名である場合、T(x1, x2, x3)という形の式は、T t(x1, x2, x3)という形と同じ意味を持つ一時オブジェクトを生成し、その一時オブジェクトを、prvalueの結果として返す。型名がクラス名でも、式リストがひとつしかない場合は、キャストである。もっとも、その場合も、ユーザー定義のコンストラクターが、変換関数として呼び出されることになるので、意味はあまり変わらない。

struct C
{
    C(int) {}
    C(int, int) {}
    C(int, int, int) {}
} ;

int main()
{
    C(0) ; // これはキャスト、意味としては、あまり違いはない
    C(1, 2) ; 
    C(1, 2, 3) ;
}

式リストが空の場合、つまり、T()という形の式の場合。まず、Tは配列型であってはならない。Tは完全な型か、voidでなければならない。式の結果は、値初期化された型のprvalueの値になる。値初期化については、初期化子を参照。

int() ; // int型の0で初期化された値
double() ; // double型の0で初期化された値

struct C {} ;
C() ; // デフォルトコンストラクターが呼ばれたCの値

void型の場合、値初期化はされない。式の結果の型はvoidである。

void() ; // 結果はvoid

括弧で囲まれた式リストではなく、初期化リストの場合、式の結果は、指定された型の、初期化リストによって直接リスト初期化されたprvalueの一時オブジェクトになる。

#include <initializer_list>

struct C
{
    C( std::initializer_list<int> ) { }
} ;

int main()
{
    C{1,2,3} ;
}

疑似デストラクター呼び出し（Pseudo destructor call）

疑似デストラクター呼び出しとは、デストラクターを明示的に呼び出すことができる一連の式である。使い方は、operator .、operator ->に続けて、疑似デストラクター名を書き、さらに関数呼び出しのoperator ()を書く。この一連の式を、疑似デストラクター呼び出しという。このような疑似デストラクター名に続けては、関数呼び出し式しか適用することができない。式の結果はvoidになる。

// このコードは、疑似デストラクター呼び出しの文法を示すためだけの例である
struct C {} ;

int main()
{
    C c ;
    c.~C() ; // 疑似デストラクター呼び出し
    C * ptr = &c
    ptr->~C() ; // 疑似デストラクター呼び出し
}

注意すべきことは、デストラクターを明示的に呼び出したとしても、暗黙的に呼び出されるデストラクターは、依然として呼び出されるということである。

#include <iostream>

struct C
{
    ~C() { std::cout << "destructed." << std::endl ; }
} ;

int main()
{
    {
        C c ;
        c.~C() ; // デストラクターを呼び出す
    }// ブロックスコープの終りでも、デストラクターは暗黙的に呼ばれる

    C * ptr = new C ;
    ptr->~C() ; // デストラクターを呼び出す

    delete ptr ; // デストラクターが暗黙的に呼ばれる。
}

このように、通常は、デストラクターの呼び出しが重複してしまう。二重にデストラクターを呼び出すのは、大抵の場合、プログラム上のエラーである。では、疑似デストラクター呼び出しは何のためにあるのか。具体的な用途としては、placement newと組み合わせて使うということがある。

struct C { } ;

int main()
{
    // placement new用のストレージを確保
    void * storage = operator new( sizeof(C) ) ;
    // placement new
    C * ptr =  new(storage) C ;
    // デストラクターを呼び出す
    ptr->~C() ;
    // placement new用のストレージを解放
    operator delete( storage ) ;
}

この疑似デストラクターには、decltypeを使うことができる。

struct C {} ;

int main()
{
    C c ;
    c.~decltype(c) ; 
    C * ptr = &c
    ptr->~decltype(c) ;
}

テンプレート引数の場合、型がスカラー型であっても、疑似デストラクター呼び出しができる。

template < typename T >
void f()
{
    T t ;
    t.~T() ;
}

int main()
{
    f<int>() ;
}

これにより、ジェネリックなテンプレートコードが書きやすくなる。

クラスメンバーアクセス（Class member access）

クラスのオブジェクト . メンバー名
クラスのポインター -> メンバー名

クラスメンバーアクセスは、名前の通り、クラスのオブジェクトか、クラスのオブジェクトへのポインターのメンバーにアクセスするための演算子である。

. 演算子の左側の式は、クラスのオブジェクトでなければならない。-> 演算子の左側の式は、クラスのオブジェクトへのポインターでなければならない。演算子の右側は、そのクラスか、基本クラスのメンバー名でなければならない。-> 演算子を使った式、E1->E2は、(*(E1)).E2という式とおなじになる。

struct Object
{
    int x ;
    static int y ;
    void f() {}
} ;

int Object::y ;

int main()
{
    Object obj ;
    // . 演算子
    obj.x = 0 ;
    obj.y = 0 ;
    obj.f() ;

    Object * ptr = &obj ;
    // -> 演算子
    ptr->x = 0 ;
    ptr->y = 0 ;
    ptr->f() ;
}

もし、クラスのオブジェクト、クラスのオブジェクトへのポインターを表す式が依存式であり、メンバー名がメンバーテンプレートであり、テンプレート引数を明示的に指定したい場合、メンバー名の前に、templateキーワードを使わなければならない。

struct Object
{
    template < typename T >
    void f() {}
} ;

template < typename T >
void f()
{
    T obj ;
    obj.f<int>() ; // エラー
    obj.template f<int>() ; // OK
}

int main()
{
    f<Object>() ;
}

これは、<演算子や、>演算子と、文法が曖昧になるためである。この問題については、テンプレート特殊化の名前でも、解説している。

派生によって、クラスのメンバー名が曖昧な場合、エラーになる。

struct Base1 { int x ; } ;
struct Base2 { int x ; } ;

struct Derived : Base1, Base2
{ } ;

int main()
{
    Derived d ;

    d.x ; // エラー    
    d.Base1::x ; // OK
    d.Base2::x ; // OK
}

インクリメントとデクリメント（Increment and decrement）

ここでは、後置式のインクリメントとデクリメントについて解説する。前置式のインクリメントとデクリメントについては、単項式のインクリメントとデクリメントを参照。

式 ++
式 --

後置式の++演算子の式の結果は、オペランドの式の値になる。オペランドは、変更可能なlvalueでなければならない。オペランドの型は、数値型か、ポインター型でなければならない。式が評価されると、オペランドに1を加算する。ただし、式の結果は、オペランドに1を加算する前の値である。

int x = 0 ;
int result = x++ ;

// ここで、result == 0, x == 1

式の結果の値は、オペランドの値と変わりがないが、オペランドには、1を加算されるということに注意しなければならない。

後置式の--演算子は、オペランドから1を減算する。それ以外は、++演算子と全く同じように動く。

int x = 0 ;
int result = x-- ;

// ここで、result == 0, x == -1

Dynamic cast（Dynamic cast）

dynamic_cast < 型名 > ( 式 )

dynamic_cast<T>(v)という式は、vという式をTという型に変換する。便宜上、vをdynamic_castのオペランド、Tをdynamic_castの変換先の型とする。変換先の型はクラスへのポインターかリファレンス、あるいは、voidへのポインター型でなければならない。オペランドは、変換先の型が、ポインターの場合はポインター、リファレンスの場合はリファレンスでなければならない。

struct C {} ;

int main()
{
    C c ;

    // 変換先の型がポインターの場合は、オペランドもポインター
    // 変換先の型がリファレンスの場合は、オペランドもリファレンスでなければならない
    dynamic_cast<C &>(c) ; // OK
    dynamic_cast<C *>(&c) ; // OK

    // ポインターかリファレンスかが、一致していない
    dynamic_cast<C *>(c) ; // エラー
    dynamic_cast<C &>(&c) ; // エラー 
}

struct Base {} ;
struct Derived : Base {} ;

int main()
{
    Derived d ;

    Base & base_ref = d ;
    Derived & derived_ref = static_cast<Derived &>(base_ref) ;

    Base * base_ptr = &d ;
    Derived * derived_ptr = static_cast<Derived *>(base_ptr) ;
}

void f( Base & base )
{
    // baseがDerivedを参照しているかどうかは、分からない。
    Derived & d = static_cast<Derived &>(base) ;
}

int main()
{
    Derived derived ;
    f(derived) ; // ok

    Base base ;
    f(base) ; // エラー
}

void f( Base & base )
{
    if ( /* baseの指すオブジェクトがDerivedクラスの場合*/ )
    {
        // 特別な処理
    }

    // 共通の処理
}

動的な型チェックを使うためには、dynamic_castのオペランドのクラスは、ポリモーフィック型でなければならない。つまり、少なくともひとつのvirtual関数を持っていなければならない。ポリモーフィック型の詳しい定義については、virtual関数を参照。

もし、オペランドの参照するオブジェクトが、変換先の型として指定されている派生クラスのオブジェクトであった場合、変換することができる。

struct Base { virtual void f() {} } ;
struct Derived : Base {} ;

void f(Base & base)
{ // baseはDerivedを指しているとする
    Derived & ref = dynamic_cast<Derived &>(base) ;
    Derived * ptr = dynamic_cast<Derived *>(&base) ;
}

実引数に、変換先の型ではないオブジェクトを渡した場合、dynamic_castの変換は失敗する。変換が失敗した場合、変換先の型がリファレンスの場合、std::bad_castがthrowされる。変換先の型がポインターの場合、nullポインターが返される。

struct Base { virtual void f() {} } ;
struct Derived : Base {} ;

int main()
{
    Base base ;

    // リファレンスの場合
    try
    {
        Derived & ref = dynamic_cast<Derived &>(base) ;
    }
    catch ( std::bad_cast )
    {
        // 変換失敗
        // リファレンスの場合、std::bad_castがthrowされる
    }

    // ポインターの場合
    Derived * ptr = dynamic_cast<Derived *>(&base) ;

    if ( ptr == nullptr )
    {
        // 変換失敗
        // ポインターの場合、nullポインターが返される
    }
}

基本クラスのポインターやリファレンスが、実際は何を指しているかは、実行時にしか分からない。そのため、常に変換に失敗する可能性がある。そのため、dynamic_castを使う場合は、常に変換が失敗するかもしれないという前提のもとに、コードを書かなければならない。

失敗せずに変換できる場合というのは、オペランドの指すオブジェクトの本当の型が、変換先の型のオブジェクトである場合で、しかもアクセスできる場合である。オブジェクトである（is a）場合というのは、例えば、

struct A { virtual void f(){} } ;
struct B : A {} ;
struct C : B {} ;
struct D : C {} ;

このようなクラスがあった場合、Dは、Cであり、Bであり、Aである。従って、Dのオブジェクトを、Aへのリファレンスで保持していた場合、D、C、Bのいずれにも変換できる。

int main()
{
    D d ;
    A & ref = d ;

    // OK
    // refの指しているオブジェクトは、Dなので、変換できる。
    dynamic_cast<D &>(ref) ;
    dynamic_cast<C &>(ref) ;
    dynamic_cast<B &>(ref) ;    
}

アクセスできる場合というのは、変換先の型から、publicで派生している場合である。

struct Base1 { virtual void f(){} } ;
struct Base2 { virtual void g(){} } ;
struct Base3 { virtual void h(){} } ;

struct Derived
    : public Base1,
      public Base2,
      private Base3
{ } ;

int main()
{
    Derived d ;
    Base1 & ref = d ;

    // OK、Base2はpublicなので、アクセス出来る
    dynamic_cast<Base2 &>(ref) ;
    // 実行時エラー、Base3はprivateなので、アクセス出来ない
    // std::bad_castがthrowされる。
    dynamic_cast<Base3 &>(ref) ;
}

この例の場合、refが参照するオブジェクトは、Derived型であるので、Base3型のサブオブジェクトも持っているが、Base3からは、privateで派生されているために、アクセスすることはできない。そのため、変換することが出来ず、std::bad_castがthrowされる。

変換先の型は、void型へのポインターとすることもできる。その場合、オペランドの指す本当のオブジェクトの、もっとも派生されたクラスを指すポインターが、voidへのポインター型として、返される。

struct Base { virtual void f(){} } ;
struct Derived1 : Base {} ;
struct Derived2 : Derived1 {} ;

int main()
{
    Derived1 d1 ;
    Base * d1_ptr = &d1 ;

    // Derived1を指すポインターの値が、void *として返される
    void * void_ptr1 = dynamic_cast<void *>(d1_ptr) ;

    Derived1 d2 ;
    Base * d2_ptr = &d2;

    // Derived2を指すポインターの値が、void *として返される
    void * void_ptr2 = dynamic_cast<void *>(d2_ptr) ;
}

一般に、この機能はあまり使われることがないだろう。

// 型と式が同じ場合の例
struct C { } ;

int main()
{
    C v ;

    dynamic_cast<C &>(v) ;
    dynamic_cast<C const &>(v) ; // constを付け加える

    C const cv ;
    dynamic_cast<C &>(cv) ; // エラー、constを消し去ることは出来ない

    // ポインターの場合 
    C * ptr = &v ;
    dynamic_cast<C *>(ptr) ;   
    dynamic_cast<C const *>(ptr) ;
}

struct Base {} ; // 基本クラス
struct Derived : Base {} ; // 派生クラス

int main()
{
    Derived d ;

    Base & base_ref = dynamic_cast<Base &>(d) ;
    Base * base_ptr = dynamic_cast<Base *>(&d) ;
}

型識別（Type identification）

typeid ( 式 )
typeid ( 型名 )

typeidとは、式や型名の、型情報を得るための式である。型情報は、const std::type_infoのリファレンスという形で返される。std::type_infoについての詳細は、RTTI（Run Time Type Information）を参照。typeidを使うには、必ず、<typeinfo>ヘッダーを#includeしなければならない。ただし、本書のサンプルコードは、紙面の都合上、必要なヘッダーのincludeを省略していることがある。

typeidのオペランドは、sizeofに似ていて、式と型名の両方を取ることができる。

#include <typeinfo>

int main()
{
    // 型名の例
    typeid(int) ;
    typeid( int * ) ;

    // 式の例
    int x = 0 ;
    typeid(x) ; 
    typeid(&x) ;
    typeid( x + x ) ;

}

typeidのオペランドの式が、ポリモーフィッククラス型のglvalueであった場合、実行時チェックが働き、結果のstd::type_infoが表す型情報は、実行時に決定される。型情報は、オブジェクトの最も派生したクラスの型となる。

struct Base { virtual void f() {} } ;
struct Derived : Base {} ;

int main()
{
    Derived d ;
    Base & ref = d ;

    // オブジェクトの、実行時の本当の型を表すtype_infoが返される
    std::type_info const & ti = typeid(d) ;

    // true
    ti == typeid(Derived) ;

    // Derivedを表す、人間の読める実装依存の文字列
    std::cout << ti.name() << std::endl ;
}

オペランドの式の型がポリモーフィッククラス型のglvalueの場合で、nullポインターを参照した場合は、std::bad_typeidが投げられる。

struct Base { virtual void f() {} } ;
struct Derived : Base {} ;

int main()
{
    // ptrの値はnullポインター
    Base * ptr = nullptr ;

    try
    {
        typeid( *ptr ) ; // 実行時エラー
    }
    catch ( std::bad_typeid )
    {
        // 例外が投げられて、ここに処理が移る
    }
}

オペランドの式の型が、ポリモーフィッククラス型でない場合は、std::type_infoが表す型情報は、コンパイル時に決定される。

// int型を表すtype_info
typeid(0) ;
// double型を表すtype_info
typeid(0.0) ;

int f() {}
// int型を表すtype_info
typeid( f() ) ;

この際、lvalueからrvalueへの型変換、配列からポインターへの型変換、関数からポインターへの型変換は行われない。

// 配列からポインターへの型変換は行われない
int a[10] ;

// 型情報は、int [10]
// int *ではない
typeid(a) ;

// 関数からポインターへの型変換は行われない
void f() {}

// 型情報は、void (void)
// void (*)(void)ではない。
typeid(f) ;

これらの標準型変換は、C++では、非常に多くの場所で、暗黙のうちに行われているので、あまり意識しない。たとえば、テンプレートの実引数を推定する上では、これらの変換が行われる。

// 実引数の型を、表示してくれるはずの便利な関数
template < typename T >
void print_type_info(T)
{
    std::cout << typeid(T).name() << std::endl ;
}

void f() { }

int main()
{
    int a[10] ;
    // int [10]
    std::cout << typeid(a).name() << std::endl ;
    // int *
    print_type_info(a) ;

    // void (void)
    std::cout << typeid(f).name() << std::endl ;
    // void (*)(void)
    print_type_info(f) ;
}

std::type_info::name()の返す文字列は実装依存だが、今、C++の文法と同じように型を表示すると仮定すると、このような出力になる。C++では、多くの場面で、暗黙のうちに、これら三つの型変換が行われるので、このような差異が生じる。

オペランドが、型名の場合は、std::type_infoは、その型を表す。ほんの一例をあげると。

int main()
{
    typeid( int ) ;             // int型
    typeid( int * ) ;           // intへのポインター型
    typeid( int & ) ;           // intへのlvalueリファレンス型
    typeid( int [2] ) ;         // 配列型
    typeid( int (*)[2] ) ;      // 配列へのポインター型
    typeid( int (int) ) ;       // 関数型
    typeid( int (*)(int) );     // 関数へのポインター型
}

オペランドの式や型名の、トップレベル（top-level）のCV修飾子は、無視される。

int main()
{
    // トップレベルのCV修飾子は無視される
    typeid(const int) ; // int
    // 当然、型情報は等しい
    typeid(const int) == typeid(int) ; // true

    // 型名も式も同じ
    int i = 0 ; const int ci = 0;
    typeid(ci) ; // int
    typeid(ci) == typeid(i) ; // true

    // これはトップレベルのCV修飾子
    typeid(int * const) ; // int *

    // 以下はトップレベルのCV修飾子ではない
    typeid(const int *) ; // int const *
    typeid(int const *) ; // int const *
}

Static cast（Static cast）

static_cast< 型名 >( 式 )

static_castは、実に多くの静的な変換ができる。その概要は、標準型変換とその逆変換、ユーザー定義の変換、リファレンスやポインターにおける変換など、比較的安全なキャストである。以下にstatic_castの行える変換を列挙するが、これらを丸暗記しておく必要はない。もし、どのキャストを使うか迷った場合は、static_castを使っておけば、まず間違いはない。static_castがコンパイルエラーとなるキャストは、大抵、実装依存で危険なキャストである。

static_castによるキャストがどのように行われるかは、おおむね、以下のような順序で判定される。条件に合う変換方法が見つかった時点で、それより先に行くことはない。これは、完全なstatic_castの定義ではない。分かりやすさのため省いた挙動もある。

static_cast<T>(v)の結果は、オペランドvを変換先の型Tに変換したものとなる。変換先の型がlvalueリファレンスならば結果はlvalue、rvalueリファレンスならば結果はxvalue、それ以外の結果はprvalueとなる。static_castは、constとvolatileを消し去ることはできない。

オペランドの型が基本クラスで、変換先の型が派生クラスへのリファレンスの場合。もし、標準型変換で、派生クラスのポインターから、基本クラスのポインターへと変換できる場合、キャストできる。

struct Base {} ;
struct Derived : Base {} ;

void f(Base & base)
{
    // Derived *からBase *に標準型変換で変換できるので、キャストできる
    Derived & derived = static_cast<Derived &>(base) ;
}

ただし、これには実行時チェックがないので、baseが本当にDerivedのオブジェクトを参照していなかった場合、動作は未定義である。

glvalueのオペランドは、rvalueリファレンスに型変換できる。

int main()
{
    int x = 0 ;
    static_cast<int &&>(x) ;
}

もし、static_cast<T>(e) という式で、T t(e); という宣言ができる場合、オペランドの式eは、変換先の型Tに変換できる。その場合、一時オブジェクトを宣言して、それをそのまま使うのと、同じ意味になる。

// short t(0) は可能なので変換できる
static_cast<short>(0) ;

// float t(0) は可能なので変換できる
static_cast<float>(0) ;

標準型変換の逆変換を行うことができる。ただし、いくつかの変換は、逆変換を行えない。これには、lvalueからrvalueへの型変換、配列からポインターへの型変換、関数からポインターへの型変換（Function-to-pointer conversion）、ポインターや関数ポインターからnullポインターへの変換、がある。

変換先の型に、voidを指定することができる。その場合、static_castの結果はvoidである。オペランドの式は評価される。

int main()
{
    static_cast<void>( 0 ) ;
    static_cast<void>( 1 + 1 ) ;    
} 

整数型とscoped enum型は、static_castを使うことで、明示的に変換することができる。その場合、変換先の型で、オペランドの値を表現できる場合は、値が保持される。値を表現できない場合の挙動は、規定されていない。

int main()
{
    enum struct A { value = 1 } ;
    enum struct B { value = 1 } ;

    int x = static_cast<int>( A::value ) ;
    A a = static_cast<A>(1) ;
    B b = static_cast<B>( A::value ) ;
} 

派生クラスへのポインターから、基本クラスへのポインターにキャストできる。

struct Base {} ;
struct Derived : Base {} ;

Derived d ;
Base * ptr = static_cast<Base *>(&d) ;

voidへのポインターは、他の型へのポインターに変換できる。ある型へのポインターから、voidへのポインターにキャストされ、そのまま、ある型へのポインターにキャストされなおされた場合、その値は保持される。

int main()
{
    int x = 0 ;
    int * ptr = &x ;

    // void *への変換は、標準型変換で行えるので、キャストはなくてもよい。
    void * void_ptr = static_cast<void *>(ptr) ;

    // キャストが必要
    ptr = static_cast<int *>(void_ptr) ;

    *ptr ; // ポインターの値は保持されるので、xを正しく参照する
} 

Reinterpret cast

reinterpret_cast < 型名 > ( 式 )

reinterpret_castは、式の値をそのまま、他の型に変換するキャストである。ポインターと整数の間の変換や、ある型へのポインターを全く別の型へのポインターに変換するといったことができる。reinterpret_castを使えば、値をそのままにして、型を変換することができる。変換した結果、その値が、変換先の型としてそのまま使えるかどうかなどといったことは、ほとんど規定されていない。元の値をそのまま保持できるかどうかも分からない。それ故、reinterpret_castは、危険なキャストである。

多くの実装では、reinterpret_castには、何らかの具体的で実用的な意味がある。現実のC++が必要とされる環境では、reinterpret_castを使わなければならないことも、多くある。しかし、reinterpret_castを使った時点で、そのコードは実装依存であり、具体的に意味が定義されたその環境でしか動かないということを、常に意識するべきである。

reinterpret_castでは、constやvolatileを消し去ることはできない。

reinterpret_castでできる変換を、以下に列挙する。

int main()
{
    int x = 0 ;
    int * ptr = &x ;

    // ポインターから整数へのキャスト
    int value = reinterpret_cast<int>(ptr) ;

    // 整数からポインターへのキャスト
    ptr = reinterpret_cast<int *>(value) ;
} 

int main()
{
    int x = 0 ;
    int * int_ptr = &x ;

    // int * からshort *へのキャスト
    short * short_ptr = reinterpret_cast<short *>(int_ptr) ;
} 

int main()
{
    int x = 0 ;

    // int & からshort &へのキャスト
    short & short_ref = reinterpret_cast<short &>(x) ;
} 

struct A { int value ; } ;
struct B { int value ; } ;

int main()
{
    int B::* ptr = reinterpret_cast<int B::*>(&A::value) ;
} 

void f(int) {}

int main()
{
    // void (short)な関数へのポインター型
    using type = void (*)(short) ;

    // 関数ポインターの型変換
    type ptr = reinterpret_cast<type>(&f) ;
} 

int main()
{
    short value = 0 ;

    // OK、標準型変換による暗黙の型変換
    int a = value ;
    // OK、static_castによる明示的な型変換
    int b = static_cast<int>(value) ;

    // エラー
    // reinterpret_castでは、この型変換をサポートしていない
    int c = reinterpret_cast<int>(value) ;
} 

Const cast

const_cast < 型名 > ( 式 )

const_castは、constとvolatileが異なる型の間の型変換を行う。constやvolatileを取り除くことや、付け加えることができる。

int main()
{
    int const x = 0 ;

    // エラー、constを取り除くことはできない。
    int * error1 = &x ; 
    int * error2 = static_cast<int *>(&x) ;

    // OK、ポインターの例
    int * ptr = const_cast<int *>(&x) ;
    // OK、リファレンスの例
    int & ref = const_cast<int &>(x) ;

    // constを付け加えることもできる。
    int y = 0 ;
    int const * cptr = const_cast<int const *>(&y) ;
} 

ポインターへのポインターであっても、それぞれのconstを取り除くことができる。

int main()
{
    int const * const * const * const c = nullptr ;
    int *** ptr = const_cast<int ***>(c) ;
} 

const_castは、constやvolatileのみを取り除く、または付け加えるキャストのみを行える。それ以外の型変換を行うことはできない。

int main()
{
    int const x = 0 ;
    // エラー、const以外の型変換を行っている。
    short * ptr = const_cast<short *>(&x) ;
} 

では、constを取り除くと同時に、他の型変換も行ないたい場合はどうするかというと、static_castや、reinterpret_castを併用する。

int main()
{
    int const x = 0 ;

    short * ptr1 =
        static_cast<short *>(
            static_cast<void *>(
                const_cast<int *>(&x)
            )
        ) ;
  
    short * ptr2 = reinterpret_cast<short *>(const_cast<int *>(&x)) ;
} 

const_castは、基本的に、ほとんどのconstをキャストすることができるが、キャストできないconstも存在する。たとえば、関数ポインターやメンバー関数ポインターに関するconstを取り除くことはできない。関数へのリファレンスも同様である。

void f( int ) {}

int main()
{
    using type = void (*)(int) ;
    type const ptr = nullptr ;

    // エラー、関数ポインターはキャストできない
    type p = const_cast<type>(ptr) ;
} 

もちろん、関数の仮引数に対するconstをキャストすることや、constなメンバー関数を非constなメンバー関数にキャストすることなどもできない。

単項演算子（Unary operators）

単項演算子というカテゴリーには、六つの異なる演算子がまとめられている。*、&、+、-、!、~である。

int main()
{
    int x = 0 ;

    // & 演算子
    // 変数xのオブジェクトへのポインターを得る。
    int * ptr = &x ;

    // * 演算子
    // ポインターを参照する
    *ptr ;
}

int main()
{
    int x = +0 ; // xは0
    +x ; // 結果は0

    int * ptr = nullptr ;
    +ptr ; // 結果はptrの値
} 

short x = 0 ;
+x ; // int型の0

-0 ; // 0
-1 ; // -1
- -1 ; // +1

// unsigned int型は16bitであるとする。
unsigned int x = 1 ;
// result = 216 - 1 = 65536 - 1 = 65535
unsigned int result = -x ;

x = 100 ;
// result = 216 - 100 = 65536 - 100 = 65436
result = -x ;

!true ; // false
!false ; // true

int x = 0 ;
!x ; // 0はfalseに変換される。その否定なので、結果はtrue

int x = 0 ;
// ビット列の各ビットを反転する
~x ;

インクリメントとデクリメント（Increment and decrement）

++ 式
-- 式

ここでは、前置式のインクリメントとデクリメントについて解説する。後置式のインクリメントとデクリメントも参照。

前置式の++ 演算子は、オペランドに1を加算して、その結果をそのまま返す。オペランドは数値型かポインター型で、変更可能なlvalueでなければならない。式の結果はlvalueになる。

前置式の-- 演算子は、オペランドから1を減算する。それ以外は、++演算子と同じように動く。

int x = 0 ;
int result = ++x ;
// ここで、result = 1, x = 1

sizeof（Sizeof）

sizeof ( 未評価式 )
sizeof ( 型名 )
sizeof ... ( 識別子 )

sizeofとは、オペランドを表現するオブジェクトのバイト数を返す演算子である。オペランドは、未評価式か型名になる。

オペランドに型名を指定した場合、sizeof演算子は、型のオブジェクトのバイト数を返す。sizeof(char)、sizeof(signed char)、sizeof(unsigned char)は、1を返す。それ以外のあらゆる型のサイズは、実装によって定義される。たとえば、sizeof(bool)やsizeof(char16_t)やsizeof(char32_t)のサイズも、規格では決められていない。

// 1
sizeof(char) ;
// int型のオブジェクトのサイズ
sizeof(int) ;

オペランドに式を指定した場合、その式の結果の型のオブジェクトのバイト数を返す。式は評価されない。lvalueからrvalueへの型変換、配列からポインターへの型変換、関数からポインターへの型変換は行われない。

int f() ;

// int型のオブジェクトのサイズ
sizeof( f() ) ;
// int型のオブジェクトのサイズ
sizeof( 1 + 1 ) ;

関数呼び出しの式の結果の型は、関数の戻り値の型になる。

オペランドには、関数と不完全型を使うことはできない。関数は、そもそもオブジェクトではないし、不完全型は、そのサイズを決定できないからだ。「関数」は使えないが、関数呼び出しは「関数」ではないので使える。また、関数ポインターにも使える。

int f() ;
struct Incomplete ;

// 関数呼び出しは「関数」ではない
// sizeof(int) と同じ
sizeof( f() ) ;
// 関数ポインターはオブジェクトであるので、使える
// sizeof ( int (*)(void) ) と同じ
sizeof( &f ) ;

// エラー、関数を使うことはできない
sizeof( f ) ;
// エラー、不完全型を使うことはできない
sizeof( Incomplete ) ;

オペランドがリファレンス型の場合、参照される型のオブジェクトのサイズになる。

void f( int & ref )
{
// sizeof(int)と同じ
sizeof(int &) ;
sizeof(int &&) ;
sizeof( ref ) ;
}

オペランドがクラス型の場合、クラスのオブジェクトのバイト数になる。これには、アライメントの調整や、配列の要素として使えるようにするための実装依存のパディングなども含まれる。クラス型のサイズは、必ず1以上になる。これは、サイズが0では、ポインターの演算などに差し支えるからである。

オペランドが配列型の場合、配列のバイト数になる。これはつまり、要素の型のサイズ　×　要素数となる。

// sizeof(int) * 10 と同じ
sizeof( int [10] ) ;

char a[10] ;
// sizeof(char) * 10 = 1 * 10 = 10
sizeof( a ) ;

// この型は配列ではなく、char
// sizeof(char)と同じ
sizeof( a[0] ) ;

sizeof...は、オブジェクトのバイト数とは、何の関係もない。sizeof...のオペランドには、パラメーターパックの識別子を指定できる。sizeof...演算子は、オペランドのパラメーターパックの引数の数を返す。sizeof...演算子の結果は定数で、型はstd::size_tである。

#include <cstddef>
#include <iostream>

template < typename... Types >
void f( Types... args )
{
    std::size_t const t = sizeof...(Types) ;
    std::size_t const a = sizeof...(args) ;

    std::cout << t << ", " << a << std::endl ;    
}

int main()
{
    f() ; // 0, 0
    f(1,2,3) ; // 3, 3
    f(1,2,3,4,5) ; // 5, 5
}

new

確保関数と解放関数の具体的な実装方法については、動的メモリー管理を参照。

::opt new 型名 new初期化子opt
::opt new ( 式リスト ) 型名 new初期化子opt

newに必要な宣言の一部は、<new>ヘッダーで定義されているので、使う際は、これをincludeしなければならない。

new式は、型名のオブジェクトを生成する。newされる型は、完全型でなければならない。ただし、抽象クラスはnewできない。リファレンスはオブジェクトではないため、newできない。new式の結果は、型が配列以外の場合は、生成されたオブジェクトへのポインターを返す。型が配列の場合は、配列の先頭要素へのポインターを返す。

class C {} ;
int main()
{
    // int型のオブジェクトを生成する
    int * i = new int ;
    // C型のオブジェクトを生成する
    C * c = new C ;
}

newが、オブジェクトのためのストレージの確保に失敗した場合、std::bad_alloc例外がthrowされる。

int main()
{
    try
    {
        new int ;
    }
    catch ( std::bad_alloc )
    {
        // newが失敗した
    }
}

詳細なエラーについては、後述する。

newによって生成されるオブジェクトは、動的ストレージの有効期間を持つ。つまり、newによって作られたオブジェクトを破棄するためには、明示的にdeleteを使わなければならない。

int main()
{
    int * ptr = new int ; // 生成
    delete ptr ; // 破棄
}

void f( int n )
{
    // 5個のint型の配列を生成する
    // 要素数は定数
    new int[5] ;

    // n個のint型の配列を生成する
    // 要素数は定数ではない
    new int[n] ;
}

void f( int n )
{
    // 要素数はすべて定数
    new int[5][5][5] ;

    // OK
    // 最初の要素数は定数ではない
    // 残りはすべて定数
    new int[n][5][5] ;

    new int [n] // 最初の要素数は定数でなくてもよい
            [5][5] ; // 残りの要素数は定数でなければならない

    // エラー
    // 最初以外の要素数が定数ではない
    new int[n][n][n] ;
    new int[5][n][n] ;
    new int[5][n][5] ;
}

int main()
{
    // OK 
    int * ptr = new int[0] ;
    // もちろんdeleteしなければならない
    delete [] ptr ;

    // エラー
    new int[-1] ;
}

// int[n]のストレージを確保できないとする。
int main()
{
    try
    {
        std::size_t n = std::numeric_limits<std::size_t>::max() ;
        new int[n] ; // 要素数は定数ではない
    }
    catch ( std::bad_array_new_length )
    {
        // ストレージを確保できなかった場合
    }

    try
    {
        // numeric_limitsのメンバー関数maxはconstexpr関数なので、定数になる。
        std::size_t const n = std::numeric_limits<std::size_t>::max() ;
        new int[n] ; // 要素数は定数
    }
    catch ( std::bad_alloc )
    {
        // ストレージを確保できなかった場合
    }    
}

struct C
{
    C() {}
    C(int) {}
    C(int,int) {}
} ;


int main()
{
    // new初期化子が省略されている
    // デフォルト初期化
    new C ;

    // 直接初期化
    new C(0) ;
    new C(0, 0) ;

    // 初期化リスト
    new C{0} ;
    new C{0,0} ;
}

int f() { return 0 ; }
int main()
{
    // int型、値は0
    new auto( 0 ) ;
    // double型、値は0.0
    new auto( 0.0 ) ;
    // float型、値は0.0f
    new auto( 0.0f ) ;
    // int型、値は関数fの戻り値
    new auto( f() ) ;
}

void * operator new( std::size_t size, int ) throw(std::bad_alloc)
{ return operator new(size) ; }
void * operator new( std::size_t size, int, int ) throw(std::bad_alloc)
{ return operator new(size) ; }
void * operator new( std::size_t size, int, int, int ) throw(std::bad_alloc)
{ return operator new(size) ; }

int main()
{
    new(1) int ; // operator new( sizeof(int), 1 )
    new(1,2) int ; // operator new( sizeof(int), 1, 2 )
    new(1,2,3) int ; // operator new( sizeof(int), 1, 2, 3 )
}

// デフォルトで実装により定義される確保関数
// void * operator new(std::size_t, const std::nothrow_t &) throw() ;

int main()
{
    // 失敗しても例外を投げない
    int * ptr = new(std::nothrow) int ;

    if ( ptr != nullptr )
    {
        // オブジェクトの生成に成功
        // 参照できる
        *ptr = 0 ;
    }

    delete ptr ;
}

// 実装例
namespace std {
    struct nothrow_t {} ;
    extern const nothrow_t nothrow ;
}

struct C
{
    C(){ std::cout << "constructed." << std::endl ; }
    ~C(){ std::cout << "destructed." << std::endl ; }
} ;

int main()
{
    // ストレージを自前で確保する
    // operator newの返すストレージは、あらゆるアライメント要求を満たす
    void * storage = operator new( sizeof(C) ) ;

    // placement newによって、ストレージ上にオブジェクトを構築
    C * ptr = new( storage ) C ;

    // ストレージの解放の前に、デストラクターを呼び出す
    ptr->~C() ;

    // ストレージを自前で解放する
    operator delete( storage ) ;
}

struct C
{
    int x ;
    double y ;
} ;

int main()
{
    // ストレージは自動変数
    char storage [[align(C)]] [sizeof(C)] ;

    // placement newによって、ストレージ上にオブジェクトを構築
    C * ptr = new( storage ) C ;

    // デストラクターはtrivialなので呼ぶ必要はない。
    // ストレージは自動変数なので、解放する必要はない
}

int main()
{
    try
    {
        new int ;
    }
    catch ( std::bad_alloc )
    {
        // エラー処理
    }

    int * ptr = new(std::nothrow) int ;

    if ( ptr == nullptr )
    {
        // エラー処理
    }
}

// 例外を投げるコンストラクターを持つクラス
struct Fail
{
    Fail() { throw 0 ; }
} ;

int main()
{
    try
    {
        new Fail ; // 必ず初期化に失敗する
    }
    catch ( int ) { }
}

// placement new
void * operator new( std::size_t size, int, int, int ) throw(std::bad_alloc)
{ return operator new(size) ; }

// placement delete
void operator delete( void * ptr, int, int, int ) throw()
{
    std::cout << "placement delete" << std::endl ;
    operator delete(ptr) ;
}

// 例外を投げるかもしれないクラス
struct Fail
{
    Fail() noexcept(false) ; // 例外を投げる可能性がある
} ;

int main()
{
    // コンストラクターが例外を投げた場合、
    // operator delete( /*ストレージへのポインター*/, 1, 2, 3 )が呼ばれる
    Fail * ptr = new(1, 2, 3) Fail ;

    // operator delete(void *)が呼ばれる
    delete ptr ;
}

// オーバーロードあり
struct A
{
    void * operator new( std::size_t size ) throw(std::bad_alloc) ;
} ;

// オーバーロードなし
struct B { } ;

int main()
{
    // A::operator newが選ばれる
    new A ;
    // ::operator newが選ばれる
    new B ;

    // ::operator newが選ばれる
    ::new A ;
}

// オーバーロードあり
struct A
{
    void * operator new[]( std::size_t size ) throw(std::bad_alloc) ;
} ;

// オーバーロードなし
struct B { } ;

int main()
{
    // A::operator new[]が選ばれる
    new A[1] ;
    // ::operator new[]が選ばれる
    new B1[1] ;

    // ::operator new[]が選ばれる
    ::new A[1] ;
}

void * operator new( std::size_t size, int ) throw( std::bad_alloc ) ;
void * operator new( std::size_t size, double ) throw( std::bad_alloc ) ;
void * operator new( std::size_t size, int, int ) throw( std::bad_alloc ) ;

int main()
{
    // operator new( std::size_t size, int )
    new(0) int ;
    // operator new( std::size_t size, double )
    new(0.0) int ;
    // operator new( std::size_t size, int, int )
    new(1, 2) int ;
}

int main()
{
    int const * ptr = new int const(0) ;
    delete ptr ;
}

delete

確保関数と解放関数の具体的な実装方法については、動的メモリー管理を参照。

::opt delete 式
::opt delete [ ] 式

new式によって確保したオブジェクトの寿命は、スコープにはとらわれない。オブジェクトを破棄したければ、delete式で解放しなければならない。

deleteのオペランドの値は、new式によって返されたポインターでなければならない。オブジェクトが配列ではない場合は、deleteを、配列の場合は、delete [ ]を使う。delete式の結果の型は、voidである。

int main()
{
    int * ptr = new int ;
    int * array_ptr = new int[1] ;

    delete ptr ;
    delete[] array_ptr ;
}

配列であるかどうかで、deleteとdelete[]を使い分けなければならない。これは間違えやすいので注意すること。

deleteのオペランドがクラスのオブジェクトであった場合、非explicitなユーザー定義の変換が定義されている場合、オブジェクトへのポインターに変換される。

struct C
{
    operator int *() { return new int ; }
} ;

int main()
{
    C c ;
    // C::operator int *()を呼び出し、
    // 戻り値を解放する。
    delete c ;
}

delete式は、まず、ポインターの指し示すオブジェクトのデストラクターを呼び出す。次に、解放関数を呼び出して、ストレージを解放する。オブジェクトの指す型が、メンバー関数としてoperator deleteのオーバーロードを持つ場合、メンバー関数が呼ばれる。オーバーロードされたメンバー関数が存在しない場合、グローバルスコープのoperator deleteを呼び出す。delete式が、「::delete」で始まる場合、メンバー関数のオーバーロードの有無にかかわらず、グローバルスコープのoperator deleteを呼び出す。

// オーバーロードあり
struct A
{
    void operator delete( void * ) throw() ;
} ;

// オーバーロードなし
struct B { } ;

int main()
{
    A * a = new A ;
    // A::operator delete(void*)を呼び出す
    delete a ; 

    B * b = new B ;
    // ::operator delete(void*)を呼び出す
    delete b ;

    a = new A ;
    // ::operator delete(void*)を呼び出す
    ::delete a ;
}

オブジェクトが、placement newで確保されたとしても、呼び出す解放関数は、必ずoperator delete(void *)、もしくはoperator delete[](void *)となる。delete式では、placement deleteは呼び出されない。また、delete式には、placement deleteを呼び出すための文法も存在しない。どうしてもplacement deleteを呼び出したい場合は、手動でデストラクターを呼び出し、さらに手動でplacement deleteを呼び出すしかない。

// placement delete
void operator delete( void *, int ) throw() ;

struct C
{
    C() {}
    ~C(){}
} ;

void f()
{
    C * ptr = new C ;

    // これでは、operator delete( void * )が呼び出される
    delete ptr ;

    // 疑似デストラクター呼び出し
    ptr->~C() ;
    // operator deleteの明示的な呼び出し
    operator delete( ptr, 0 ) ;
}

alignof

alignof ( 型名 )

alignof式は、オペランドの型のアライメント要求を返す。オペランドの型は、完全なオブジェクト型か、その配列もしくはリファレンスでなければならない。式の結果は、std::size_t型の定数になる。

オペランドが、リファレンス型の場合、結果は参照される型のアライメント要求になる。配列の場合、結果は配列の要素の型のアライメント要求になる。

struct C
{
    char c ; int i ; double d ;
} ;

void f()
{
    // char型のアライメント要求を返す
    alignof( char ) ;
    // int型のアライメント要求を返す
    alignof( int ) ;
    // double型のアライメント要求を返す
    alignof( double ) ;
    // C型のアライメント要求を返す
    alignof( C ) ;
}

noexcept演算子（noexcept operator）

noexcept ( 未評価式 )

noexcept演算子は、オペランドの式が、例外を投げる可能性のある式を含むかどうかを返す。noexcept演算子の結果の型はboolの定数で、例外を投げる可能性のある式を含まない場合trueを、含む場合falseを返す。オペランドの式は、評価されない。

結果がfalseとなる場合、すなわち、例外を投げる可能性のある式とは、以下の通りである。

throw式。

// false
noexcept( throw 0 ) ;

dynamic_cast式、dynamic_cast<T>(v)において、Tがリファレンス型で、実行時チェックが必要な場合。

struct Base { virtual void f() {} } ;
struct Derived : Base { } ;

void f( Base & ref )
{
    // false
    noexcept( dynamic_cast<Derived & >( ref ) ) ;
}

typeid式において、オペランドがglvalueで、実行時チェックが必要な場合。

struct Base { virtual void f() {} } ;
struct Derived : Base { } ;

void f( Base * ptr )
{
    // false
    noexcept( typeid( *ptr ) ) ;
}

関数、メンバー関数、関数ポインター、メンバー関数ポインターを呼び出す式において、呼び出す関数の例外指定が、無例外（non-throwing）でないもの。

void a() ;
void b() noexcept ; // non-throwing
void c() noexcept(true) ; // non-throwing
void d() noexcept(false) ;
void e() throw() ; // non-throwing
void f() throw(int) ;

int main()
{
    noexcept( a() ) ; // false
    noexcept( b() ) ; // true
    noexcept( c() ) ; // true
    noexcept( d() ) ; // false
    noexcept( e() ) ; // true
    noexcept( f() ) ; // false
}

関数を、「呼び出す式」というのは、関数を間接的に呼び出す場合も該当する。たとえば、new式は確保関数を呼び出すので、関数を呼び出す式である。その場合の結果は、呼び出される確保関数の例外指定に依存する。

int main()
{
    // ::operator new( std::size_t ) throw( std::bad_alloc) を呼び出す
    std::cout << noexcept( new int ) ; // false

    // ::operator new( std::size_t, std::nothrow_t ) throw() を呼び出す
    std::cout << noexcept( new(std::nothrow) int ) ; // true
}

もちろん、演算子のオーバーロード関数も、「関数」である。従って、演算子のオーバーロード関数を呼び出す式は、関数を呼び出す式である。

struct C
{
    C operator +( C ) ;
    C operator -( C ) noexcept ;
} ;


int main()
{
    int i = 0 ;
    noexcept( i + i ) ; // true

    C c ;
    noexcept( c + c ) ; // false
    noexcept( c - c ) ; // true
}

その他にも、関数を間接的に呼び出す可能性のある式というのは、非常に多いので、注意しなければならない。

関数のオーバーロード解決は静的に行われるので、当然、呼び出される関数に応じて結果も変わる。

void f(int) noexcept ;
void f(double) ;

int main()
{
    noexcept( f(0) ) ; // true
    noexcept( f(0.0) ) ; // false
}

例外を投げる可能性のある式を「含む」というのは、たとえその式が絶対に評価されないでも、例外を投げる可能性があるとみなされる。例えば、

noexcept( true ? 0 : throw 0 ) ; // false

このnoexceptのオペランドの式は、もし評価された場合、決して例外を投げることがない。しかし、例外を投げる可能性のある式を含んでいるので、noexceptの結果はfalseとなる。

上記以外の場合、noexceptの結果はtrueとなる。

struct Base { } ;
struct Derived : Base { } ;

int main()
{
    noexcept( 0 ) ; // true

    Derived d ;
    noexcept( d ) ; // true
    noexcept( dynamic_cast<Base &>( d ) ) ; // true
    noexcept( typeid( d ) ) ; // true
}

if文（The if statement）

if ( 条件 ) 文
if ( 条件 ) 文 else 文

if文は、条件の値によって、実行すべき文を変える。

条件がtrueと評価された場合、一つ目の文が実行される。条件がfalseと評価された場合、elseに続く二つ目の文が有るのならば、二つ目の文が実行される。

int main()
{
    if ( true ) // 一つ目の文が実行される
        /*一つ目の文*/ ;

    if ( false ) // 一つ目の文は実行されない
        /*一つ目の文*/ ;

    if ( true ) // 一つ目の文が実行される
        /*一つ目の文*/ ;
    else
        /*二つ目の文*/ ;

    if ( false ) // 二つ目の文が実行される
        /*一つ目の文*/ ;
    else
        /*二つ目の文*/ ;
}

elseは、近い方のif文に対応する。

int main()
{
    if ( false ) // #1
        if ( true ) ; // #2

    else { } // #2のif文に対応するelse
}

インデントに騙されてはいけない。インデントを正しく対応させると、以下のようになる。

int main()
{
    if ( false ) // #1
        if ( true ) ; // #2
        else ; // #2のif文に対応するelse
}

このため、elseのあるif文の中に、さらにif文をネストさせたい場合は、内側のif文にも、elseが必要である。

int main()
{
    if ( false ) // #1
        if ( true ) ; // #2
        else ; // #2のif文に対応するelse
    else ; // #1のif文に対応するelse
}

あるいは、ブロック文を使うという手もある。

int main()
{
    if ( false ) // #1
    { if ( true ) ; }

    else ; // #1のif文に対応するelse
}

switch文（The switch statement）

switch( 条件 ) 文 

switch文は、条件の値によって、実行する文を選択する。

条件は、整数型かenum型、もしくは非explicitな変換関数を持つクラス型でなければならない。条件がクラス型の場合、整数型かenum型に型変換される。

struct C
{
    operator int(){ return 0 ; }
} ;

int main()
{
    switch(1) ; // OK
    C c ;
    switch(c) ; // OK、C::operator int()が呼ばれる

    switch(1.0) ; // エラー、浮動小数点数型は指定できない

    switch( static_cast<int>(1.0) ) ; // OK
}

switch文の中の文には、通常、複合文を指定する。複合文の中には、caseラベル文やdefaultラベル文を書く。

switch(1)
{
    case 1 :
        /* 処理 */ ;
    break ;

    case 2 :
        /* 処理 */ ;
    break ;

    default :
        /* 処理 */ ;
}

caseラベル文に指定する式は、整数の定数式でなければならない。また、同じswitch内で、caseラベル文の値が重複してはならない。

defaultラベル文は、switch文の中の文に、ひとつだけ書くことができる。

switch文が実行されると、まず条件が評価される。結果の値が、switch文の中にあるcaseラベルに対して、ひとつづつ比較される。もし、値が等しいcaseラベル文が見つかった場合、そのラベル文に実行が移る。

void f( int const value )
{
    switch( value )
    {
        case 1 :
            std::cout << "Good morning." << std::endl ;
        break ;
        case 2 :
            std::cout << "Good afternoon." << std::endl ;
        break ;
        case 3 :
            std::cout << "Good evening." << std::endl ;
        break ;
    }
}

int main()
{
    f( 1 ) ; // Good morning.
    f( 2 ) ; // Good afternoon.
    f( 3 ) ; // Good evening.
}

条件と値の等しいcaseラベルが見つからない場合で、defaultラベルがある場合、defaultラベルに実行が移る。

void f( bool const value )
{
    switch( value )
    {
        case true :
            std::cout << "true" << std::endl ;
        break ;

        default :
            std::cout << "false" << std::endl ;
        break ;
    }
}

int main()
{
    f( true ) ; // true
    f( false ) ; // false
}

条件と値の等しいcaseラベルが見つからず、defaultラベルもない場合、switch内の文は実行されない。

int main()
{
    // switch内の文は実行されない
    switch( 0 )
    {
        case 999 :
            std::cout << "hello" << std::endl ;
        break ;
        case 123456 :
            std::cout << "hello" << std::endl ;
        break ;
    }
}

caseラベルとdefaultラベル自体には、文の実行を変更する機能はない。

void f( int const value )
{
    switch( value )
    {
        case 1 :
            std::cout << "one" << std::endl ;
        default :
            std::cout << "default" << std::endl ;
        case 2 :
            std::cout << "two" << std::endl ;
    }
}

この場合、valueの値が1の場合、case 1のラベル文に続く文も、すべて実行されてしまう。また、valueの値が1でも2でもない場合、defaultラベル文に続くcase 2のラベル文も、実行されてしまう。このため、switch内の実行を切り上げたい時点で、break文を書かなければならない。break文を書き忘れたことによる、意図しない文の実行は、よくあることなので、注意が必要である。なお、このことは、逆に利用することもできる。

void f( int const value )
{
    switch( value )
    {
        case 3 :
        case 5 :
        case 7 :
            /* 何らかの処理 */ ;
    }
}

この例では、valueの値が3, 5, 7のいずれかの場合に、何らかの処理が実行される。

while文（The while statement）

while ( 条件 ) 文

while文は、条件の結果がfalseになるまで、文を繰り返し実行する。条件は、文の実行前に、繰り返し評価される。

int main()
{
    // 一度も繰り返さない
    while ( false )
    {
        std::cout << "hello" << std::endl ; 
    }

    // 無限ループ
    while ( true )
    {
        std::cout << "hello" << std::endl ; 
    }

    // iが10になるまで繰り返す
    int i = 0 ;
    while ( i != 10 )
    {
        ++i ;
    }

}

条件が宣言である場合、変数のスコープは、while文の宣言された場所から、while文の最後までである。条件の中で宣言された変数は、文の実行が繰り返されるたびに、生成、破棄される。

while ( T t = x ) 文

という文は、

label:
{
    T t = x;
    if (t)
    {
        文
        goto label;
    }
}

と書くのに等しい。

while文の条件の中で宣言された変数は、ループの繰り返しのたびに、破棄されてから再び生成される。

#include <iostream>

class nonzero
{
private :
    int value ;

public :
    nonzero( int i )
        : value(i)
    { std::cout << "constructed" << std::endl ; }
    ~nonzero()
    { std::cout << "destructed" << std::endl ;}

    operator bool() { return value != 0 ; }
} ;

int main()
{
    int i = 3 ;

    while ( nonzero n = i )
    {
        --i ;
    }
}

do文（The do statement）

do 文 while ( 式 ) ;

do文の式は、boolに変換される。boolに変換できない場合、エラーとなる。

do文は、式の結果がfalseになるまで、文が繰り返し実行される。ただし、式の評価は、文の実行の後に行われる。

int main()
{
    // 一度だけ文を実行
    do {
        std::cout << "hello" << std::endl ; 
    } while ( false ) ;


    // 無限ループ
    do {
        std::cout << "hello" << std::endl ; 
    } while ( true ) ;
}

for文（The for statement）

for ( for初期化文 条件opt ; 式opt ) 文

for初期化文:
    式文
    宣言

for文は、for初期化文で、ループ前の初期化を書き、条件で、ループを実行するかどうかの判定を行い、文が実行されたあとに、そのつど式が評価される。

for文の実行では、まず、for初期化文が実行される。for初期化文は、式文か、変数の宣言を行うことができる。変数のスコープは、for文の最後までである。次に、文の実行の前に、条件が評価され、falseとなるまで文が繰り返し実行される。文の実行の後に、式が評価される。

for ( for初期化文 条件 ; 式 ) 文

は、以下のコードと同等である。

{
    for初期化文
    while ( 条件 )
    {
        文
        式 ;
    }
}

ただし、文の中でcontinue文を使ったとしても、式は評価されるという違いがある。

for文は、while文でよく書かれるコードを書きやすくした構文である。例えば、while文を10回実行したい場合、

int main()
{
    // カウンター用の変数の宣言
    int i = 0 ; 

    while ( i != 10 )
    {
        // 処理
        ++i ;
    }
}

このようなコードを書く。for文は、このようなコードを、一度に書けるようにしたものである。

int main()
{
    for ( int i = 0 ; i != 10 ; ++i )
    {
        // 処理
    }
}

for文の条件と式は、省略することができる。条件を省略した場合、trueとみなされる。

int main()
{
    // 条件を省略、for ( ; true ; ) と同じ
    for ( ; ; ) ;
}

range-based for文（The range-based for statement）

ここでは、range-based forの言語機能を説明している。ライブラリとしてのレンジや、ユーザー定義のクラスでレンジをサポートする方法については、ライブラリのレンジを参照。

for ( for-range-宣言 : for-range-初期化子 ) 文

int main()
{
    int a[] = { 1, 2, 3 } ;
    for ( int i : a ) ; // 各要素をint型のコピーで受ける
    for ( int & ref : a ) ; // 各要素をリファレンスで受ける
    for ( auto i : a ) ; // auto指定子を使った例
}

int main()
{
    int a[] = { 1, 2, 3 } ;
    for ( auto i : a )
    {
        i ;
    }
}

#include <iostream>

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 } ;
    for (
        int * iter = &a ; // 各要素を表す変数の宣言
        iter != &a + 5 ; // 終了条件の判定
        ++iter // 次の要素の参照
    )
    {
        // 各要素に対する処理
        std::cout << *iter << std::endl ;
    }
}

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 } ;
    for ( auto i : a )
    {
        std::cout << i << std::endl ;
    }
}

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 } ;
    for ( int & i : a )
    {
        i *= 2 ; // 二倍する
    }
}

#include <iterator>

int main()
{
    // 配列
    int a[] = { 1, 2, 3 } ;
    for ( auto i : a )
    { std::cout << i << std::endl ; }     
    
    // 初期化リスト
    for ( auto i : { 1, 2, 3 } )
    { std::cout << i << std::endl ; } 

    // クラス
    std::vector<int> v = { 1, 2, 3 } ;
    for ( auto i : v )
    { std::cout << i << std::endl ; } 
}

for ( for-range-宣言 : for-range-初期化子 ) 文

for ( auto i : a, b, c, d ) ;
// 括弧でくくる
for ( auto i : (a, b, c, d) ) ;

{
    // 式の結果をlvalueかrvalueのリファレンスで束縛
    auto && __range = for-range-初期化子 ;
    for (
        auto __begin = begin式, // 先頭のイテレーター
        __end = end式 ; // 終端のイテレーター
        __begin != __end ; // 終了条件
        ++__begin ) // イテレーターのインクリメント
    {
        for-range-宣言 = *__begin; // 要素を得る
        文
    }
}

int x [10] ;
for ( auto i : x )
{
    // 処理
}

int x [10] ;
{
    auto && __range = ( x ) ;
    for (
        auto __begin = __range,
        __end = __range + 10 ;
        __begin != __end ;
        ++__begin )
    {
        auto i = *__begin; 
        // 処理
    }
}

std::vector<int> v ;
for ( auto i : v )
{
    // 処理
}

std::vector<int> v ;
{
    // 式の結果をlvalueかrvalueのリファレンスで束縛
    auto && __range = ( v ) ;
    for (
        auto __begin = begin(__range),
        __end = end(__range) ;
        __begin != __end ;
        ++__begin )
    {
        auto i = *__begin; 
        // 処理
    }
}

ジャンプ文（Jump statements）

ジャンプ文は、実行する文を無条件で変更するための文である。

break ;

int main()
{
    while ( true )
    {
        break ;
    }

    do
    {
        break ;
    } while ( true ) ;

    for ( ; ; )
    {
        break ;
    }

    switch(0)
    {
        default :
            break ;
    }
}

int main()
{
    while ( true ) // 外側
        while ( true ) // 内側
        {
            break ;
        }
}

continue ;

int main()
{
    while ( true )
    {
        continue ;
    }

    do
    {
        continue ;
    } while ( true ) ;

    for ( int i = 0 ; true ; ++i )
    {
        continue ; // for文の式である++iが評価される。
    }
}

int main()
{
    while ( true ) // 外側
        while ( true ) // 内側
        {
            continue ;
        }

}

return 式opt ;
return 初期化リスト ;

int f()
{
    return 0 ; // OK
    return ; // エラー、戻り値がない
}

struct C
{
    C() { return ; }
    ~C() { return ; }
} ;

void f() { return ; }

void f()
{
    return ; // OK
    return 0 ; // エラー、関数fは戻り値を返さない
}

void f() { }
void g()
{
    // 関数fの呼び出しの結果は、void
    return f() ;
}

void f()
{
// 値を返さないreturn文が書かれた場合と同じ
}

// 値を返す関数
int f( bool b )
{
    if ( b ) 
    { return 0 ; }
// bがfalseの場合の挙動は未定義
}

int main()
{
// return 0 ;が書かれた場合と同じ
}

std::initializer_list<int> f()
{
    return { 1, 2, 3 } ;
}

struct List
{
    List( std::initializer_list<int> ) { }
} ;

List g()
{
    return { 1, 2, 3 } ;
}

// コピーとムーブが可能なクラス
struct C
{
    C() = default ; // デフォルトコンストラクター
    C( C const & ) = default ; // コピーコンストラクター
    C( C && ) = default ; // ムーブコンストラクター
} ;

C f()
{
    C c ;
    // 一時オブジェクトが生成される場合、コピーかムーブが行われる。
    return c ; 
// なぜならば、ローカル変数はreturn文の実行後、破棄されるので、ムーブしても構わないからである。
}

goto 識別子 ;

int main()
{
label : ; // labelという名前のラベル文

    goto label ;
}

ストレージクラス指定子（Storage class specifiers）

ストレージクラス指定子には、register、static、thread_local、extern、mutableがある。

ひとつの宣言の中には、ひとつのストレージクラス指定子しか書く事はできない。つまり、ストレージクラス指定子同士は、組み合わせて使うことができない。ただし、thread_localだけは、staticやexternと併用できる。

// グローバル名前空間のスコープ
thread_local int global_variable ;

// 名前の付いている名前空間のスコープ
namespace perfect_cpp
{
    thread_local int variable ;
}

// ブロックスコープ
void f()
{
// 以下の3行は、すべてthread_localかつstaticな変数である。
    thread_local int a ;
    thread_local static int b ;
    static thread_local int c ;
}

struct C
{
// 以下の2行は、すべてthread_localなstaticデータメンバーである。
    static thread_local int a ;
    thread_local static int b ;
} ;

struct C
{
    // エラー、thread_localは非staticデータメンバーには適用できない。
    thread_local int a ;
} ;

// 翻訳単位 1
thread_local int value ;

// 翻訳単位 2
extern thread_local int value ;

// 翻訳単位 2
extern int value ; // エラー、thread_localが指定されていない

struct C
{
    // staticデータメンバー
    static int data ;
    // staticメンバー関数
    static void f() {}
} ;

int main()
{
    // 変数、static変数になる
    static int x ;

    // 無名union、static変数になる
    static union { int i ; float f ; } ;
}

// グローバル名前空間スコープ
// 内部リンケージの指定
static int x ;
static void f() {} 

// 無名名前空間を使う
namespace
{
    int x ;
    void f() {}
}

// 変数
extern int i ;
// 関数
extern void f() ;

class C
{
private:
    mutable int value ;

public :
    void f() const
    {
        // 変更できる
        value = 0 ;
    }
} ;

int main()
{
    C c ;
    c.f() ;
}

関数指定子（Function specifiers）

関数指定子（Function specifier）には、inline、virtual、explicitがある。

// インライン関数
inline void f() { }

struct C
{
    // 関数定義、インライン関数である
    void f() {}
    // 関数の宣言、インライン関数である
    inline void g() ;
    // 関数の宣言、インライン関数ではない
    void h() ;
} ;

// 関数C::gの定義
inline void C::g() { }

// 関数C::hの定義
void C::h() { }

// 外部リンケージを持つ
inline void f() {}
// 内部リンケージを持つ
inline static void g() {}

// 翻訳単位 1
// translation_unit_1.cpp

// 外部リンケージを持つインライン関数の定義
inline void f() {}
inline void g() {}

// 翻訳単位 2
// translation_unit_2.cpp

// 宣言だけ
inline void f() ;

// 定義
inline void g() {}

// 関数の宣言
int main()
{
    // エラー
    // この翻訳単位に関数fの定義がない
    f() ; 

    // OK、定義もある
    g() ;
}

// 宣言
inline void f() ;

int main()
{
    // すでに名前fは宣言されていて、この翻訳単位に定義がある
    f() ; // OK
}

// 定義
inline void f() {} 

typedef指定子（The typedef specifier）

typedef指定子は、型の別名を宣言するための指定子である。この別名のことを、typedef名（typedef-name）という。typedef名は、型と同じように扱われる。

typedef int integer ;
// これ以降、typedef名integerは、int型とおなじように使える。

integer main()
{
    integer x = 0 ;
    integer y = x ;
}

typedef名は、エイリアス宣言（alias-declaration）で宣言することもできる。

using 識別子 = 型名 ;

using integer = int ;

エイリアス宣言では、usingキーワードに続く識別子が、typedef名となる。typedef指定子によって宣言されたtypedef名と、エイリアス宣言によって宣言されたtypedef名は、全く同じ意味を持つ。そのため、本書で「typedef名」と記述されている場合、それはtypedef指定子による宣言であろうと、エイリアス宣言による宣言であろうと、等しく適用される。一方、「typedef指定子」と記述されている場合、エイリアス宣言には当てはまらない。

エイリアス宣言の文法は、typedefより分かりやすい。例えば、関数ポインターの別名を宣言したいとする。

// 同じ意味
typedef void (*type)(void) ;
using type = void (*)(void) ;

typedef指定子は、指定子であるので、単純宣言と同じ文法で名前を宣言しなければならない。using宣言は、名前を先に書き、その後に、純粋な型名を書くことができる。

エイリアス宣言とテンプレートについては、テンプレートエイリアスを参照。

typedef指定子は、クラス以外の同じスコープ内で、同じ型のtypedef名を再宣言することができる。

typedef int I ;
typedef int I ; // OK、同じ型の再宣言
typedef short I ; // エラー、型が違う

void f()
{
    typedef short I ; // OK、別のスコープなので別の宣言
}

struct Class_Scope
{
    typedef int type ;
    typedef int type ; // エラー、クラススコープ内では、同じ型でも再宣言できない
} ;

typedef名とconstの関係は、一見して分かりにくい。

typedef int * type ;

// aの型はint const *
const int * a ; 
// bの型は、int * const 
const type b ; 

これは、指定子と宣言子との違いによる。

const int // 指定子
* a // 宣言子
;

const type // 指定子、typeの型は int *
b // 宣言子
;

変数aの場合、const intへのポインター型となる。変数bの場合、const type型となる。typeの型は、int *なので、int *へのconst型となる。そのため、違う型となる。

friend指定子（The friend specifier）

friend指定子については、friendを参照。

constexpr指定子（The constexpr specifier）

constexpr指定子は、constexprの制約を満たした、変数の定義、関数と関数テンプレートの宣言、staticデータメンバーの宣言に対して指定できる。

constexpr int value = 0 ;

constexpr指定子を使って定義され、定数式で初期化された変数は、定数式として使うことができる。

void f()
{
    constexpr std::size_t size = 10 ;
    int a[size] ;
}

constexpr指定子を使う変数の型は、リテラル型でなければならない。

struct literal
{
    int a ;
} ;

struct non_literal
{
    non_literal() { }
} ;

int main()
{
    constexpr literal a{} ; // OK
    constexpr non_literal b{} ; // エラー
}

コンストラクター以外の関数にconstexpr指定子を記述すると、その関数は、constexpr関数(constexpr function)となる。コンストラクターにconstexpr指定子を記述すると、そのコンストラクターは、constexprコンストラクター(constexpr constructor)となる。constexpr関数とconstexprコンストラクターは暗黙にinlineになる。

constexpr関数の定義は、以下の条件を満たさなければならない。

• virtual関数でないこと
• 戻り値の型がリテラル型であること
• 仮引数の型がリテラル型であること

• 関数の本体は、= deleteか、= defaultか、複合文であること。

  複合文として使える文は、以下のものだけである。

  • null文
  • static_assert宣言
  • typedef宣言とエイリアス宣言で、クラスやenumを定義しないもの
  • using宣言
  • usingディレクティブ
  • return文ひとつ
• 戻り値を初期化する際のコンストラクター呼び出しや、暗黙の型変換は、すべて定数式でなければならない。

以下は合法なconstexpr関数の例である。

constexpr int f()
{
    return 1 + 1 ;
}

constexpr int g( int x, int y )
{
    return x + y + f() ;
}

constexpr int h( unsigned int n )
{
    return n == 0 ? 0 : h( n - 11 ) ;
}

以下は、constexpr関数の制約を満たさない誤ったコードの例である。

// エラー、使えない文の使用
constexpr int f( )
{
    constexpr int x = 0 ;
    return x ;
}

// エラー、使えない文の使用
constexpr int g( bool b )
{
    if ( b )
        return 1 ;
    else
        return 2 ;
}

// エラー、return文がふたつ
constexpr int h()
{
    return 0 ;
    return 0 ;
}

// エラー、戻り値の型がリテラル型ではない
struct S{ S(){ } } ;
constexpr S i()
{
    return S() ;
}

C++11のconstexpr関数の制約はとても厳しい。C++14では、この制約は大幅に緩和される。

constexprコンストラクターの定義は、仮引数の型がリテラルでなければならない。関数の本体は、= deleteか、= defaultか、複合文でなければならない。複合文は以下の制約を満たさなければならない。

• クラスはvirtual基本クラスを持たないこと
• 関数の本体は関数tryブロックではないこと

• 関数の本体の複合文は、以下のいずれかしか含まないこと

  • null文
  • static_assert宣言
  • typedef宣言とエイリアス宣言で、クラスやenumを定義しないもの
  • using宣言
  • usingディレクティブ
• クラスの非staticデータメンバーと、基本クラスのサブオブジェクトは、すべて初期化されること
• 非staticデータメンバーと基本クラスのサブオブジェクトの初期化に関わるコンストラクターは、constexprコンストラクターであること

• 非staticデータメンバーに指定された初期化句は定数式であること

  struct S
  {
      int member = 0 ; // 定数式であること
  
      constexpr S() { }
  } ;
  

• コンストラクターの実引数を仮引数の型に変換する際の型変換は、定数式であること

constexprコンストラクターは、ユーザー定義の初期化を記述したリテラル型のクラスを書くことができる。

struct point
{
    int x ;
    int y ;

    constexpr S( int x, int y )
        : x(x), y(y)
    { }
} ;

このようなリテラル型のクラスは、constexpr指定子を使った変数で使える。

constexpr S s( 10, 10 ) ;

どのような実引数（無引数関数も含む）を与えても、constexprが定数式にならない場合、エラーとなる。

// OK、定数式になる実引数がある
constexpr int f( bool b )
{
    return b ? throw 0 : 0 ;
}

// エラー、絶対に定数式にならない。
constexpr int g( )
{
    throw ;
}

constexpr関数テンプレートや、クラステンプレートのconstexprメンバー関数のインスタンス化された特殊化が、constexpr関数の制約を満たさない場合、そのような関数やコンストラクターは、constexpr関数、constexprコンストラクターとはみなされない。

template < typename T >
constexpr T f( T x )
{
    return x ;
}

struct non_literal { non_literal(){ } } ;

int main()
{
    f( 0 ) ; // OK、constexpr関数

    non_literal n ;
    f( n ) ; // OK、ただし通常の関数
}

constexpr関数を呼び出した結果の値は、同等だがconstexprではない関数を呼び出した結果の値と等しくなる。

コンストラクターを除く非staticメンバー関数にconstexpr指定子を使うと、そのメンバー関数はconst修飾される。

struct S
{
    constexpr int f() ; // constになる
} ;

これは、以下のように書くのと同等である。

constexpr int f() const ;

constexpr指定子は、これ以外には関数の型に影響を与えない。

constexpr非staticメンバー関数を持つクラスは、リテラル型でなければならない。

// OK、リテラル型
struct literal
{
    constexpr int f() { return 0 ; }
} ;

// エラー、リテラル型ではない
struct non_literal
{
    non_literal() { }
    constexpr int f() { return 0 ; }   
} ;

constexpr指定子が変数定義に使われた場合、変数はconstになる。変数の型はリテラル型でなければならず、また初期化されなければならない。

constexpr int a = 0 ;

// エラー、初期化されていない
constexpr int b ;


struct non_literal { non_literal() { } } ;
// エラー、リテラル型ではない
constexpr non_literal c{ } ;

初期化にコンストラクター呼び出しが行われる場合、コンストラクター呼び出しは定数式でなければならない。

型指定子（Type specifiers）

型指定子（type specifier）には、クラス指定子、enum指定子、単純型指定子（simple-type-specifier）、複雑型指定子（elaborated-type-specifier）、typename指定子、CV修飾子（cv-qualifier）がある。

クラス指定子はクラスで、enum指定子はenumの宣言で、typename指定子は、テンプレートの名前解決を参照。

型指定子は、一部を除いて、宣言の中にひとつだけ書くことができる。組み合わせることのできる型指定子は、以下の通りである。

constは、const以外の型指定子と組み合わせることができる。volatileは、volatile以外の型指定子と組み合わせることができる。

signedとunsignedは、char, short, int, longを後に書くことができる。

shortとlongは、intを後に書くことができる。

longは、doubleを後に書くことができる。longは、longを後に書くことができる。

long double a = 0.0l ;
long long int b = 0 ;

const int a = 0 ;
volatile int b = 0 ;
const volatile int c = 0 ;

const int d ; // エラー、初期化子がない

int main()
{
    int x = 0 ; // 非constなオブジェクト
    x = 0 ; // 変更できる

    int const & ref = x ; // 参照する
    ref = 0 ; // エラー、変更できない
}

// signed int
signed a = 0 ;
// unsigned int
unsigned b = 0 ;

// short int
short a = 0 ;
// long int
long b = 0 ;
// long long int
long long c = 0 ;

struct StructName { } ;
class ClassName { } ;
union UnionName { } ;
enum struct EnumName { value } ;

int main()
{
    {
        // 複雑型指定子
        struct StructName a ;
        class ClassName b ;
        union UnionName c ;
        enum EnumName d = EnumName::value ;
    }

    {
        // 単純型指定子
        StructName a ;
        ClassName b ;
        UnionName c ;
        EnumName d = EnumName::value ;
    }
}

class Name { } ;
struct Name a ; // OK、structキーワードでもよい

enum Name b ; // エラー、キーワードが不一致
union Name c ; // エラー、キーワードが不一致

auto a = 0 ; // int
auto b = 0l ; // long
auto c = 0.0 ; // double
auto d = 0.0l ; // long double

int f() { return 0 ; }

bool g(int){ return true ; }
char g(double){ return 'a' ; }

int main()
{
    auto a = f() ; // int

    // もちろん、オーバーロード解決もされる
    auto b = g(0) ; // bool
    auto c = g(0.0) ; // char

    auto d = &f ; // int (*)(void)
}

#include <vector>
#include <string>

int main()
{
    std::vector< std::string > v ;
    // 型名が長くて面倒
    std::vector< std::string >::iterator iter1 = v.begin() ;

    // 簡潔に書ける
    auto iter2 = v.begin() ;
}

template < typename T1, typename T2 > struct Add { } ;
template < typename T1, typename T2 > struct Sub { } ;

template < typename T1, typename T2 >
Add< T1, T2 > operator + ( T1, T2 )
{
    typedef Add< T1, T2 > type ;
    return type() ;    
}

template < typename T1, typename T2 >
Sub< T1, T2 > operator - ( T1, T2 )
{
    typedef Sub< T1, T2 > type ;
    return type() ;    
}

struct A { } ;
struct B { } ;

int main()
{
    A a ; B b ;
    auto result = a + b - b + (b - a) ;
}

Add< Sub< Add< A, B>, B>, Sub< B, A> > result = a + b - b + (b - a) ;

auto u = expr ;

template < typename U > void f( U u ) ;

// std::initializer_list<int>
auto a = { 1, 2, 3 } ;
// std::initializer_list<double>
auto b = { 1.0, 2.0, 3.0 } ;

// エラー、型を推定できない
auto c = { 1, 2.0 } ;
auto d = { } ;

// OK、明示的なキャスト
auto e = std::initializer_list<int>{ 1, 2.0 } ;
auto f = std::initializer_list<int>{ } ;

void f() { }

int main()
{
    int a[1] ;
    auto t1 = a ; // int *
    auto t2 = f ; // int (*)(void)
}

int const expr = 0 ; // exprの型はint const
auto a = expr ; // int
auto const b = expr ; // int const
auto const & c = expr ; // int const &
auto const * d = &expr ; // int const *

static auto e = expr ; // static指定子付きのint型の変数

auto & x = 0 ; // エラー

int main()
{
    int x = 0 ;

    int && r1 = x ; // エラー、rvalueリファレンスをlvalueで初期化できない

    auto && r2 = x ; // OK、ただし、r2の型はint &
    auto && r3 = std::move(x) ; // OK、r3の型はint &&
}

template < typename U >
void f( U && u ) { }

int main()
{
    int x = 0 ;

    f( x ) ; // Uはint &
    f( std::move(x) ) ; // Uはint &&
}

auto a ; // エラー、初期化子がない
auto b = b ; // エラー、初期化子の中で宣言しようとしている変数名が使われている

// std::initializer_list<int>
auto a = { 1, 2, 3 } ;

void f() { }
auto (*p)() -> void = &f ;

auto a = 0, & b = a, * c = &a ;

int x = 0 ;
auto a = x, * b = &x ; // OK、autoに対して推定される型は同じ
auto c = 0, d = 0.0 ; // エラー、型が同じではない

auto int x = 0 ; // エラー、C++11には存在しない昔の機能

decltype ( 式 )

int main()
{
    decltype( 0 ) x ; // xの型はint
    decltype( x ) y ; // yの型はint

    int const c = 0 ;
    decltype( c ) z = 0 ; // zの型はint const
}

int x = 0 ;

decltype( x ) t1 = x ; // t1の型はint
decltype( (x) ) t2 = x ; // t2の型はint &

int x ;
decltype( x ) * ptr ; // int *
decltype( x ) const & const_ref = x ; // int const &

struct C
{
    typedef int type ;
} ;

int main()
{
    C c ;
    decltype(c)::type x = 0 ; // int
}

struct Base { } ;
Base base ;

struct Derived
    : decltype(base) // decltypeを基本クラスとして指定
{
    Derived()
        : decltype(base) () // メンバー初期化子
    { }
} ;

struct C { } ;

int main()
{
    C c ;
    c.~decltype(c)() ; // 疑似デストラクターの呼び出し
}

unscoped enum

enum指定子:
    enum 識別子opt enum基底opt { 列挙子リスト }

enumというキーワードだけで宣言するenumのことを、unscoped enumという。unscoped enumは、弱い型付けのenumを宣言、定義する。enumの定義は、それぞれ別の型を持つ。列挙子リストとは、コンマで区切られた識別子である。各列挙子には、=に続けて定数を指定することで、値を指定できる。これをenumの初期化子という。ただし、列挙子自体はオブジェクトではない。enumは先頭の列挙子に初期化子がない場合、値は0になる。先頭以外の列挙子に初期化子がない場合、そのひとつ前の列挙子の値に、1を加算した値になる。

// a = 0, b = 1, c = 2
enum E { a, b, c } ;

// a = 3, b = 4, c = 5
enum E { a = 3, b = 4 , c = 5 } ;

// a = -5, b = -4, c = -3
enum E { a = -5, b, c } ;

// a = 0, b = 1, c = 0, d = 1
enum E { a, b, c = 0, d } ;

宣言した列挙子は、次の列挙子から使うことができる。

// a = 0, b = 0, c = 5, d = 3
enum E { a, b = a, c = a + 5, d = c - 2 } ;

enum名とunscoped enumの列挙子は、enum指定子があるスコープで宣言される。

enum GlobalEnum { a, b } ;

GlobalEnum e1 = a ;
GlobalEnum e2 = b ;

int main()
{
    enum LocalEnum { c, d } ;
    LocalEnum e1 = c ;
    LocalEnum e2 = d ;
}

unscoped enumによって宣言された列挙子は、整数のプロモーションによって、暗黙的に整数型に変換できる。整数型は、明示的なキャストによって、enum型に変換できる。整数型の値が、enum型の表現できる範囲を超えていた場合の挙動は、未定義である。

enum E { value = 123 } ;

void f()
{
    int x = value ; // enum Eからintへの暗黙の型変換

    E e1 = 123 ; // エラー、intからenum Eへの暗黙の型変換はできない
    E e2 = static_cast<E>(123) ; // intからenum Eへの明示的なキャスト
}

// コマンドの種類を表す定数
enum Command { copy, cut, paste } ;

// コマンドを処理する関数
void process_command( Command id )
{
    switch( id )
    {
        case copy :
            // 処理
            break ;
        case cut :
            // 処理
            break ;
        case paste :
            // 処理
            break ;

        default :
            // エラー処理
            break ;
    }
}

クラスのスコープ内で宣言された列挙子の名前は、クラスのメンバーアクセス演算子（::, ., ->）を使うことによって、参照することができる。

struct C
{
    enum { value } ;
    // クラススコープのなかでは名前のまま参照できる
    void f() { value ; }
} ;

int main()
{
    C::value ; // ::による参照
    C c ;
    c.value ; // .による参照
    C * p = &c ;
    p->value ; // ->による参照
}

unscoped enumは、識別子を省略することができる。

// 識別子あり
enum E { a } ;

// 識別子なし
enum { b } ;

scoped enum

scoped enumは、強い型付けをするenumである。

enum struct 識別子 enum基底opt { 列挙子リスト } ;
enum class 識別子 enum基底opt { 列挙子リスト } ;

scoped enumは、enum structかenum classという連続した二つのキーワードによって宣言する。enum structとenum classは、全く同じ意味である。どちらを使ってもよい。enumには、クラスのようなアクセス指定はない。scoped enumの識別子は省略できない。列挙子リストの文法は、unscoped enumと変わらない。

enum struct scoped_enum_1 { a, b, c } ;
enum class scoped_enum_2 { a, b, c } ;

scoped enumは、非常に強い型付けを持っている。列挙子は、scoped enumが宣言されているスコープに導入されることはない。かならず、enum名に::演算子をつけて参照しなければならない。

enum struct E { value } ;

value ; // エラー、scoped enumの列挙子は、このように参照できない
E::value ; // OK

このため、同じスコープ内で、同じ名前の列挙子を持つ、複数のscoped enumを宣言することもできる。

void f()
{
    // scoped enumの場合
    enum struct Foo { value } ;
    enum struct Bar { value } ; // OK

    Foo::value ; // enum struct Fooのvalue
    Bar::value ; // enum struct Barのvalue
}

void g()
{
    // unscoped enumの場合
    enum Foo { value } ;
    enum Bar { value } ; // エラー、すでにvalueは宣言されている。
}

scoped enumの列挙子は、暗黙的に整数型に変換することはできない。明示的にキャストすることはできる。整数型からenumへの変換は、unscoped enumと変わらない。つまり、明示的なキャストが必要である。

enum struct E { value = 123 } ;

int x = E::value ; // エラー、scoped enumの列挙子は暗黙的に変換できない
int y = static_cast<int>( E::value ) ; // OK、明示的なキャスト

E e = static_cast<E>( 123 ) ; // OK、unscoped enumと同じ

ただし、switch文の中のcaseラベルや、非型テンプレート実引数では、scoped enumも使うことができる。

enum struct E { value } ;
template < int N > struct C { } ;

void f( E e )
{
    // switch文のcaseラベル
    switch( e )
    { case E::value : ; }

    // 非型テンプレート実引数
    C< E::value > c ;
}

これが許されている理由は、scoped enumの内部的な値は使わないものの、強い型付けがされた一種のユニークな識別子として、scoped enumを使えるようにするためである。

scoped enumは、強い型付けをするenumである。scoped enumは、列挙子の内部的な値は使わないが、単に名前付きの状態を表すことができる変数が欲しい場合、また、たとえ内部的な値を使うにしても、強い型付けによって、些細なバグを未然に防ぎたい場合などに使うことができる。

enum基底（enum-base）

enum基底:
    : 型指定子

enum型は、内部的には単なる整数型である。この内部的な整数型のことを、内部型（underlying type）という。enum基底（enum-base）は、この内部型を指定するための文法である。enum基底の型は、基本クラスの指定とよく似た文法で指定することができる。enum基底の型指定子は、整数型でなければならない。

enum基底が指定されたenum型の内部型は、enum基底の型指定子の型になる。

enum E : int { } ; // 内部型はint

enum struct Foo : int { } ; // 内部型はint
enum struct Bar : unsigned int { } ; // 内部型はunsigned int

enum Error : float { } ; // エラー、enum基底が整数型ではない

enum基底が省略された場合、scoped enumの内部型は、intになる。

enum struct E { } ; // scoped enumのデフォルトの内部型はint

scoped enumで、int型の範囲を超える値の列挙子を使いたい場合は、明示的にenum基底を指定しなければならない。

unscoped enumのenum基底が省略された場合、内部型は明確に定められることがない。

enum E { } ; // 内部型は定められない。

enumの内部型が定められていない場合、内部型は、enumの列挙子をすべて表現できる整数型になる。その際、どの整数型が使われるかは、実装依存である。どの整数型でも、すべての列挙子を表現できない場合は、エラーとなる。

enum宣言（opaque-enum-declaration）

enum宣言は、正式には、opaque-enum-declarationという。これは、定義をしないenumの宣言である。関数や変数が、定義せずに宣言できるように、enumも、定義せずに宣言することができる。

enum 識別子 enum基底 ;
enum struct 識別子 enum基底opt ;
enum class 識別子 enum基底opt ;

unscoped enumの場合は、必ず定義と一致するenum基底を指定しなければならない。scoped enumの場合は、enum基底を省略した場合、内部型はデフォルトのintになる。ただし、安全のためには、enum宣言と対応するenumの定義には、enum基底を明示的に書いておいたほうがよい。

enum struct Foo : unsigned int ; // 内部型はunsigned int
enum class Bar ; // enum基底が省略された場合、内部型はint

enum E1 : int ; // 内部型はint

enum E2 ; // エラー、unscoped enumの宣言では、enum基底を省略してはならない。

enum宣言によって、宣言のみされたenum名は、通常のenumと同じように使用できる。ただし、列挙子を使うことはできない。なぜならば、列挙子は宣言されていないからだ。

列挙子を使うことができないenum宣言に、何の意味があるのか。enum宣言が導入された背景には、ある種の利用方法では、すべての翻訳単位に列挙子が必要ないこともあるのだ。

無駄な定義を省く

// 翻訳単位 1

enum ID : int { /* 自動的に生成される多数の列挙子 */ } ;

// 翻訳単位 2

enum ID : int ; // enum宣言
void f( ID id ) // IDを引数にとる関数
{
    int x = id ;
    id = static_cast<ID>(0) ;
}

翻訳単位 1で定義されているenumの列挙子は、外部のツールによって、自動的に生成されるものだとしよう。この定義は、かなり頻繁に更新される。もし、翻訳単位 2では、enumの内部的な値が使われ、列挙子という名前付きの定数には、それほど意味が無い場合、この自動的に生成される多数の列挙子は、無駄である。なぜならば、enumが生成されるたびに、たとえ翻訳単位 2のソースコードに変更がなく、再コンパイルが必要ない場合でも、わざわざコンパイルしなおさなければならないからだ。

なぜenumの定義が必要かというと、完全な定義がなければ、enumの内部型を決定できないからである。C++11では、enum基底によって、明示的に内部型を指定できる。これにより、enumを定義せず宣言することができるようになった。

型安全なデータの秘匿

以下のクラスを考える。

// クラスCのヘッダーファイル
// C.h
enum struct ID { /* 自動的に生成される多数の列挙子 */ } ;

class C
{
public :
    // 外部に公開するメンバー

private :
    ID id ;
} ;

さて、このクラスを、複数の翻訳単位で使いたいとする。このクラスには、データメンバーとしてenum型の変数があるが、これは外部に公開しない。クラスの中の実装の都合上のデータメンバーである。enumの列挙子は、外部ツールで自動的に生成されるものとする。

すると、このヘッダーファイルを#includeしているソースファイルは、enumが自動的に生成されるたびに、再コンパイルしなければならない。しかし、このクラスを使うにあたって、enumの定義は必要ないはずである。この場合にも、enum宣言が役に立つ。

// クラスCのヘッダーファイル
// C.h

enum struct ID : int ;

class C { /* メンバー */ } ;

// クラスCのソースコード
// C.cpp

enum struct ID : int  { /* 自動的に生成される多数の列挙子 */ } ;

// メンバーの実装

このようにしておけば、enumの定義が変更されても、クラスのヘッダーファイルを#includeして、クラスを使うだけのソースコードまで、再コンパイルする必要はなくなる。

名前空間の定義（Namespace definition）

inlineopt namespace 識別子 { 名前空間の本体 }

名前空間は、別の名前空間スコープの中か、グローバルスコープに書くことができる。名前空間の本体には、あらゆる宣言を、いくつでも書くことができる。これには、名前空間自身も含まれる。

// グローバルスコープ

namespace NS
{ // NSという名前の名前空間のスコープ
    // 宣言の例
    int value = 0 ;
    void f() { }
    class C { } ;
    typedef int type ;
}// NSのスコープ、ここまで 

int main()
{
    // NS名前空間の中の名前を使う
    NS::value = 0 ;
    NS::f() ;
    NS::C c ; 
    NS::type t ;

    value ; // エラー、名前が見つからない
}

名前空間は、名前の衝突を防ぐために使うことができる。

// グローバルスコープ
int value ;
int value ; // エラー、valueという名前はすでに宣言されている

// OK、名前空間Aのvalue
namespace A { int value ; }
// OK、名前空間Bのvalue
namespace B { int value ; }

int main()
{
    value ; // グローバルスコープのvalue
    A::value ; // 名前空間Aのvalue
    B::value ; // 名前空間Bのvalue
}

グローバル変数として、valueのような、分かりやすくて誰でも使いたがる名前を使うのは、問題が多い。しかし、名前付きの名前空間スコープの中であれば、名前の衝突を恐れずに、気軽に短くてわかりやすい名前を使うことができる。

名前空間は、何度でも定義することができる。

// 最初の定義
namespace NS { int x ; }

// 二度目の定義
namespace NS { int y ; }

名前空間はネストできる。

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

int main()
{
    A::B::C::value ; // Aの中の、Bの中の、Cの中のvalue
}

inline namespace NS { int value ; }

namespace Outer
{
    inline namespace Inner
    {
        int value ;
    } 
}

int main()
{
    value ; // NS::value
    NS::value ;

    Outer::value ; // Outer::Inner::value
    Outer::Inner::value ;
}

namespace { }

namespace
{
    int x ; // 内部リンケージ
}

namespace NS
{
    void f() ; // 関数fの宣言
    namespace Inner
    {
        void g() ; // 関数gの宣言
        void h() ; // 関数hの宣言
    }
    void Inner::g() { } // 関数gの定義
}

void NS::f() { } // 関数fの定義
void NS::Inner::h() { } // 関数hの定義

名前空間エイリアス（Namespace alias）

namespace 識別子 = 名前空間の名前 ;

名前空間エイリアス（Namespace alias）とは、名前空間の名前の別名を定義する機能である。

名前空間は、名前の衝突を防いでくれる。しかし、名前空間の名前自体が衝突してしまうこともある。それを防ぐためには、名前空間の名前には、十分にユニークな名前をつけなければならない。しかし、衝突しない名前をつけようとすると、どうしても、短い名前をつけることはできなくなってしまう。

namespace Perfect_cpp
{
    int x ;
}

int main()
{
   Perfect_cpp::x = 0 ;
}

この例では、十分にユニークな名前、Perfect_cppを使っている。このため、xという名前の変数名でも、衝突を恐れず使うことができる。しかし、このPerfect_cppは長い上に、大文字とアンダースコアを使っており、タイプしづらい。そこで、名前空間エイリアスを使うと、別名を付けることができる。

namespace Perfect_cpp { int x ; }

int main()
{
    namespace p = Perfect_cpp ;
    p::x ; // Perfect_cpp::x
}

ネストされた名前にも、短い別名をつけることができる。

namespace Perfect_cpp { namespace Library { int x ; } }

int main()
{
    namespace pl = Perfect_cpp::Library ;
    pl::x ; // Perfect_cpp::Library::x
}

別名の別名を定義することもできる。

namespace Long_name_is_Looooong { }
namespace long_name = Long_name_is_Looooong ;
namespace ln = long_name ;

同じ宣言領域で、別名と名前空間の名前が衝突してはならない。

namespace A { } namespace B { }

// エラー、同じ宣言領域では、別名と名前空間の名前が衝突してはならない
namespace A = B ;

int main()
{
    // OK、別の宣言領域なら可
    namespace A = B ;
}

using宣言（The using declaration）

using 識別子 ;

using宣言は、宣言が書かれている宣言領域に、指定した名前を導入する。これにより、明示的に名前空間名と::演算子を使わなくても、その宣言領域で、名前が使えるようになる。

using宣言を、名前空間のメンバーに使う場合、using宣言が書かれているスコープで、::演算子による明示的なスコープの指定なしに、その名前を使うことができる。

namespace NS { int name ; }

int main()
{
    name = 0 ; // エラー、名前nameは宣言されていない

    using NS::name ;
    name = 0 ; // NS::nameと解釈される
    NS::name = 0 ; // 明示的なスコープの指定
}

// ブロックスコープ外でもusing宣言は使える
using NS::name ;

using宣言は、テンプレート識別子を指定することはできない。テンプレート名は指定できる。

namespace NS
{
    template < typename T > class C { } ;
}

int main()
{
    using NS::C ; // OK、テンプレート名は指定できる
    using NS::C<int> ; // エラー、テンプレート識別子は指定できない
}

using宣言は、名前空間の名前を指定することはできない。

namespace NS { }
using NS ; // エラー

using宣言は、scoped enumの列挙子を指定することはできない。

namespace NS
{
    enum struct E { scoped } ;
    enum { unscoped } ;
}

int main()
{
    using NS::unscoped ; // OK、unscoped enumの列挙子
    using NS::E::scoped ; // エラー、scoped enumの列挙子は指定できない
}

using宣言は、その名の通り、宣言である。したがって、通常通り、外側のスコープの名前を隠すこともできる。usingディレクティブとは、違いがある。

int name  ; // グローバルスコープのname
namespace NS { int name ; } // NS名前空間のname

int main()
{
    // ここではまだ、名前が隠されてはいない
    name = 0 ; // ::nameを意味する

    using NS::name ; // このusing宣言は::nameを隠す
    name = 0 ; // NS::nameを意味する
}

using宣言は、宣言された時点で、すでに宣言されている名前を、スコープに導入する。宣言場所から見えない名前は、導入されない。

namespace NS { void f( int ) { } }
// void NS::f(int)をグローバルスコープに導入する
// void NS::f(double)は、この時点では宣言されていないので、導入されない
using NS::f ; 
namespace NS { void f( double ) { } }

int main()
{
    // この時点で、unqualified名fとして名前探索されるのは
    // void NS::f(int)のみ
    f( 1.23 ) ; // NS::f(int)を呼ぶ。

    using NS::f ; // void NS::f(double) をmain関数のブロックスコープに導入する
    f( 1.23 ) ; // オーバーロード解決により、NS::f(double)を呼ぶ
}

ただし、テンプレートの部分的特殊化は、プライマリークラステンプレートを経由して探すので、たとえusing宣言の後に宣言されていたとしても、発見される。

namespace NS
{
    template < typename T >
    class C { } ;
}

using NS::C ;

namespace NS
{
    template < typename T >
    class C<T * > { } ; // ポインター型への部分的特殊化
}

int main()
{
    C<int * > c ; // 部分的特殊化が使われる。
}

using宣言は、コンストラクターの継承に使うこともできる。詳しくは、該当の項目を参照。ここでは、クラスのメンバー宣言としてusing宣言を使う際の、文法上の注意事項だけを説明する。

クラスのメンバー宣言としてusing宣言を使う場合、基本クラスのメンバー名を指定しなければならない。名前空間のメンバーは指定できない。using宣言は、基本クラスのメンバー名を、派生クラスのスコープに導入する。

namespace NS { int value ; }

class Base
{
public :
    void f() { } 
} ;

class Derived : private Base
{
public :
    using Base::f ; // OK、基本クラスのメンバー名
    using NS::value ; // エラー、基本クラスのメンバーではない
} ;

クラスのメンバー宣言としてのusing宣言は、基本クラスのメンバーの名前を、クラスのメンバーの名前探索で発見させることができる。

struct Base { void f( int ) { } } ;
struct Derived1 : Base
{
    void f( double ) { }
} ;
struct Derived2 : Base
{
    using Base::f ;
    void f( double ) { }
} ;

int main()
{
    Derived1 d1 ;
    d1.f( 0 ) ; // Derived::f(double)を呼ぶ
    Derived2 d2 ;
    d2.f( 0 ) ; // Base::f(int)を呼ぶ
}

Derived1::fは、Base::fを隠してしまうので、Base::fはオーバーロード解決の候補関数に上がることはない。Derived2では、using宣言を使って、Base::fをDerived2のスコープに導入しているので、オーバーロード解決の候補関数として考慮される。

また、using宣言は、基本クラスのメンバーのアクセス指定を変更する目的でも使える。

class Base
{
    int value ;
public :
    int get() const { return value ; }
    void set( int value ) { this->value = value ; }
} ;

// Baseからprivateで派生
class Derived : private Base
{
public : // Base::getのみpublicにする
    using Base::get ;
} ;

この例では、DerivedはBaseからprivate派生している。ただし、Base::getだけは、publicにしたい。そのような場合に、using宣言が使える。

using宣言でクラスのメンバー名を指定する場合、クラスのメンバー宣言でなければならない。クラスのメンバー宣言以外の場所で、using宣言にクラスのメンバー名を指定してはならない。

struct C
{
    int x ;
    static int value ;
} ;

int C::value ;

using C::x ; // エラー、これはクラスのメンバー宣言ではない
using C::value ; // エラー、同上

usingディレクティブ（Using directive）

using namespace 名前空間名 ;

usingディレクティブ（using directive）は、その記述以降のスコープにおける非修飾名前探索に、指定された名前空間内のメンバーを追加するための指示文である。usingディレクティブを使うと、指定された名前空間内のメンバーを、::演算子を用いないで使用できる。

namespace NS
{
    int a ;
    void f() { }
    class C { } ;
}

int main()
{
    using namespace NS ;

    a = 0 ; // NS::a
    f() ; // NS::f
    C c ; // NS::C
}

usingディレクティブを使えば、指定された名前空間内のすべてのメンバーを、明示的な::演算子を使わずにアクセスできるようになる。

usingディレクティブは、名前空間スコープとブロックスコープ内で使用することができる。クラススコープ内では使用できない。

namespace A { typedef int type ; }

void f()
{
    // ブロックスコープ内
    using namespace A ;
    type x ; // A::type
}

namespace B
{
    // 名前空間スコープ
    using namespace A ;
    type x ; // A::type
}

other_namespace::type g1 ; // A::type

// 名前空間スコープ（グローバルスコープ）
using namespace A ;
type g2 ; // A::type

class C
{
    using namespace A ; // エラー、クラススコープ内では使用できない
} ;

グローバルスコープにusingディレクティブを記述するのは推奨できない。特に、ヘッダーファイルのグローバルスコープにusingディレクティブを記述すると、非常に問題が多い。名前空間の本来の目的は、名前の衝突を防ぐためである。usingディレクティブは、名前空間という仕組みに穴を開けるような機能だからだ。

しかし、usingディレクティブは必要である。たとえば、非常に長い名前空間名や、深くネストした名前空間内の多数のメンバーを使う場合、いちいち::演算子で明示的にスコープを指定したり、using宣言でひとつひとつ宣言していくのは、非常に面倒である。あるブロックスコープで、名前が衝突しないということが保証できるならば、usingディレクティブを使っても構わない。

namespace really_long_name { namespace yet_another_long_name
{
    int a ; int b ; int c ; int d ;  
} }

void f()
{
    // このスコープでは、a, b, c, dという名前は衝突しないと保証できる
    using namespace really_long_name::yet_another_long_name ;
    a = 0 ; b = 0 ; c = 0 ; d = 0 ;
}

usingディレクティブは、宣言ではない。usingディレクティブは、非修飾名前探索に、名前を探すべき名前空間を、特別に追加するという機能を持っている。したがって、usingディレクティブは、名前を隠さない。以下の例はエラーである。using宣言と比較すると、違いがある。

int name  ; // グローバルスコープのname
namespace NS { int name ; } // NS名前空間のname

int main()
{
    // ここではまだ、名前が隠されてはいない
    name = 0 ; // ::nameを意味する

    using namespace NS ; // 名前探索にNS名前空間内のメンバーを追加
    name = 0 ; // エラー、::nameとNS::nameとで、どちらを使うべきか曖昧
}

usingディレクティブは、非修飾名前探索にしか影響を与えない。ADLには影響を与えない。

namespace NS
{
    struct S { } ;
    namespace inner
    { 
        void f(S) { }
        void g(S) { }
    }

    using inner::f ; // inner::fをNS名前空間に導入する
    using namespace inner ; // 非修飾名前探索に影響をおぼよす
} ;

int main()
{
    NS::S s ;
    f(s) ; // OK
    g(s) ; // エラー、usingディレクティブはADLには影響しない
}

usingディレクティブで探索できるようになった名前は、オーバーロード関数の候補にもなる。

void f( int ) { } 
namespace NS { void f( double ) { } }

int main()
{
    // この時点では、NS::fは名前探索で発見されない
    f( 1.23 ) ; // ::f(int)

    using namespace NS ; // NS名前空間のメンバーがunqualified名前探索で発見されるようになる
    f( 1.23 ) ; // オーバーロード解決により、NS::f( double )
}

usingディレクティブは、unqualified名前探索のルールを変更するという、非常に特殊な機能である。usingディレクティブは、確実に名前が衝突しないブロックスコープ内で使うか、あるいは、オーバーロード解決をさせるので、同じ関数名を複数、意図的に名前探索で発見させる場合にのみ、使うべきである。

アライメント指定子(alignment specifier)

アライン(align)やアライメント(alignment)とは、ある型のオブジェクトを構築するストレージのアドレスに、制約を指定する機能である。

アライメント指定子は、通常の[[ ]] のようなアトリビュートの文法を使わない。alignasというキーワードが与えられている。当初、アライメントを指定する機能は、アトリビュートの文法を使う予定だったが、アライメント指定のような基本的な機能には、独自のキーワードが与えられるべきだという合意がなされたため、独自のキーワードが与えられた。指定子と名前はついているものの、アライメント指定子が現れることができる箇所の文法は、アトリビュートの文法に基づいている。

アライメント指定子は、変数とクラスのデータメンバーに指定できる。書ける場所は、宣言の前がわかりやすい。

// OK
alignas(16) char buf[16] ;

struct S
{
// OK
    alignas(16) char buf[16] ;
} ;

ただし、ビットフィールド、関数の仮引数、例外宣言、registerストレージクラス指定子つきで宣言された変数には指定できない。

struct S
{
// エラー、ビットフィールド
    alignas(4) unsigned int data:16 ;
} ;

// エラー、関数の仮引数
void f( alignas(4) int x ) ;

void g()
{
    try { }
// エラー、例外宣言
    catch ( alignas(4) int x ) { }
}

アライメント指定子は、クラスの宣言や定義に適用することもできる。書ける場所は、クラスキーの後、クラス名の前である。

struct alignas(16) S ;
struct alignas(16) S { } ;

同様に、アライメント指定子は、enumの宣言や定義にも適用することができる。

enum struct alignas(16) E1 : int
{ value } ;
enum alignas(16) E2
{ value } ;

アライメント指定子にエリプシス(...)を適用したものは、パック展開である。

template < typename ... Types >
struct alignas( Types ... ) // パック展開
S { } ;

アライメント指定子には、二種類の形がある。alignas( )の括弧の中身が、コンマで区切られた代入式という形と、コンマで区切られた型という形だ。

// 代入式
alignas( 4, 8, 16 ) char b1[128] ;
// 型
alignas( short, int, long ) char b2[128] ;

アライメント指定子がalignas(代入式)の形の場合、

• 代入式は整数定数式でなければならない
• 定数式が拡張アライメントであり、実装がそのアライメントをその文脈でサポートしている場合は、宣言されたエンティティのアライメントは、指定されたアライメントになる
• 定数式が拡張アライメントであり、実装がそのアライメントをその文脈でサポートしていない場合、エラーとなる
• 定数式がゼロだと評価された場合、アライメント指定子の効果はなくなる

これ以外の場合、エラーとなる。

// OK
constexpr std::size_t f() { return 4 ; }
alignas( f() ) char b1[128] ;

// エラー
int g() { return 4 ; }
alignas( g() ) char b2[128] ;

// 実装がサポートしている場合OK
// 実装がサポートしていなければエラー
alignas( alignof(std::max_align_t) * 2 ) char b3[128] ;

// OK、ただしアライメント指定の効果なし
alignas( 0 ) char b4[128] ;

アライメント指定子が、alignas(型名)の場合、alignas( alignof(形名) )と同等の効果になる。

// alignas( alignof(int) )と同等
alignas( int ) int x ;

ひとつのエンティティに複数のアライメントが指定された場合、最も厳格なアライメント要求になる。

// もし、実装が16のアライメント要求をサポートしている場合
// アライメント要求は16
alignas( 4, 8, 16 ) char b[128] ;

アライメント指定子が、宣言されるエンティティのアライメント要求より緩いアライメントを指定すると、エラーとなる。

// Sの最低のアライメント要求は8
struct alignas(8) S { } ;

// エラー、Sの最低のアライメント要求より緩い
alignas(4) S s ;

あるエンティティの定義である宣言にアライメント指定子がある場合、同じエンティティの定義ではない宣言は、同等のアライメントを指定するか、アライメント指定子なしでなければならない。

struct alignas(8) S { } ;

struct S ; // OK
struct alignas(8) S ; // OK


struct alignas(4) S ;   // エラー、同等ではない
struct alignas(16) S ;  // エラー、同等ではない

もし、エンティティの宣言のどれかひとつにでもアライメント指定子があった場合、そのエンティティの定義となる宣言にも、同等のアライメントを指定しなければならない。

struct S { } ; // エラー、アライメント指定つきの宣言がある
struct alignas(4) S ; 

noreturnアトリビュート(Noreturn attribute)

アトリビュートトークン、noreturnは、関数がreturnしないことを指定する。このアトリビュートは、関数宣言の宣言子idに適用できる。

// この関数は決してreturnしない
[[ noreturn ]] void f()
{
// なぜならば、必ずthrowするからだ
    throw 0 ;
}

noreturnは、宣言中に一度しか現れてはならない。noreturnを指定する関数は、その最初に現れる宣言にこのアトリビュートを適用しなければならない。

void f() ; // エラー、最初の宣言だがnoreturnがない
[[ noreturn ]] void f() ;

もし、ある関数が、ある翻訳単位ではnoreturnが指定され、別の翻訳単位では指定されていない場合、エラーとなる。

noreturnを指定した関数からreturnした場合、挙動は未定義である。例外によって抜けるのは問題がない。

ポインター（Pointers）

宣言子が以下のように記述されている場合、ポインターを意味する。

* CV修飾子opt 識別子

int * a ; // intへのポインター型

*に続くCV修飾子は、ポインター型に対するCV修飾子として解釈される。

int * constは、指定子intへのポインターに対するconstである。intに対するconstではない。const int *とint const *はどちらも同じ型である。const intもint constも指定子だからだ。

typedef const int * type1 ;
typedef int const * type2 ;
typedef int * const type3 ;

このように宣言されている場合、type1とtype2は同じ型である。type3は、type1やtype2とは別の型である。

宣言子の中に、ポインターは複数書くことができる。

int obj ;
int * p = &obj ;
int * * pp = &p ;
int * * * ppp = &pp ;

int const * * a ; // int const *へのポインター
int * const * b ; // int * constへのポインター
int * * const c = nullptr ; // int *へのconstなポインター

T * *という型は、T *へのポインターということになる。

リファレンスへのポインターは存在しない。

int & * ptr_to_ref ; // エラー、リファレンスへのポインターは存在しない

ビットフィールドのアドレスを取得することは禁止されているので、ビットフィールドへのポインターも存在しない。

関数へのポインターや、配列へのポインターは存在する。ただし、記述がやや難しい。コードの可読性を上げるために、これらの型や変数を宣言するには、typedefやエイリアス宣言、autoなどを使うという手もある。

void func( void ) { } // 型はvoid (void)

void g()
{
    void (*ptr_func)( void ) = &func ;
    ptr_func() ; // 関数呼び出し

    int array[5] ; // 型はint [5]
    int (*ptr_array)[5] = &array ;
}

リファレンス（References）

宣言子が以下のように記述されている場合、リファレンスを意味する。

& 識別子
&& 識別子

&の場合、lvalueリファレンスとなり、&&の場合、rvalueリファレンスとなる。lvalueリファレンスとrvalueリファレンスは、ほとんど同じ働きをする。単にリファレンスといった場合、lvalueリファレンスとrvalueリファレンスの両方を指す。

void f( int obj )
{
    int & lvalue_reference = obj ;
    int && rvalue_reference = static_cast< int && >( obj ) ;

    lvalue_reference = 0 ; // objに0を代入
    rvalue_reference = 0 ; // objに0を代入
}

リファレンスは、CV修飾できない。

void f( int obj )
{
    int const & a = obj ; // OK、int constへのリファレンス
    int & const b = obj ; // エラー、リファレンスへのCV修飾はできない
}

ただし、typedefやテンプレート実引数にCV修飾子が使われた場合は、単に無視される。

// typedefの例
void f( void )
{
    int const & a = 3 ; // OK、int constへのリファレンス
    typedef int & type ;
    typedef const type type2 ; // type2の型はint &
    const type b = 3 ; // エラー、bの型はint &
}

// テンプレート実引数の例
template < typename T >
struct S
{
    typedef const T type ; 
} ;

void g()
{
    typedef S< int & >::type type ; // type はint &
}

typedefの例では、typeというtypedef名にconst修飾子が使われているが、これは単に無視される。したがって、bの型は、int &である。int & constとはならないし、int const &ともならない。

テンプレートの例では、テンプレート仮引数Tの実際の型が決定されるのは、テンプレート実引数が渡されて、インスタンス化されたときである。

void型へのリファレンスは存在しない。

typedef void & type ; // エラー

リファレンスへのリファレンス、リファレンスの配列、リファレンスへのポインターは存在しない。

typedef int & & type1 ; // エラー、リファレンスへのリファレンス
typedef int & type2[5] ;   // エラー、リファレンスの配列
typedef int & * type3 ;     // エラー、リファレンスへのポインター

その他の型へのリファレンスは存在する。例えば、配列へのリファレンスや、関数へのリファレンスは存在する。ただし、ポインターと同じく、記述がやや難しい。

void func( void ) { } // 型はvoid (void)

void g()
{
    void (&ref_func)( void ) = func ;
    ref_func() ; // 関数呼び出し

    int array[5] ; // 型はint [5]
    int (&ref_array)[5] = array ;
}

リファレンスの宣言には、初期化子が必要である。

void f()
{
    int obj ;

    int & ref1 ; // エラー、初期化子がない
    int & ref2 = obj ; // OK
}

ただし、宣言がextern指定子を含む場合、クラスのメンバーの宣言である場合、関数の仮引数や戻り値の型の宣言である場合は、初期化子は必要ない。

int obj ;

// クラスの例
struct S
{
    int & ref ;
    S() : ref(obj) { }
} ;

// extern指定子の例
// このリファレンスは単なる宣言。
// 実体はどこか別の場所で定義されている
extern int & external_ref ;

// 関数の仮引数と戻り値の型の例
int & f( int & ref ) { return ref ; }

リファレンスは必ず、有効なオブジェクトか関数を参照していなければならない。nullリファレンスというものはあり得ない。なぜならば、nullリファレンスを作る方法というのは、nullポインターを参照することである。nullポインターを参照することは、それ自体が未定義動作となるので、規格の上では、合法にnullリファレンスを作ることはできない。

void f()
{
    int * ptr = nullptr ;
    int & ref = *ptr ; // エラー、nullポインターを参照している
}

リファレンスのリファレンスは存在しないということはすでに述べた。ただし、見かけ上、リファレンスが重なるという場合が存在する。

typedef、テンプレート仮引数の型、decltype指定子が、Tへのリファレンス型であるとする。リファレンスというのは単なるリファレンスであり、lvalueリファレンスとrvalueリファレンスの両方を含む。その場合、この型に対するlvalueリファレンスを宣言した場合、Tへのlvalueリファレンスになる。一方、この型に対するrvalueリファレンスを宣言した場合、Tへのリファレンス型になる。

これはどういうことかというと、すでにリファレンス型であるtypedef、テンプレート仮引数、decltype指定子に対して、さらにリファレンスの宣言子を付け加えるという意味である。もし、この型に対して、lvalueリファレンスを宣言しようとした場合、元のリファレンス型の如何に関わらず、lvalueリファレンスとなる。rvalueリファレンスを宣言しようとした場合、元のリファレンス型になる。

int main()
{
    typedef int & lvalue_ref ; // lvalueリファレンス
    typedef int && rvalue_ref ; // rvalueリファレンス

    // lvalueリファレンスを宣言しようとした場合
    // 元のリファレンス型が、lvalueリファレンスでもrvalueリファレンスでも、lvalueリファレンスになる
    typedef lvalue_ref & type1 ; // int &
    typedef rvalue_ref & type2 ; // int &

    // rvalueリファレンスを宣言しようとした場合
    // 元のリファレンス型になる
    typedef lvalue_ref && type3 ; // int &
    typedef rvalue_ref && type4 ; // int &&
}

換言すれば、lvalueリファレンスは優先され、rvalueリファレンスは無視されるということである。

リファレンスが、内部的にストレージを確保するかどうかは規定されていない。したがって、memcpyなどをつかい、リファレンスを他のストレージの上にコピーすることはできない。

メンバーへのポインター（Pointers to members）

宣言子が以下のように記述されている場合、メンバーへのポインターを意味する。

::opt ネストされたクラス名 * CV修飾子opt 識別子

struct S
{
    void func(void) { }
    int value ;
} ;

void ( S:: * ptr_func )( void ) = &S::func ;
int S:: * ptr_value = &S::value ;

メンバーへのポインターは、クラスのstaticなメンバーを参照することはできない。また、リファレンス型のメンバーを参照することもできない。

struct S
{
    static void func(void) { }
    static int value ;
    int & ref ;
} ;
int S::value ;

void ( S:: * p1 )( void ) = &S::func ; // エラー
void ( *p2 )(void) = &S::func ; // OK
int S:: * p3 = &S::value ; // エラー

メンバーへのポインターは、ポインターとは異なる型である。staticメンバー関数へのポインターは、メンバー関数ポインターではなく、通常の関数ポインターである。

配列（Arrays）

宣言子が以下のように記述されている場合、配列を意味する。

識別子 [ 定数式opt ] 

int a[5] ; // 要素数5のint型の配列
float b[123] ; // 要素数123のfloat型の配列

型指定子と、配列以前の宣言子を合わせた型を、配列の要素型（element type）という。要素型は、void以外の基本型、ポインター型、メンバーへのポインター型、クラス、enum型、配列型でなければならない。要素型には、リファレンス型、void型、関数型、抽象クラスは使えない。

int a[5] ; // void以外の基本型

int * b[5] ; // ポインター型

struct S { int value ; } ;
int S::*c[5] ; // メンバーへのポインター型

S d[5] ; // クラス

enum struct E{ value } ;
E e[5] ; // enum型

配列に対する配列を作ることができる。これを、多次元配列（multidimensional array）という。

int a[3][5][7] ;

ここでは、aは3 × 5 × 7の配列である。詳しく言うと、aは要素数3の配列である。その各要素は、要素数5の配列である。その各要素は、要素数7のint型の配列である。

配列の定数式は、整数の定数式でなければならない。また、その値は、0より大きくなければならない。

int a[0] ; // エラー
int b[-1] ; // エラー

定数式は、配列の要素数を表す。今、定数式の値がNであるとすると、配列の要素数はN個であり、0からN-1までの数字を持って表される。その配列のオブジェクトは、連続したストレージ上に、N個の要素型のサブオブジェクトを持っていることになる。

int main()
{
    constexpr int N = 5 ;
    int a[N] ; // 要素数5の配列
    a[0] = 0 ; // 最初要素
    a[4] = 0 ; // 最後の要素
}

配列の定数式が省略された場合、要素数の不明な配列となる。これは不完全なオブジェクト型である。多次元配列の場合は、最初の配列の定数式のみ省略できる。

定数式の省略された配列は、不完全なオブジェクト型なので、不完全なオブジェクト型の使用が許可されている場所で使うことができる。

typedef int a[] ; 
typedef int b[][5][7] ; // 最初の定数式のみ省略可

また、関数の仮引数の型として使うことができる。

void f( int parameter[] ) { }

ただし、関数の仮引数の場合、型は、要素型への配列ではなく、要素型へのポインターに置き換えられる。詳しくは、宣言子の関数を参照。

宣言に初期化子がある場合、配列の定数式を省略できる。この場合、要素数は、初期化子から決定される。

int a[] = { 1, 2, 3 } ; // 型はint [3]

詳しくは、初期化子のアグリゲートを参照。

関数（Functions）

識別子 ( 仮引数リスト ) CV修飾子opt リファレンス修飾子opt 例外指定opt

int f( int ) ; // int型の引数を取り、int型の戻り値を返す関数
int * f( int, int ) ; // int型の引数とint型の引数を取り、int *型の戻り値を返す関数

識別子 ( 仮引数リスト ) CV修飾子opt リファレンス修飾子opt 例外指定opt -> 戻り値の型

auto f( int ) -> int ; // int型の引数を取り、int型の戻り値を返す関数
auto f( int, int ) -> int * ; // int型の引数とint型の引数を取り、int *型の戻り値を返す関数

// 関数fの宣言
int f( int ) ;
// 同じ関数fの再宣言
auto f( int ) -> int ;

template < typename T1, typename T2 >
??? multiply( T1 t1, T2 t2 )
{
    return t1 * t2 ;
}

struct Mass { } ;
struct Acceleration { } ;
struct Force { } ;
// ニュートンの運動方程式、F=ma
Force operator *( Mass, Acceleration ) { return Force() ; }

int main()
{
    Mass m ; Acceleration a ;
    Force f = multiply( m, a ) ;
}

int main()
{
    Mass m ; Acceleration a ;
    typedef decltype( m * a ) type ; // Force
}

template < typename T1, typename T2 >
decltype( t1 * t2 ) // エラー、t1とt2は宣言されていない
multiply( T1 t1, T2 t2 )
{
    return t1 * t2 ;
}

template < typename T1, typename T2 >
auto multiply( T1 t1, T2 t2 ) -> decltype( t1 * t2 )
{
    return t1 * t2 ;
}

void f( int i, float f, double d, char const * c ) ;

// 引数を取らない関数
void f( ) ;
// 同じ意味
void f( void ) ;

// OK、関数fの宣言、仮引数の名前がない
void f( int ) ;
// OK、同じ関数fの宣言、仮引数に名前がある
void f( int x ) ; 

// OK、同じ関数fの定義
void f( int x )
{
    x ; // 仮引数を表す
}

void f( int ) { /* 実引数を使えない */ }

int main()
{
    f( 0 ) ; // 実引数を渡すことには変わりない。
}

// 型はvoid (int, int)
void f( int foo, int bar ) ;
// 同じ関数fの宣言
void f( int bar, int foo ) ; 

// 同じ関数fの定義
void f( int hoge, int /*名前の省略*/ ) { }

// 仮引数リスト：int
void f( int ) ;
// 仮引数リスト：int *, int *
void f( int *, int * ) ;

// void ( int * )
void f( int [3] ) ;
// void ( int * )
void g( int [] ) ;

// void ( void (*)(int) )
void h( void ( int ) ) ;

void f( int array[5] )
{
// arrayの型は int *である。int [5]ではない
}

void g( void func( int ) )
{
// funcの型は、void (*)(int)である。void (int)ではない
}

// void (int)
void f( const volatile int ) ;
// void (int const *)
void g( int const * const ) ;

// void (int)
void h( const int x )
{
// 関数の本体では、xの型はconst int
}

// void ( int *, int * )
void f( int a[10], decltype(a) b)  ;
// void ( int, int const * ) ;
void g( int const a, decltype(a) * b)  ;

// void (int)
void f( register int ) ; 

struct S
{
    // void S::f(void)
    void f() ;
    // void S::f(void) const
    void f() const ;
} ;

struct S
{
    // void S::f(void) &
    void f() & ; 
    // void S::f(void) &&
    void f() && ;

    // リファレンス修飾子が省略された関数
    void g() ;
} ;

// void f(int)
void f( int param = 0 ) noexcept ;

// エラー
auto f() -> void (void);
auto f() -> int [5] ;

// OK、ポインター
auto f() -> void (*)(void) ;
auto f() -> int (*)[5] ;
// OK、リファレンス
auto f() -> void (&)(void) ;
auto f() -> int (&)[5] ;

デフォルト実引数（Default arguments）

仮引数に対して、=に続けて式が書かれていた場合、その式は、デフォルト実引数として用いられる。デフォルト実引数は、関数呼び出しの際に、実引数が省略された場合、かわりに引数として渡される。

void f( int x = 123, int y = 456 ) { }

int main()
{
    f( ) ; // f( 123, 456 )と同じ
    f( 0 ) ; // f( 0, 456 )と同じ
    f( 1, 2 ) ; // デフォルト実引数を使用しない
}

式は、単にリテラルでなくてもよい。

int f() { return 0 ; }
void g( int x = f() ) { }

関数の呼び出しの際に、前の実引数を省略して、あとの実引数を指定することはできない。

void f( int x = 123, int y = 456 ) { }
int main()
{
    f( , 0 ) ; // エラー
}

デフォルト実引数は、関数のパラメーターパックに指定することはできない。

template < typename ... Types >
void f( Types .. args = 0 ) ; // エラー

デフォルト実引数は、後から付け加えることも出来る。ただし、再宣言してはいけない。たとえ同じ式であったとしても、再宣言はできない。

void f( int ) ;
// OK、デフォルト実引数を付け加える
void f( int x = 0 ) ;
// エラー、デフォルト実引数の再宣言
void f( int x = 0 ) ; 
// 定義
void f( int x ) { }

可読性のためには、デフォルト実引数は、関数の最初の宣言に記述すべきである。

void f( int = 0 ) ; // 宣言
void f( int ) { } // 定義

デフォルト実引数が使われる場合、式は、関数呼び出しの際に、毎回評価される。評価の順序は規定されていない。

default定義（Explicitly-defaulted functions）

関数の宣言 = default ;

関数の宣言に続けて、= default ;と書く関数の定義を、明示的にデフォルト化された関数（Explicitly-defaulted functions）という。本書では、default定義と呼ぶ。

明示的にデフォルト化された関数は、特別なメンバー関数でなければならない。また、暗黙的に定義された場合と同等の型でなければならない。デフォルト実引数と例外指定は使えない。

明示的なデフォルト化は、暗黙の定義と同等の定義を、明示的に定義するための機能である。

struct S
{
    S() = default ; // default定義
    S(int){ } 
} ;

この例では、もし、明示的なデフォルト化が書かれていない場合、Sのデフォルトコンストラクターは、暗黙的に定義されない。

明示的にデフォルト化された関数と、暗黙的に定義される関数とをあわせて、デフォルト化された関数（defaulted function）という。

delete定義（Deleted definitions）

関数の宣言 = delete ;

関数の宣言に続けて、= delete ; と書く関数の定義を、削除された定義（Deleted definitions）という。また、本書では、分かりやすさのため、delete定義と呼ぶ。

削除された関数定義は、宣言として存在しているが、定義のない関数である。宣言としては存在しているので、名前解決やオーバーロード解決、テンプレートのインスタンス化の際には、通常通り考慮される。

ただし、削除された関数定義を、宣言以外の方法で参照した場合、エラーとなる。参照というのは、明示的、暗黙的に関数を呼び出すことや、関数へのポインター、メンバーポインター、リファレンスを得ることなどである。また、たとえ未評価式の中であっても、参照した場合エラーとなる。

// 削除された関数の定義
void f() = delete ;

void f() ; // OK、宣言はできる

int main()
{
    f() ; // エラー、削除された関数の呼び出し
    &f ; // エラー、削除された関数のポインターを得ようとしている
    void (& ref )(void) = f ; // エラー、削除された関数のリファレンスを得ようとしている
    typedef decltype(f) type ; // エラー、未評価式の中で、削除された関数を参照している
}

削除された関数の定義は、関数の最初の宣言でなければならない。

void f() ; // 削除された定義ではない
void f() = delete ; // エラー、最初の宣言でなければならない

void g() = delete ; // OK、最初の宣言
void g() ; // OK、再宣言

ただし、関数テンプレートの特殊化の場合、最初の特殊化の宣言となる。

template < typename T >
void f( T ) { } // primary template

// 特殊化
template < >
void f<int>(int) = delete ;

int main()
{
    f(0) ; // エラー
    f(0.0) ; // OK
}

関数がオーバーロードされている場合、オーバーロード解決によって、削除された関数定義が参照される場合のみ、エラーとなる。

void f( int ) {} // 削除されていない関数
void f( double ) = delete ; // 削除された関数定義

int main()
{
    f( 0 ) ; // OK、void f(int)は削除されていない
    f( 0.0 ) ; // エラー、削除された関数の参照
}

関数のオーバーロード、関数テンプレート、削除された定義を組み合わせると、非常に面白い事ができる。

template < typename T >
void f( T ) { }

// 特殊化でdoubleでインスタンス化された場合の定義を削除
template < >
void f<double>(double) = delete ;

void call_f()
{
// doubleでインスタンス化した場合、エラーになる
    f( 0 ) ; // OK
    f( true ) ; // OK
    f( 0.0 ) ; // エラー
}

// あらゆるインスタンス化を削除
template < typename T >
void g( T ) = delete ;

// 削除されていない定義
template < >
void g< double >( double ) { }

void call_g()
{
// double以外でインスタンス化した場合、エラーになる
    g( 0 ) ; // エラー
    g( true ) ; // エラー
    g( 0.0 ) ; // OK   
}

// 非テンプレートな関数
void h( int ) { }

// 関数テンプレートの定義を削除
template < typename T >
void h( T ) = delete ;

void call_h()
{
// intへの標準型変換を禁止
    h( 0 ) ; // OK、非テンプレートな関数を呼び出す
    h( true ) ; // エラー、関数テンプレート
    h( 0.0 ) ; // エラー、関数テンプレート
}

void i( int ) = delete ;
void i( double ) { }

void call_i()
{
// intからdoubleへの標準変換をエラーにする
    i( 0 ) ; // エラー
    i( true ) ; // OK
    i( 0.0 ) ; // OK
}

このように、削除された定義を使うことで、意図しない標準型変換やインスタンス化を阻害できる。

削除された関数定義の具体的な使い方は、実に様々な例が考えられる。ここでは、その一部を挙げる。

クラスのコンストラクターを制御する。

struct Boolean
{
    Boolean( ) = delete ;
    Boolean( bool ) { }

    template < typename T >
    Boolean( T ) = delete ;
} ;

int main()
{
    Boolean a = true ; // OK
    Boolean b = 123 ; // エラー
    Boolean c = &a ; // エラー
}

Booleanクラスは、必ず、ひとつのbool型の引数で初期化しなければならない。このクラスの初期化の際に、bool以外の型を渡すと、テンプレートのインスタンス化とオーバーロード解決により、関数テンプレート版のコンストラクターが優先される。しかし、定義は削除されているため、エラーとなる。結果的に、暗黙の型変換を禁止しているのと同じ意味となる。そのため、意図しない数値やポインターでの初期化という、つまらないバグを防げる。

クラスのオブジェクトをnewで生成することを禁止する。

struct Do_not_new
{
    void *operator new(std::size_t) = delete;
    void *operator new[](std::size_t) = delete;
} ;

int main()
{
    Do_not_new a ; // OK
    Do_not_new * ptr = new Do_not_new ; // エラー
    Do_not_new * array_ptr = new Do_not_new[10] ; // エラー
}

何らかの理由で、あるクラスのオブジェクトを、newで生成してほしくないとする。削除された定義を使えば、あるクラスに対して、newを禁止できる。

クラスのコピーを禁止する。

struct move_only
{
    move_only() = default ;
    ~move_only() = default ;

    move_only( const move_only & ) = delete ;
    move_only( move_only && ) = default ;
    move_only & operator = ( const move_only & ) = delete ;
    move_only & operator = ( move_only && ) = default ;
} ;

int main()
{
    move_only m ;
    move_only n ;

    n = m ; // エラー、コピーは禁止されている
    n = std::move(m) ; // OK、ムーブはできる
}

クラスmove_onlyは、ムーブができるが、コピーはできないクラスになる。

ゼロ初期化（zero-initialize）

ゼロ初期化（zero-initialize）とは、T型のオブジェクトやリファレンスに対して、

Tがスカラー型の場合、整数の定数、0を、T型に変換して初期化する。

static int x ; // 0で初期化される
static float f ; // 0がfloat型に変換されて初期化される
static int * ptr ; // 0がnullポインターに変換されて初期化される

Tがunionではないクラス型の場合、非staticなデータメンバーと基本クラスのサブオブジェクトが、それぞれゼロ初期化される。また、アライメント調整などのための、オブジェクト内のパディングも、ゼロビットで初期化される。

struct Base { int x ; } ;
struct Derived : Base
{
    int y ;
} ;

// 非staticなデータメンバー、基本クラスのサブオブジェクトが、それぞれゼロ初期化される
static Derived d ;

この例では、Derivedのデータメンバーであるyと、基本クラスであるBaseのオブジェクトがゼロ初期化される。Baseをゼロ初期化するということは、Baseのデータメンバーであるxもゼロ初期化される。

Tがunion型の場合、オブジェクトの最初の、非staticな名前のつけられているデータメンバーが、ゼロ初期化される。また、アライメント調整などのための、オブジェクト内のパディングも、ゼロビットで初期化される。

union U
{
    int x ;
    double d ; 
} ;

このunionのオブジェクトをゼロ初期化した場合、U::xがゼロ初期化される。

Tが配列型の場合、各要素がそれぞれゼロ初期化される。

Tがリファレンス型の場合、初期化は行われない。

デフォルト初期化（default-initialize）

デフォルト初期化（default-initialize）とは、T型のオブジェクトに対して、

Tがクラス型の場合、Tのデフォルトコンストラクターが呼ばれる。デフォルトコンストラクターにアクセス出来ない場合は、エラーである。

class A
{
public :
    A() { }
} ;

class B
{
private :
    B() { }
} ;

int main()
{
    A a ; // デフォルトコンストラクターが呼ばれる
    B b ; // エラー、デフォルトコンストラクターにアクセスできない
}

Tが配列型の場合、各要素がそれぞれデフォルト初期化される。

上記以外の場合、初期化は行われない。

int main()
{
    int x ; // 初期化は行われない
}

const修飾された型をデフォルト初期化する場合、型はユーザー定義コンストラクターを持つクラス型でなければならない。

struct X { } ;
struct Y { Y() { } } ;

int main()
{
    int const a ; // エラー、intはユーザー定義コンストラクターを持つクラス型ではない
    X const b ; // エラー、Xはユーザー定義コンストラクターを持つクラス型ではない

    Y const c ; // OK
}

リファレンス型をデフォルト初期化しようとした場合、エラーになる。

値初期化（value-initialize）

値初期化（value-initialize）とは、T型のオブジェクトに対して、

Tがクラス型で、ユーザー提供のコンストラクターを持つ場合、Tのデフォルトコンストラクターが呼ばれる。デフォルトコンストラクターにアクセス出来ない場合は、エラーである。

struct S
{
    S() { }
    int x ; 
} ;

クラスSのオブジェクトを値初期化した場合、Sのデフォルトコンストラクターが呼ばれる。xの値は不定である。

Tが、unionではないクラス型で、ユーザー提供のコンストラクターを持たない場合、オブジェクトはゼロ初期化される。もし、暗黙的に定義されたコンストラクターが、トリビアルではない場合、コンストラクターが呼ばれる。

struct A
{
    A() { }
} ;

struct B
{
// ユーザー提供のコンストラクターがない
// 暗黙に定義されたコンストラクターはトリビアルではない
    A a ;
    int x ;
} ;

クラスBのオブジェクトを値初期化した場合、Aのデフォルトコンストラクターが呼ばれる。また、xはゼロ初期化される。

Tが配列型の場合、各要素がそれぞれ値初期化される。

上記以外の場合、オブジェクトはゼロ初期化される。

リファレンス型をゼロ初期化しようとした場合、エラーとなる。

初期化の文法と方法

staticストレージの期間を持つオブジェクトは、プログラムの開始時に、必ずゼロ初期化される。その後、必要であれば、初期化される。

struct S
{
    S() : x(1) { }
    int x ;
} ;

S s ; // staticストレージの期間を持つオブジェクト

ここでは、Sのデフォルトコンストラクターが実行される前に、データメンバーのxはゼロ初期化されている。

初期化子が空の括弧、()、であるとき、オブジェクトは値初期化される。ただし、通常の宣言文では、初期化子として空の括弧を書く事はできない。なぜならば、空の括弧は、関数の宣言であるとみなされるからだ。

int main()
{
    int x() ; // int (void)型の関数xの宣言
}

初期化子としての空の括弧は、new、関数形式の明示的型変換、基本クラスとデータメンバーの初期化子で使うことができる。

struct S
{
    S()
    : x() // メンバー初期化子
    { }
    int x ;
}

int main()
{
    new int() ; // new、初期化子として空の括弧
    int() ; // 関数形式のキャスト
}

初期化子が指定されていない場合、オブジェクトはデフォルト初期化される。

struct S { } ;

int main()
{
    S s ; // デフォルト初期化される
}

デフォルト初期化では、すでに説明したように、クラス以外の型は、初期化が行われない。初期化が行われないオブジェクトの値は、不定である。

int main()
{
    int i ; // 値は不定
    double d ; // 値は不定
}

ただし、staticやthreadストレージの有効期間を持つオブジェクトは、ゼロ初期化されることが保証されている。

// グローバル名前空間
int x ; // staticストレージ、ゼロ初期化される
thread_local int y ; // threadストレージ、ゼロ初期化される

以下のような文法の初期化子を、コピー初期化（copy-initialization）という。

T x = a ;

これに加えて、関数の実引数を渡す、関数のreturn文、例外のthrow文、例外を受ける、アグリゲートのメンバーの初期化も、コピー初期化という。この「コピー」という言葉は、コピーコンストラクターやコピー代入演算子とは関係がない。コピー初期化でも、コピーではなく、ムーブされることもある。

以下のような文法の初期化子を、直接初期化（direct-initialization）という。

T x(a) ;
T x{a} ;

これに加えて、new、static_cast、関数形式のキャスト、基本クラスとデータメンバーの初期化子も、直接初期化という。

初期化子の意味は、以下のように決定される。オブジェクトの型を、目的の型（destination type）とし、初期化子の型を、元の型（source type）とする。元の型は、初期化子が、ひとつの初期化リストか、括弧で囲まれた式リストの場合は、存在しない。

// 目的の型はT
// 元の型はint
T x = 0 ;

// 目的の型はT
// 元の型は存在しない（ひとつの初期化リスト）
T x = { } ;
T x({ }) ;
T x{ } ;

// 目的の型はT
// 元の型は存在しない（括弧で囲まれた式リスト）
T x(1, 2, 3)

初期化子が、ひとつの初期化リストの場合、リスト初期化される。

// リスト初期化される
T x = { } ;
T x({ }) ;
T x{ } ;

目的の型がリファレンスの場合、リファレンスを参照。

目的の型が、char、signed char、unsigned char、char16_t、char32_t、wchar_tの配列で、初期化子が文字列リテラルの場合、文字配列を参照。

初期化子が空の()の場合、オブジェクトは値初期化される。

ただし、通常の変数の宣言では、空の()を書く事はできない。なぜならば、空の括弧は、関数の宣言とみなされるからだ。

// int (void)型の関数xの宣言
// int x(void) ; と同じ
int x() ; 

空の()を書く事ができる初期化子には、関数形式のキャスト、new、メンバー初期化がある。

 // 関数形式のキャスト
int x = int() ;
// new
int * p = new int() ;

// メンバー初期化
class C
{
    int member ;
    C() : member()
    { }
} ;

{}や、空の初期化リストを含む({})は、文法上曖昧とならないので、宣言文でも書ける。詳しくはリスト初期化で解説するが、この場合も、オブジェクトは値初期化される。

int x{} ; // int型の変数xの宣言と定義と初期化子

それ以外の場合で、目的の型が配列型の場合、エラーとなる。これは、初期化子がある場合で、上記のいずれにも該当しない場合を指す。

int a[5] = 0 ; // エラー、int [5]型は、int型で初期化できない

目的の型がクラス型で、初期化子が直接初期化である場合、最も最適なコンストラクターが、オーバーロード解決によって選ばれる。

struct Elem { } ;

struct S
{
    S( int ) { }
    S( Elem ) { }
} ;

int main()
{
    S s1( 0 ) ; // S::S(int)
    S s2( 0.0 ) ; // S::S(int)、標準型変換による

    Elem elem ;
    S s3( elem ) ; // S::S(Elem)
}

コンストラクターが適用できなかったり、曖昧である場合は、エラーとなる。

struct S
{
    S( long ) { }
    S( long long ) { }
} ;

struct Elem { } ;

int main()
{
    S s1( 0 ) ; // エラー、コンストラクターが曖昧
    Elem elem ;
    S s2( elem ) ; // エラー、適切なコンストラクターが見つからない
}

目的の型がクラス型で、初期化子がコピー初期化で、初期化子の型が目的の型か、その派生クラス型である場合、直接初期化と同じ方法で初期化される。初期化子の型が目的の型か、その派生クラス型でない場合は、後述。

struct Base { } ;
struct Derived : Base { } ;

int main()
{
    Base b1 = Base() ; 
    Base b2 = Derived() ;
}

目的の型がクラス型で、初期化子がコピー初期化の場合（ただし上記を除く）、ユーザー定義の型変換が試みられ、最適な候補が、オーバーロード解決によって選ばれる。

struct Elem { } ;
struct Integer
{
    operator int () const { return 0 ; }
} ;

struct S
{
    S( int ) { }
    S( Elem ) { }
} ;

int main()
{
    S s1 = 0 ; // コンストラクターによる変換、S::S(int)
    S s2 = 0.0 ; // 標準型変換の結果、S::S(int)
    S s3 = Elem() ; // コンストラクターによる変換、S::S(Elem)
    S s4 = Integer() ; // Integer::operator int()が呼ばれ、次にS::S(int)
}

型変換できなかったり、型変換が曖昧である場合は、エラーとなる。

struct A { } ;
struct B { } ;

struct C
{
    C( long ) { }
    C( long long ) { }
} ;

int main()
{
    A a ;
    B b = a ; // エラー、変換関数が見つからない
    C c = 0 ; // エラー、変換関数が曖昧
}

それ以外の場合、つまり、目的の型がクラス型ではない場合で、初期化子の型がクラスであった場合、目的の型に型変換が試みられ、最適な候補がオーバーロード解決によって選択される。型変換ができない場合や、曖昧な場合は、エラーとなる。

struct S
{
    operator int() { return 0 ; }
} ;

int main()
{
    S s ;
    int x = s ; // OK、S::operator int()が呼ばれる
}

それ以外の場合、つまり、目的の型も初期化子の型も、クラスではない場合、標準型変換が試みられる。ユーザー定義の変換関数は考慮されない。型変換ができない場合、エラーとなる。

int main()
{
    int i = 0 ;
    float f = i ; // OK、整数から浮動小数点数へ型変換される
    int * p = f ; // エラー、floatはint *に変換できない
}

アグリゲート（Aggregates）

アグリゲート（aggregate）とは、配列か、いくつかの制約を満たしたクラスである。クラスの場合、ユーザー定義のコンストラクター、非staticデータメンバーの初期化子、privateおよびprotectedな非staticデータメンバー、基本クラス、virtual関数が存在しないものだけを、アグリゲートという。

以下は、アグリゲートの例である。

struct Aggregate
{
// 非staticデータメンバーはすべてpublic
    int x ;
    float y ;

// 非virtualなメンバー関数
    void f() { }
// staticデータメンバーはpublicでなくてもよい
private :
    static int data ;
} ;
int Aggregate::data ;

int a[10] ;
Aggregate b ;
Aggregate c[10] ;

以下はアグリゲートの条件を満たさないクラスの例である。

struct Base { } ;

struct NonAggregate
    : Base // 基本クラス
{
// ユーザー定義のコンストラクター
    NonAggregate() { }
// 非staticデータメンバーの初期化子
    int x = 0 ;
// privateおよびprotectedな非staticデータメンバー
private :
    int y ;
protected :
    int z ;
// virtual関数
    virtual void f() { }
} ;

配列は必ずアグリゲートである。たとえアグリゲートではないクラス型であっても、そのクラスの配列型は、アグリゲートとなる。

// アグリゲートではないクラス
struct NonAggregate
{
    NonAggregate() { }
} ;

NonAggregate a[3] ; // アグリゲート

アグリゲートが初期化リストで初期化される場合、初期化リストの対応する順番の要素が、それぞれアグリゲートのメンバーの初期化に用いられる。メンバーはコピー初期化される。

// 配列の例
int a[3] = { 1, 2, 3 } ;
// 各要素の初期化、a[0] = 1, a[1] = 2, a[2] = 3

// クラスの例
struct S
{
    int x ; int y ;
    double d ;
} ;

S s = { 1, 2, 3.0 } ;
// 各メンバーの初期化は、s.x = 1, s.y = 2, s.d = 3.0

// クラスの配列の例
S sa[3] =
{
    { 1, 2, 3.0 },
    s, s
} ;

// アグリゲートではないクラスの配列の例
class C
{
    int value ;
public :
    C(int value) : value(value) { }
} ;

C obj( 3 ) ; // クラスのオブジェクト

// 配列はアグリゲート
C ca[3] = { 1, 2, obj } ;
// コピー初期化を適用した結果、C::C(int)が呼び出される
// ca[0]は1、ca[1]は2、ca[2]はobjで、それぞれ初期化される

初期化の際に、縮小変換が必要な場合、エラーである。

int a( 0.0 ) ; // OK
int b{ 0.0 } ; // エラー、縮小変換が必要

struct S { int x ; } ;
S s = { 0.0 } ; // エラー、縮小変換が必要

初期化リストが、内部に初期化リストを含む場合、アグリゲートの対応するメンバーは、初期化リストによって初期化される。

struct Inner { int x ; int y ;  } ;
struct Outer
{
    int x ;
    Inner obj ;
} ;

Outer a = { 1, { 1, 2 } } ;
// a.x = 1, a.obj = { 1, 2 }
// a.obj.x = 1, a.obj.y = 2

要素数不定の配列のアグリゲートが、初期化リストで初期化される場合、配列の要素数は、初期化リストの要素数になる。

int a[] = { 1 } ; // int [1] 
int b[] = { 1, 2, 3 } ; // int [3]
int c[] = { 1, 2, 3, 4, 5 } ; // int [5]

staticデータメンバーと無名ビットフィールドは、アグリゲートのリスト初期化の際には、メンバーとして考慮されない。つまり、初期化リストの要素の順番などにも影響しない。

struct S
{
    int x ;
    static int static_data_member ; // staticデータメンバー
    int y ;
    int : 8 ; // 無名ビットフィールド
    int z ;
} ;

int S::static_data_member ;

S s = { 1, 2, 3 } ;
// s.x = 1, s.y = 2, s.z = 3

この例では、static_data_memberと、yとzとの間にある無名ビットフィールドは、リスト初期化の際には、メンバーとして考慮されない。

もし、アグリゲートのメンバーよりも、初期化リストの要素の方が多い場合は、エラーとなる。

int a[3] = { 1, 2, 3, 4 } ; // エラー

struct S
{
    int x, int y, int z ;
} ;

S s = { 1, 2, 3, 4 } ; // エラー

もし、アグリゲートのメンバーよりも、初期化リストの要素の方が少ない場合、明示的に初期化されていないアグリゲートのメンバーは、すべて値初期化される。値初期化では、アグリゲートの条件を満たす型はすべて、ゼロ初期化される。したがって、単にゼロで初期化されると考えても差し支えない。

int a[5] = { 1, 2, 3 } ;
// a[0] = 1, a[1] = 2, a[2] = 3
// a[4]とa[5]は、値初期化される

struct S { int x ; int y ; } ;

S s { 1 } ;
// s.x = 1
// s.yは値初期化される

空の初期化リストでは、値初期化される。

// メンバーはすべて値初期化される
int a[5] = { } ;
struct S
{
    int x ; int y ;
} ;

S s = { } ;

既存のコードでは、アグリゲートのすべてのメンバーをゼロ初期化するために、{0}という初期化リストが使われていることがある。

int x[100] = {0} ; // すべてゼロで初期化

これは、C++ではなく、C言語に由来するコードである。C言語では、空の初期化リストを書く事ができない。そのため、Cプログラマは、{0}と書くのである。多くのC++プログラマは、C言語もよく知っているので、既存のコードでは、慣習的に{0}が使われている。しかし、C++では、{0}と書く必要はない。{}で十分である。

アグリゲートが、内部に別のアグリゲートを持っている場合、初期化リストは、その内部のアグリゲートを無視することはできない。

struct SubAggregate { } ;

struct Aggregate
{
    int m1 ;
    SubAggregate s1 ;
    int m2 ;
    SubAggregate s2 ;    
    int m3 ;
    SubAggregate s3 ;    
} ;

SubAggregate s ;

Aggregate a =
{
    1,
    { },// 空の初期化リスト
    2,
    s,// オブジェクトの変数
    3,
    SubAggregate() // 関数形式のキャスト
} ;

このように、内部のアグリゲートに続くメンバーを初期化したい場合は、たとえ空の初期化リストでも、必ず書かなければならない。もちろん、その内部のアグリゲートをコピー初期化できる型の値ならば、なんでも使える。

アグリゲート内のリファレンスのメンバーが、明示的に初期化されなかった場合、エラーとなる。

struct S
{
    int & ref ; // リファレンスのメンバー
} ;

int x ;
S s1 = { x } ; // OK、リファレンスを初期化している
S s2 = { } ; // エラー、リファレンスが初期化されていない

多次元配列は、初期化リストのネストによって初期化することができる。

int a[2][2] = { { 1, 2 }, { 1, 2 } } ;

int b[3][3][3] =
{
    { { 1, 2, 3 }, { 1, 2, 3 }, { 1, 2, 3 } },
    { { 1, 2, 3 }, { 1, 2, 3 }, { 1, 2, 3 } },
    { { 1, 2, 3 }, { 1, 2, 3 }, { 1, 2, 3 } }
} ;

文字配列（Character arrays）

char（signed charとunsigned charも含む）, wchar_t, char16_t, char32_tの配列は、それぞれ、対応する文字列リテラルで初期化できる。

char str[6] = "hello" ;
char utf8_str[6] = u8"hello" ;
wchar_t wide_str[6] = L"hello" ;
char16_t utf16_str[6] = u"hello" ;
char32_t utf32_str[6] = U"hello" ;

文字列リテラルは、null文字を含むということに注意しなければならない。文字列リテラル、"hello"の型は、char const [6]である。

文字配列の要素数が指定されていない場合、初期化子の文字列リテラルの要素数になる。

// 要素数は6
char str[] = "hello" ;

配列の要素数より、文字列リテラルの要素数の方が多い場合、エラーとなる。

char str[5] = "hello" ; // エラー

配列の要素数より、文字列リテラルの要素数の方が少ない場合、明示的に初期化されない要素は、ゼロ初期化される。

// 以下の二行は同等
char str[10] = "hello" ;
char str[10] = { 'h', 'e', 'l', 'l', 'o', '\0', 0, 0, 0, 0 } ;

リファレンス（References）

T &を、「T型へのlvalueリファレンス」という。T &&を、「T型へのrvalueリファレンス」という。これらを二つまとめて、「T型へのリファレンス」という。lvalueリファレンスは、lvalueへのリファレンスであり、lvalueで初期化する。rvalueリファレンスは、rvalueへのリファレンスであり、rvalueで初期化する。そのため、このような名前になっている。

T型へのリファレンスは、T型のオブジェクトか関数、あるいは、T型に変換可能なオブジェクトで初期化できる。

struct Integer
{
    int object ;
    operator int & () { return object ; }
} ;

void f(void) { }

int main()
{
// オブジェクトによる初期化
    int int_object ;
    int & ref_int = int_object ;

// 関数による初期化の例
    void ( &ref_function )(void) = f ;

// int型に変換可能なオブジェクトによる初期化
    Integer integer_object ;
    int & ref_integer = integer_object ;
}

リファレンスは、必ず初期化されなければならない。リファレンスの参照先を変更することはできない。リファレンスは、参照先のオブジェクトと同じように振舞う。

int main()
{
    int x ;
    int & ref = x ;
    ref = 0 ; // x = 0 と同じ
    int y = 0 ;
    ref = y ; // x = y と同じ、参照先は変わらない
}

関数の仮引数、関数の戻り値の型、クラス定義の中のクラスメンバー宣言、extern指定子が明示的に使われている宣言では、リファレンスの初期化子を省略できる。

// 関数の仮引数
void f( int & ) ;

// 関数の戻り値の型
int & g() ;
auto g() -> int & ;

// クラス定義のクラスメンバーの宣言
struct S { int & ref ; } ;

// extern指定子（refは別の場所で定義されている）
extern int & ref ;

もちろん、これらのリファレンスも、使うときには、初期化されていなければならない。

リファレンスの具体的な初期化について説明する前に、リファレンス互換（reference-compatible）を説明しなければならない。ある型、T1とT2があるとする。もし、T1が、T2と同じ型か、T2の基本クラス型であり、T1のCV修飾子が、T2のCV修飾子と同等か、それ以上の場合、T1はT2に対してリファレンス互換である。

一般に、T1がT2に対してリファレンス互換である場合、T1へのリファレンスは、T2へのリファレンスで初期化できる。

// AとBとは、お互いにリファレンス互換ではない
struct A { } ;
struct B { } ;

A a ;
B & r1 = a ; // エラー、リファレンス互換ではない

// BaseはDerivedに対して、リファレンス互換である
// DerivedはBaseに対して、リファレンス互換ではない
// 基本クラスは派生クラスに対してリファレンス互換であるが、
// 派生クラスは基本クラスに対してリファレンス互換ではない
struct Base { } ;
struct Derived : Base { } ;

Base base ;
Derived derived ;

Base & r2 = derived ; // OK
Derived & r3 = base ; // エラー

// Non_const_intはConst_intに対して、リファレンス互換ではない
// Const_intはNon_const_intに対して、リファレンス互換である
// CV修飾子が同じか、それ以上である場合、リファレンス互換である
// CV修飾子が少ない場合、リファレンス互換ではない
typedef int Non_const_int ;
typedef int const Const_int ;

Non_const_int nci ;
Const_int ci ;

Non_const_int & r4 = ci ; // エラー
Const_int & r5 = nci ; // OK

T型へのlvalueリファレンスは、リファレンス互換なlvalueで初期化できる。

struct Base { } ;
struct Derived : Base { } ;

int main()
{
    int object ;
    int & r1 = object ;

    Base base ;
    Base & r2 = base ;
// 派生クラスのlvalueでも初期化できる
    Derived derived ;
    Base & r3 = derived ;

    int const const_object = 0 ;
    // OK
    int const & r5 = const_object ;
    int const volatile & r6 = const_object;
}

基本的に、lvalueリファレンスはlvalueでしか初期化できない。xvalueやprvalueで初期化することはできない。また、CV修飾子を取り除くことはできない。以下はエラーの例である。

#include <utility>

struct A { } ;
struct B { } ;

struct Base { } ;
struct Derived : Base { } ;

int main()
{
// エラー、BはAに対してリファレンス互換ではない
    A a ;
    B & b = a ; 

    int & r1 = 0 ; // エラー、prvalueでは初期化できない
    int x ;
    int & r2 = std::move( x ) ; // エラー、xvalueでは初期化できない

    Base base ;
    Derived & r3 = base ; // エラー、派生クラスは基本クラスに対してリファレンス互換ではない

    int const ci = 0 ;
    int & r4 = ci ; // エラー、CV修飾子が少ないので、リファレンス互換ではない
} ;

T型へのlvalueリファレンスは、リファレンス互換な型のlvalueに暗黙的に変換できるクラス型のオブジェクトで初期化できる。

// int &に暗黙的に変換できるクラス
struct Integer
{
    int object ;
    operator int & () { return object ; }
} ;

int main()
{
    Integer object ;
    int & ref = object ; // OK、暗黙的にリファレンス互換なlvalueに変換できる
} ;

volatileではない、const T型へのlvalueリファレンスは、rvalueでも初期化できる。rvalueとは、prvalueとxvalueである。

#include <utility>

int f() { return 0 ; }

int main()
{
    // OK、prvalueで初期化できる
    int const & r1 = f() ;
    // OK、xvalueで初期化できる
    int object ;
    int const & r2 = std::move( object ) ;

    // エラー、たとえconstでも、volatileであってはならない
    int volatile const & r3 = f() ;
}

volatileではない、const T型へのlvalueリファレンスが、rvalueでも初期化できるというのは、非常に異質なルールである。これは、C++にまだrvalueリファレンスがなかった時代に、リファレンスでrvalueをも参照する必要があったために導入されたルールである。

T型へのrvalueリファレンスは、リファレンス互換なrvalueで初期化できる。rvalueとは、xvalueとprvalueのことである。

#include <utility>

int f() { return 0 ; }

int main()
{
    // OK、prvalueで初期化できる
    int && prvalue_ref = f() ;

    // OK、xvalueで初期化できる
    int object ;
    int && xvalue_ref = std::move( object ) ;
}

rvalueリファレンスは、必ずrvalueで初期化しなければならない。lvalueでは初期化できない。

int object ;
int && ref = object ; // エラー、lvalueでは初期化できない

rvalueリファレンス自体はlvalueであるということに、注意しなければならない。もし、rvalueリファレンスをrvalueリファレンスで初期化したいのならば、明示的にrvalueにしなければならない。

#include <utility>

int f() { return 0 ; }

int main()
{
    int && rvalue_ref = f() ;
    int && r1 = rvalue_ref ; // エラー、rvalue_ref自体はlvalueである。
    int && r2 = std::move( rvalue_ref ) ; // OK、xvalueでの初期化
}

T型へのrvalueリファレンスは、リファレンス互換な型のrvalueに暗黙的に変換できるクラス型のオブジェクトで初期化できる。

#include <utility>

// int &&に暗黙的に変換できるクラス
struct Integer
{
    int object ;
    operator int && () { return std::move(object) ; }
} ;

int main()
{
    Integer object ;
    int && ref = object ; // OK、暗黙的にリファレンス互換なrvalueに変換できる
}

rvalueリファレンスの初期化子が、リテラルの場合、一時オブジェクトが生成され、参照される。

int main()
{
    int && ref = 0 ; // 一時オブジェクトが生成される
}

リスト初期化（List-initialization）

リスト初期化（List-initialization）とは、ひとつの{}で囲まれた初期化子を使ってオブジェクトやリファレンスを初期化することである。このような初期化子を、初期化リスト（Initializer list）という。初期化リストの中の、コンマで区切られた式のことを、初期化リストの要素という。

リスト初期化は、直接初期化でも、コピー初期化でも使える。

T x( { } ) ; // 直接初期化
T x{ } ; // 直接初期化
T x = { } ; // コピー初期化

直接初期化のリスト初期化を、直接リスト初期化（direct-list-initialization）といい、コピー初期化のリスト初期化を、コピーリスト初期化（copy-list-initialization）という。

T x( { } ) ;
T x{ } ;
T x = { } ;

new T{ } ;

#include <initializer_list>

auto f() -> std::initializer_list<int>
{
    return { 1, 2, 3 } ;
}

#include <initializer_list>

void f( std::initializer_list<int> ) { }

int main()
{
    f( { 1, 2, 3 } ) ;
}

#include <initializer_list>

struct S
{
    void operator [] ( std::initializer_list<int> ) { }
} ;

int main()
{
    S s ;
    s[ { 1, 2, 3 } ] ;
}

#include <initializer_list>

struct S
{
    S( std::initializer_list<int> ) { }
} ;

int main()
{
    S s1( { 1, 2, 3 } ) ;
    S s2{ 1, 2, 3 } ;
    S({ 1, 2, 3 }) ; // 関数形式のキャスト
    S{ 1, 2, 3 } ; // 関数形式のキャスト
}

struct S
{
    int m1[3] = { 1, 2, 3 } ;
    int m2[3]( { 1, 2, 3 } ) ;
    int m3[3]{ 1, 2, 3 } ;
} ;

struct S
{
    int data[3] ;
    // 以下二行は同じ意味
    S() : data{ 1, 2, 3 } { }
    S() : data( { 1, 2, 3 } ) { }
} ;

#include <initializer_list>

struct S
{
    S & operator = ( std::initializer_list<int> ) { }
} ;

int main()
{
    S s ;
    s = { 1, 2, 3 } ;
}

// 変換の一例
int x = double(0.0) ; // 縮小変換、doubleからint

// 縮小変換の例
long double ld = 0.0l ;
double d = ld ; // 縮小変換、long doubleからdouble
float f = ld ; // 縮小変換、long doubleからfloat
f = d ; // 縮小変換、doubleからfloat

// 縮小変換の例
int i = 0 ;
double d = i ; // 縮小変換、intからdouble
enum { e } ;
d = e ; // 縮小変換、unscoped enumからdouble

// short型はint型の値をすべて表現できないとする
int i = 0 ;
short s = i ; // 縮小変換

const double cd = 0.0 ; // cdは定数式
float f = cd ; // 縮小変換ではない

const int ci = 0 ; // ciは定数式
double d = ci ; // 縮小変換ではない
short s = ci ; // 縮小変換ではない

int main()
{
    int a =  0.0 ; // OK
    int b = { 0.0 } ; // エラー、縮小変換
    int c{ 0.0 } ; // エラー、縮小変換
    int d( { 0.0 } ) ; // エラー、縮小変換

    // OK、明示的な型変換
    int d{ static_cast<int>(0.0) }  ;
}

#include<initializer_list>

struct S
{
    // 初期化リストコンストラクター
    S( std::initializer_list<int> list ) ;
    // リファレンスでもよい
    S( std::initializer_list<int> & list ) ;
    // CV修飾子付きの型に対するリファレンスでもよい
    S( std::initializer_list<int> const & list ) ;

    // これも初期化リストコンストラクター
    // デフォルト実引数のため
    S( std::initializer_list<int> list, int value = 0 ) ;
    
    // これらは初期化リストコンストラクターではない
    S( int value = 0, std::initializer_list<int>, short value ) ;
    S( std::initializer_list<int>, short value ) ;
} ;

// デフォルトコンストラクターを持つクラス
struct A { } ;

int main()
{
// すべて、値初期化される
    A a1 = { } ;
    A a2{ } ;
    A a3( { } ) ;
}

struct Aggregate
{
    int x ;
    double d ;
    char str[10] ;
} ;
// アグリゲートとして初期化
Aggregate a = { 123, 3.14, "hello" } ;

// エラー、縮小変換が必要。
int a[1] = { 1.0 } ;

// 空のinitializer_list
std::initializer_list<int> a = { } ;
// 要素数3のinitializer_list
std::initializer_list<int> b = { 1, 2, 3 } ;

// std::stringを要素に持つinitializer_list
std::initializer_list< std::string > c = { "hello", "C++", "world" } ;

// エラー、縮小変換が必要
std::initializer_list<int> d = { 0.0 } ;

struct S
{
    S( std::initializer_list<int> ) { }
    S( std::initializer_list<double> ) { }
} ;

int main()
{
    // S::S( std::initializer_list<int> )
    S s1 = { 1, 2, 3 } ;
    S s2{ 1, 2, 3 } ;
    S s3( { 1, 2, 3 } ) ;

    // S::S( std::initializer_list<double> )
    S s4 = { 1.0, 2.0, 3.0 } ;
    S s5{ 1.0, 2.0, 3.0 } ;
    S s6( { 1.0, 2.0, 3.0 } ) ;
}

struct S
{
    S( int, int ) { }
    S( int, double ) { }
} ;

int main()
{
    // S::S( int, int )
    S s1 = { 1, 2 } ;
    // S::S( int, double )
    S s2 = { 1, 2.0 } ;

    // エラー、S::S( int, double )が選ばれるが、縮小変換が必要
    S s3 = { 1.0, 2.0 } ;
}

struct S
{
    S( std::initializer_list<int> ) { }
    S( double ) { }
} ;

int main()
{
    // OK、値初期化される
    S s1 = { } ;
    // エラー、S( std::initializer_list<int> )が選ばれる
    // しかし、縮小変換が必要
    S s2 = { 0.0 } ; 
}

// 条件に一致する例
class C { } ;

C && r1 = { } ; // OK、Tがクラス型へのリファレンス
int && r2 = { } ; // OK、リファレンス型で初期化子が空

// これは条件に一致しない。後の条件を参照
int && r3 = { 0 } ;

struct A
{
    int x ;
} ;

struct B
{
    B( std::initializer_list<int> ) { }
} ;

int main()
{
    A && r1 = { } ;
    A && r2 = { 1 } ;
    B && r3 = { 1, 2, 3 } ;
    int && ref = { } ;
}

// 以下はOK
int && r1 = { } ; // OK、rvalueリファレンス
int const & r2 = { } ; // OK、constかつ非volatileなlvalueリファレンス

// 以下はエラー
int & r3 = { } ; // エラー、非constなlvalueリファレンス
int const volatile & r4 = { } ; // エラー、constではあるが、volatileでもある

int a{ 0 } ;
int b( { 0 } ) ;
int c = { 0 } ;

// 通常のリファレンスの初期化と同じ
// リファレンスの初期化は、リファレンスを参照。
int && ref = { 0 } ;

// エラー、縮小変換が必要
int d{ 0.0 } ;

// pは値初期化される。つまり、nullポインターとなる。
int * p{ } ;

std::initializer_list<int> list = { 1, 2, 3 } ;

int __array[3] = { 1, 2, 3 } ;
// 実装依存のstd::initializer_list<int>の初期化の実装例
// 配列の先頭要素へのポインターと、最後からひとつ後ろのポインターを格納する
std::initializer_list<int> list( array, array + 3 ) ;

レイアウト互換（layout-compatible）

レイアウト互換（layout-compatible）という概念がある。まず、同じ型は、レイアウト互換である。

もし、二つの標準レイアウトstructが、同じ数の非staticデータメンバーを持ち、対応する非staticデータメンバーが、それぞれレイアウト互換であったならば、そのクラスは、お互いにレイアウト互換structである。

もし、二つの標準レイアウトunionが、同じ数の非staticデータメンバーを持ち、対応する非staticデータメンバーが、それぞれレイアウト互換であったならば、そのクラスは、お互いにレイアウト互換unionである。

二つの標準レイアウトstructは、レイアウト互換structのメンバーが続く限り、オブジェクト上で共通の表現をしていると保証される。

// A、Bは、2番目のメンバーまで、お互いにレイアウト互換
struct A
{
    int x ;
    int y ;
    float z ;
} ;

struct B
{
    int x ;
    int y ;
    double z ;
} ;

int main()
{
    A a ;

    B * ptr = reinterpret_cast< B * >( &a ) ;
    // OK、aのオブジェクトの、対応するレイアウト互換なメンバーが変更される
    ptr->x = 1 ;
    ptr->y = 2 ;
   
    // エラー、3番目のメンバーは、レイアウト互換ではない
    ptr->z = 0.0 ;
}

ただし、メンバーがビットフィールドの場合、お互いに同じビット数でなければならない。

// AとBはお互いにレイアウト互換
struct A
{
    int x:8 ;
} ;
struct B
{
    int x:8 ;
} ;

標準レイアウトunionが、お互いにレイアウト互換な複数の標準レイアウトstructを持つとき、先頭から共通のメンバーについては、一方を変更して、他方で使うこともできる。

struct A
{
    int x ;
    int y ;
    float z ;
} ;

struct B
{
    int x ;
    int y ;
    double z ;
} ;

union U
{
    A a ;
    B b ; 
} ;

int main()
{
    U u ;
    u.a.x = 1 ;
    u.a.y = 2 ;

    // 以下の2式はtrueとなることが保証されている
    u.b.x == 1 ;
    u.b.y == 2 ;

    // 3番目のメンバーは、レイアウト互換ではない
}

非staticメンバー関数（Nonstatic member functions）

非staticメンバー関数は、そのメンバー関数が属するクラスや、そのクラスから派生されたクラスのオブジェクトに対して、クラスメンバーアクセス演算子を使うことで、呼び出すことができる。同じクラスや、そのクラスから派生されたクラスのメンバー関数からは、他のメンバー関数を、通常の関数の呼び出しと同じように呼ぶことができる。

struct Object
{
    void f(){ }
    void g()
    {
        // 関数呼び出し
        f() ;
    }
} ;

int main()
{
    Object object ;
    // クラスのメンバーアクセス演算子と、関数呼び出し
    object.f() ;
}

非staticメンバー関数は、CV修飾子と共に宣言することができる。

struct S
{
    void none() ;
    void c() const ; // constメンバー関数
    void v() volatile ; // volatileメンバー関数
    void cv() const volatile ; // const volatileメンバー関数
} ;

このCV修飾子は、thisポインターの型を変える。また、メンバー関数の型も、CV修飾子に影響される。

非staticメンバー関数は、リファレンス修飾子と共に宣言することができる。リファレンス修飾子は、オーバーロード解決の際の、暗黙の仮引数の型に影響を与える。詳しくは、候補関数と実引数リストを参照。

非staticメンバー関数は、virtualやピュアvirtualの文法で宣言することができる。詳しくは、virtual関数や、抽象クラスを参照。

thisポインター（The this pointer）

非staticメンバー関数内では、thisというキーワードが、クラスのオブジェクトへのprvalueのポインターを表す。このクラスのオブジェクトは、メンバー関数を呼び出した際のクラスのオブジェクトである。

struct Object
{
    void f()
    {
        this ;
    }
} ;


int main()
{
    Object a, b, c ;

    a.f() ; // thisは&a
    b.f() ; // thisは&b
    c.f() ; // thisは&c
}

class Xのメンバー関数におけるthisの型は、X *である。もし、constメンバー関数の場合、X const *となり、volatileメンバー関数の場合、X volatile *となり、const volatileメンバー関数の場合は、X const volatile *となる。

class X
{
    // thisの型はX *
    void f() { this ; }
    // thisの型はX const *
    void f() const { this ; }
    // thisの型はX volatile *
    void f() volatile { this ; }
    // thisの型はX const volatile *
    void f() const volatile { this ; }
} ;

constメンバー関数では、メンバー関数に渡されるクラスのオブジェクトがconstであるため、thisの型も、constなクラスへのポインター型となり、非staticデータメンバーを変更することができない。

class X
{
    int value ;

    void f() const
    {
        this->value = 0 ; // エラー
    }
} ;

これは、thisの型を考えてみると分かりやすい。

class X
{
    int value ;


    void f() const
    {
        X const * ptr = this ;
        ptr->value = 0 ; // エラー
    }
} ;

thisの型が、constなクラスに対するポインターなので、データメンバーを変更することはできない。

同様にして、volatileの場合も、非staticデータメンバーはvolatile指定されたものとみなされる。volatileの具体的な機能ついては、実装に依存する。

CV修飾されたメンバー関数は、同等か、より少なくCV修飾されたクラスのオブジェクトに対して呼び出すことができる。

struct X
{
    X() { }
    void f() const { } ;
} ;

int main()
{
    X none ;
    none.f() ; // OK、より少なくCV修飾されている
    X const c ;
    c.f() ; // OK、同じCV修飾

    X const volatile cv ;
    cv.f() ; // エラー、CV修飾子を取り除くことはできない
}

これは、非staticメンバー関数から、他の非staticメンバー関数を、クラスメンバーアクセスなしで呼び出す際にも当てはまる。その場合、クラスのオブジェクトとは、thisである。

struct X
{
    void c() const // constメンバー関数
    {
        // thisの型はX const *
        nc() ; // エラー、CV修飾子を取り除くことはできない
    } ;

    void nc() // 非constメンバー関数
    {
        // thisの型はX *
        c() ; // OK、CV修飾子を付け加えることはできる
    }
} ;

コンストラクターとデストラクターは、CV修飾子と共に宣言することができない。ただし、これらの特別なメンバー関数は、constなクラスのオブジェクトの生成、破棄の際にも、呼び出される。

staticメンバー関数（Static member functions）

staticメンバー関数は、thisポインターを持たない。virtual指定子を使えない。CV修飾子を使えない。名前と仮引数の同じ、staticメンバー関数と非staticメンバー関数は、両立できない。

struct S
{
    // エラー、同じ名前と仮引数のstatic関数と非static関数が存在する
    void same() ;
    static void same() ; 
} ;

その他は、通常のメンバー関数と同じである。

staticデータメンバー（Static data members）

staticデータメンバーは、クラスのサブオブジェクトには含まれない。staticデータメンバーは、クラスのスコープでアクセス可能なstatic変数だと考えてもよい。クラスのすべてのオブジェクトは、ひとつのstaticデータメンバーのオブジェクトを共有する。ただし、static thread_localなデータメンバーのオブジェクトは、スレッドにつきひとつ存在する。

struct S
{
    static int member ;
} ;
int S::member ;

int main()
{
    S a, b, c, d, e ;
    // すべて同じオブジェクトを参照する
    a.member ; b.member ; c.member ; e.member ;
}

クラス定義内のstaticデータメンバー宣言は、定義ではない。staticデータメンバーの定義は、クラスの定義を含む名前空間スコープの中に書かなければならない。その際、名前に::演算子を用いて、クラス名を指定する必要がある。staticデータメンバーの定義には、初期化子を使うことができる。初期化子は必須ではない。

struct S
{
    static int member ;
} ;

// クラス名 :: メンバー名
int S::member = 0 ;

staticデータメンバーが、constなリテラル型の場合、クラス定義内の宣言に、初期化子を書くことができる。この場合、初期化子は定数式でなければならない。staticデータメンバー自体も、定数式になる。初期化子を書かない場合は、通常通り、クラス定義の外、同じ名前空間スコープ内で、定義を書かなければならない。この場合は、定数式にはならない。

struct S
{
    static const int constant_expression = 123 ; // 定数式
    static const int non_constant_expression ; // 宣言、定数式ではない
} ;
const int S::non_constant_expression = 123 ; // 定義

リテラル型のstaticデータメンバーは、constexpr指定子をつけて宣言することもできる。この場合、初期化子を書かなければならない。初期化子は、定数式でなければならない。このように定義されたstaticデータメンバーは、定数式になる。

struct S
{
    static constexpr int constant_expression = 123 ; // 定数式
} ;

名前空間スコープのクラスのstaticデータメンバーは、外部リンケージを持つ。ローカルクラスのstaticデータメンバーは、リンケージを持たない。

staticデータメンバーは、非ローカル変数と同じように、初期化、破棄される。詳しくは、非ローカル変数の初期化、終了を参照。

staticデータメンバーには、mutable指定子は使えない。

無名union（anonymous union）

以下のような形式のunionの宣言を、無名union（anonymous union）という。

union { メンバー指定opt } ;

無名unionは、無名の型のunionの、無名のオブジェクトを生成する。無名unionのメンバー指定は、非staticデータメンバーだけでなければならない。無名unionのメンバーの名前は、宣言されているスコープの他の名前と衝突してはならない。無名unionでは、staticデータメンバーやメンバー関数、ネストされた型などは使えない。また、privateやprotectedアクセス指定も使えない。

int main()
{
    union { int i ; short s ; } ;
    // iかsのどちらかひとつだけが有効
    i = 0 ;
    s = 0 ;
}

これは、以下のようなコードと同じであると考えることもできる。

int main()
{
    union Anonymous { int i ; short s ; } unnamed ;
    unnamed.i = 0 ;
    unnamed.s = 0 ;
}

名前空間スコープで宣言される無名unionには、必ずstatic指定子をつけなければならない。

// グローバル名前空間スコープ
static union { int x ; int y ; } ;

名前空間スコープで宣言される無名unionは、staticストレージの有効期間と、内部リンケージを持つ。

ブロックスコープで宣言される無名unionは、ブロックスコープ内で許されているすべてのストレージ上に構築できる。

int main()
{
    // 自動ストレージ
    union { int a } ;
    // staticストレージ
    static union { int b } ;
    // thread_localストレージ
    thread_local union { int c } ;
}

クラススコープで宣言される無名unionには、ストレージ指定子を付けることはできない。

struct S
{
    union
    {
        int x ;
    } ;
} ;

オブジェクトやポインターを宣言している、クラス名の省略されたunionは、無名unionではない。

// クラス名の省略されたunion
// 無名unionではない
union { int x ; } obj, * ptr ;

共用メンバー（variant member）

union、もしくは無名unionを直接のメンバーに持つクラスを、unionのようなクラス（union-like class）という。unionのようなクラスには、共用メンバー（variant member）という概念が存在する。unionの共用メンバーは、unionの非staticデータメンバーである。無名unionを直接のメンバーに持つクラスの場合、無名unionの非staticデータメンバーである。

// xとyは共用メンバー
union U { int x ; int y ; }

// xとyは共用メンバー
struct S
{
    union { int x ; int y ; } ;
} ;

コンストラクターによる型変換（Conversion by constructor）

explicit指定子を使わずに宣言されているコンストラクターは、仮引数からクラスへの型変換の方法を指定するメンバー関数である。このような関数を、型変換コンストラクター（converting constructor）という。

struct X
{
    X( int ) {} // int型からの型変換を提供
    X( double ) {} // double型からの型変換を提供
    X( int, int, int ) ; // 3個のint型からの型変換を提供
} ;

int main()
{
    X a = 0 ; // int型からの型変換
    X b(0) ; // int型からの型変換
    X c = 0.0 ; // double型からの型変換
    X d( 1, 2, 3 ) ;
}

型変換コンストラクターは、仮引数からクラス型への変換方法を指定する。仮引数は、複数でもよい。

explicit指定子のあるコンストラクターは、explicitのないコンストラクターとほぼ同じである。ただし、explicitコンストラクターは、直接初期化か、キャストが明示的に使われたときにしか、使われない。

struct X
{
    explicit X( int ) {} // explicitコンストラクター
} ;

void f( X ) { }

int main()
{
    X a = 0 ; // エラー
    X b(0) ; // OK、直接初期化
    X c = X(0) ; // OK、明示的なキャスト
    X d = static_cast<X>(0) ; // OK、明示的なキャスト

    f( 0 ) ; // エラー
    f( static_cast<X>(0) ) ; // OK
}

デフォルトコンストラクター、コピーコンストラクター、ムーブコンストラクターにも、explicitを指定できる。これらの関数も、explicit指定子を指定しない場合、暗黙に使われる。

struct X
{
    X() { }
    explicit X( X const & ) {} // explicitコピーコンストラクター
} ;

int main()
{
    X a ;
    X b = a ; // エラー、コピー初期化（代入式とは違うことに注意）
    X c( a ) ; // OK、直接初期化
}

デフォルトコンストラクターに対するexplicit指定子の有無は、以下のコード例のような違いをもたらす。

struct X
{
    X() { }
} ;

struct Y
{
    explicit Y() { }
} ;


int main( )
{
    X x( { } ) ; // OK、非explicitデフォルトコンストラクター
    Y y( { } ) ; // エラー、explicitデフォルトコンストラクター
}

実用上、気になるほどの違いはない。

型変換関数（Conversion functions）

以下のような文法で宣言されるメンバー関数を、型変換関数（Conversion function）という。

explicitopt operator 型識別子 ( )

型変換関数は、仮引数を取らず、戻り値の型を指定しない。型変換関数は、メンバーであるクラス型から、型識別子の型への型変換を提供する。

struct X
{
    operator int() { return 0 ; } 
} ;

int main()
{
    X x ;
    int i = x ; // 0
}

この例では、クラスXは、暗黙にint型の0に変換できるクラスとなる。

型変換関数の型は、「仮引数を取らず、型識別子の型を返す、メンバー関数」になる。

struct X
{
    operator int() const { return 0 ; } 
} ;

int main()
{
    // 型はint (X::*)(void) const
    int (X::*ptr)(void) const = &X::operator int ; // ポインターを得る
    X x ;
    (x.*ptr)() ; // 呼び出す
}

型識別子が、自分自身のクラス型（リファレンスも含む）、自分自身の基本クラス型（リファレンスも含む）、void型、またこれらの型にCV修飾子を付けた型の場合、型変換関数が使われることはない。これらの型変換には、標準型変換が用いられる。型変換関数は使われない。これらの型変換関数を宣言することはエラーではないが、使われることはない。

struct Base{ } ;

struct Derived : Base
{
    // これらの型変換関数は、使われることはない
    operator Derived () ; // 自分自身のクラス型
    operator Derived & () ; // 自分自身のクラスへのリファレンス型
    operator Derived const & () ; // 自分自身のクラスへのconstリファレンス型
    operator Base () ; // 基本クラス型
    operator void () ; // void型
} ;

int main()
{
    Derived d ;
    Base b = d ; // 標準型変換が使われる。型変換関数は使われない
}

型変換関数にexplicit指定子が指定されている場合、型変換関数は、直接初期化や明示的なキャストが使われなければ、呼び出されない。

struct A { } ;
struct B { } ;

struct X
{
    operator A() { return A() ; }
    explicit operator B() { return B() ; }

} ;

int main()
{
    X x ;

    A a1 = x ; // OK
    A a2(x) ; // OK
    A a3 = A(x) ; // OK

    B b1 = x ; // エラー、コピー初期化
    B b2(x) ; // OK、直接初期化
    B b3 = B(x) ; // OK、明示的なキャスト
}

型変換関数の型識別子を、関数型と配列型にすることはできない。

struct X
{
    operator void (void) () ; // エラー、関数型
    operator int[1] () ; // エラー、配列型
} ;

その他の型には、特に制限はない。

struct Y { } ;

struct X
{
    using pointer_type = void (*)(void) ;
    using reference_type = int (&)[1] ;

    operator pointer_type () ; // 関数ポインタ―型
    operator reference_type () ; // 配列への参照型

    operator Y() ; // 他のクラス型
} ;

型変換関数は継承される。

struct Base
{
    operator int() { return 0 ; }
} ;

struct Derived : Base { } ;

int main()
{
    Derived d ;
    int i = d ; // Base::operator intを呼び出す
}

型変換関数はvirtual関数にできる。

struct Base
{
    // ピュアvirtual関数
    virtual operator int() = 0 ;
} ;

struct Derived : Base
{
    // オーバーライド
    virtual operator int() { return 0 ; }
} ;

型変換関数はstatic関数にはできない。

struct X
{
    static operator int() ; // エラー
} ;

明示的な初期化（Explicit initialization）

クラスのオブジェクトの初期化子には括弧に囲まれた式リストを使うことができる。この場合、適切な仮引数リストのコンストラクターによって初期化される。

struct X
{
    X( int ) ;
    X( int, int ) ;
    X( int, int, int ) ;
} ;

int main()
{
    X x1( 1 ) ; // X::X(int)
    X x2( 1, 2 ) ; // X::X(int,int)
    X x3( 1, 2, 3 ) ; // X::X(int,int,int)
}

詳しくは、初期化子の直接初期化を参照。

また、=（イコール）記号に続いて値を指定することで、初期化することもできる。

struct X
{
    X( int ) ;
} ;

int main()
{
    X x = 0 ; // X::X(int)
}

詳しくは、初期化子のコピー初期化を参照。

クラスのオブジェクトは、初期化リストで初期化することができる。

struct X
{
    X( int ) { }
} ;

int main()
{
    X a[3] = { 1, 2, 3 } ;
}

詳しくは、リスト初期化を参照。

基本クラスとデータメンバーの初期化（Initializing bases and members）

基本クラスは、コンストラクター初期化子により初期化できる。データメンバーは、コンストラクター初期化子か、メンバーの宣言に続く初期化子によって、初期化できる。また、コンストラクターはデリゲート(Delegate)できる。

コンストラクター初期化子

クラスのコンストラクターの定義で、直接の基本クラス、virtual基本クラス、非staticデータメンバーを初期化できる。文法は、以下のようになる。

コンストラクター初期化子:
: メンバー初期化子, メンバー初期化子 ...opt

メンバー初期化子:
メンバー初期化識別子 ( 式リスト ) 
メンバー初期化識別子 初期化リスト

メンバー初期化識別子:
クラス名
decltype
識別子

struct Base
{ 
    Base( int ) { }
} ;

struct Derived : Base
{
    int member1 ;
    int member2 ;

    Derived()-
    // コンストラクター初期化子
        : Base( 0 ), // 基本クラス
        member1( 0 ), // メンバー
        member2{ 0 } // メンバー（初期化リスト）
    { }
} ;

非修飾のメンバー初期化識別子は、まずコンストラクターのクラスのスコープ内で名前探索され、見つからなかった場合は、基本クラスのスコープから探される。そのため、基本クラスの名前と、クラスの非staticデータメンバーの名前が衝突した場合、必ずメンバーの名前が使われる。その場合、基本クラスを指定するには、修飾名を用いなければならない。

struct Base { } ;

struct Derived : Base
{
    int Base ;
    Derived() :
        Base(), // Derivedの非staticデータメンバー
        Derived::Base() // 基本クラス
    { }
} ;

メンバー初期化識別子として使える名前は、直接の基本クラスと、virtual基本クラス、コンストラクターのクラスの非staticデータメンバーである。

struct A { } ;
struct B { } ;
struct C : B, virtual A { } ;
struct D : C
{
    D() :
        C(), // OK
        A()  // OK
        // BはDの直接の基本クラスではないので使えない
    { }
} ;

メンバー初期化子識別子には、基本クラスの型を指し示すtypedef名やdecltype指定子を使うこともできる。

struct A { } ;
typedef A type ;
struct B { } ;
B b ;

struct C : A, B
{
    C() : type(), decltype(b)()
    { }
} ;

複数の共用メンバーのうちの、ひとつだけを、メンバー初期化子で初期化することができる。

union U
{
    int a ; int b ;
    U() : a(0) { } // OK、ひとつだけ
} ;

struct S
{
    union { int a ; int b ; } ;
    S() : a(0) { } // OK ひとつだけ
} ;

union Error
{
    int a ; int b ;
    Error() : a(0), b(0) // エラー、複数の指定
    { }

} ;

同じunionのメンバーである共用メンバーは、オブジェクト上のストレージを共有しているので、複数初期化することはできない。

メンバー初期化子に、同じメンバー名、あるいは基本クラス名を、複数指定することはできない。

struct Base { } ;
struct Derived : Base
{
    int member ;
    Derived()
    : member(), member(), // エラー、同じメンバー名
      Base(), Base() // エラー、同じ基本クラス名
    { }          
} ;

コンストラクターのデリゲートについては、コンストラクターのデリゲートを参照。

メンバー初期化が明示的に指定されておらず、アブストラクトクラスのvirtual基本クラスでもない非staticデータメンバーと基本クラスは、次のように初期化される。

非staticデータメンバーに初期化子が指定されている場合、初期化子の方法に従って初期化される。

struct S
{
    int member = 123 ;
    S() /*メンバー初期化子によるmemberの指定なし*/ { }
} ;

この例では、memberは、123で初期化される。

共用メンバーの場合、初期化されない。

union U
{
    int member ;
    U() /*メンバー初期化子による共用メンバー指定なし*/ { }
} ;

struct S
{
    union { int member ; } ;
    S() /*メンバー初期化子による共用メンバーの指定なし*/ { }
} ;

union initialize
{
    int member ;
    initialize() : member(0) { } // memberを0で初期化
} ;

共用メンバーには、明示的な初期化が必要である。

それ以外の場合、デフォルト初期化される。

struct X { X() { } } ;

struct S
{
    int m1 ; 
    X m2 ;
    S() { }
} ;

この例では、int型の非staticデータメンバーm1の初期化処理はデフォルト初期化で定義されているように、何もしない。X型m2は、X型のデフォルトコンストラクターによって初期化される。

同じunionに属する非staticな共用メンバーは、ひとつしか初期化できない。

union U
{
    int m1 ; int m2 ;
    U() : m1(0), m2(0) { } // エラー
} ;

struct X
{
    union { int m1 ; int m2 ; } ;
    X() : m1(0), m2(0) { } // エラー
} ;

struct Y
{
    union { int m1 ; } ;
    union { int m2 ; } ;
    Y() : m1(0), m2(0) { } // OK、違うunionの共用メンバー
} ;

Yの例は、違うunionの共用メンバーなので、問題のないコードである。

クラスのコンストラクターの実行が終了した時点で、初期化も明示的な値の設定もされていないメンバーの値は、不定である。

struct X
{
    int member ;
    X() { }
} ;

X x1 ; // staticストレージ上に構築されたオブジェクトは、ゼロ初期化されるので、x1.memberの値は0

int main()
{
    X x2 ; // x2.memberの値は不定
}

非staticデータメンバーの宣言に初期化子があり、メンバー初期化子も指定されている場合、メンバー初期化子が優先される。この場合、メンバー宣言の初期化子は無視される。

struct X
{
    int member = 1;
    X() { } // memberは1で初期化される
    X( int arg ) : member( arg ) { } // memberはargで初期化される
} ;


int main()
{
    X x1 ; // x1.memberの値は1
    X x2(2) ; // x2.memberの値は2
}

デリゲートしていないコンストラクターにおける初期化は、以下のように行われる。

まず始めに、クラスが最も派生した型である場合、virtual基本クラスが初期化される。

struct V { } ;

struct B : virtual V { } ;
struct C : B { } ;
struct D : C { } ;

int main()
{
    D d ; // DのコンストラクターでVが初期化される
    C c ; // CのコンストラクターでVが初期化される。
    B b ; // BのコンストラクターでVが初期化される。
}

virtual基本クラスは、最も派生したクラスで初期化されるということには、注意が必要である。例えば、以下のような場合、

struct V
{
    int member ;
    V( int arg ) : member( arg )  { }
} ;

struct B : virtual V
{
    B() : V(1) { }
} ;
struct C : B { } ;

int main()
{
    C c ; // エラー、Vのデフォルトコンストラクターは暗黙にdelete定義されている。
}

VはCで初期化されるので、Bによる初期化は、無視されてしまう。Cのメンバー初期化子には、Vは記述されていないので、Vはデフォルト初期化される。Vのデフォルトコンストラクターは暗黙にdelete定義されているので、エラーとなる。

複数のvirtual基本クラスを持つ場合、初期化の順番は、深度優先（depth-first）かつ、左から右（left-to-right）となる。「深度」とは、基本クラスに行くほど深くなる。「左から右」とは、基本クラス指定子リストに現れるvirtual基本クラスの順番である。

struct V1 { } ; struct V2 { } ; struct V3 { } ;

struct B : virtual V1, virtual V2 { } ;
struct C : B, virtual V3 { } ;

C c ; // V1, V2, V3の順番で初期化される

virtual基本クラスの初期化が終わった後で、直接の基本クラスが、基本クラス指定子リストに現れる順番で初期化される。メンバー初期化子は、初期化の順番に影響しない。

struct B1 { } ; struct B2 { } ;
struct D : B1, B2
{
    D() : B2(), B1() { }
} ;

D d ; // B1, B2の順番に初期化される

メンバー初期化子は、初期化の順番に何の影響も与えないことに注意しなければならない。これは、副作用が初期化に影響をあたえるような場合、問題になる。

int i ;

struct B1 { B1(int) { } } ;
struct B2 { B2(int) { } } ;

struct D1 : B1, B2
{
    D1() : B2(++i), B1(++i) { }
} ;

struct D2 : B2, B1
{
    D2() : B2(++i), B1(++i) { }
} ;

int main()
{
    i = 0 ;
    D1 d1 ; // B1(1)、B2(2)で初期化される
    D2 d2 ; // B2(1)、B1(2)で初期化される
}

メンバー初期化子の順番は、基本クラスの初期化順序に影響しない。そのため、ある基本クラスの初期化における副作用が、次の基本クラスの初期化に影響をあたえるようなコードでは、基本クラスの記述の順番を変えるだけで、初期化の結果が異なってしまう。一般に、直接の基本クラスの初期化の順番が保証されていることを前提にしたコードを書くべきではない。

直接の基本クラスの初期化が終わった後で、クラス定義内の非staticデータメンバーが、宣言されている順番で初期化される。メンバー初期化子は、初期化の順番に影響しない。

struct X
{
    int m1 ;
    int m2 ;
    X() : m2(0), m1(0) { }
} ;

X x ; // m1, m2の順番で初期化される

直接の基本クラスの場合と同じく、メンバー初期化子は初期化の順番に影響しないということに注意しなければならない。非staticデータメンバーの初期化の順番は、クラス定義の中でメンバーが宣言されている順番である。したがって、あるメンバーの初期化の副作用が、次のメンバーの初期化に影響をあたえるようなコードでは、メンバーの宣言の順番を変えただけで、初期化処理が異なってしまう。具体的な問題例は、直接の基本クラスの場合と同じである。一般に、非staticデータメンバーの初期化の順番が保証されていることを前提にしたコードを書くべきではない。

最後に、コンストラクターの本体が実行される。

struct V { } ;
struct B { } ;
struct M { } ;

struct D : B, virtual V
{
    M m ;
    D() { /* コンストラクターの本体*/ }
} ;

D d ; // V, B, m, コンストラクターの本体の順番で初期化される

メンバー初期化子における名前は、コンストラクターの本体で評価される。

int  ;

struct X
{
    int x ;
    int y ;
    X() : x(0), y(x) { }
} ;

メンバー初期化子では、thisを使うことができる。ただし、thisの参照先はまだ構築途中である場合もあるので、注意が必要である。

非staticメンバー関数は、virtual関数を含めて、構築中のオブジェクトであっても呼び出すことができる。また、構築途中のオブジェクトを、typeid演算子やDynamic cast（Dynamic cast）のオペランドに渡すこともできる。

ただし、コンストラクター初期化子において、まだすべての基本クラスの初期化が終わっていない時点で、この種の操作を行った場合、結果は未定義である。これは、間接的に操作が行われる場合も含む。

struct A { A(int) { } } ;
struct B : A
{
    int f() { return 0 ; }
    B() : A( f() ) // 結果は未定義
    { }
} ;

// 間接的に操作が行われる例
struct C : A
{
    static int call_f( C * ptr ) { return ptr->f() ; }
    int f() { return 0 ; }
    C() : A( call_f( this ) ) // 未定義
    { }
} ;

構築中のオブジェクトに対してvirtual関数を呼び出したり、typeidやdynamic_castを使った場合の挙動は、生成と破棄を参照。

メンバー初期化子では、パック展開できる。

template < typename Bases >
struct X : Bases...
{
    X() : Bases()...
    { }
} ;

struct X
{
    int member ;

    X( int value ) : member( value )
    { /* 初期化処理 */ }

    X( double d ) : X(123) // コンストラクターのデリゲート
    {
        // 追加の処理
    }
} ;

struct X
{
    X() : X( 0 ) { }
    X( int ) : X( 0.0 ) { }
    X( double ) { }
} ;

X x ; // 初期化

struct Base { } ;

struct X : Base
{
    int member ;
    X() : X( 0 ),
        Base(), member(0) // エラー、デリゲートコンストラクターは他の識別子を指定できない
    { }
    X( int ) { }
} ;

struct X
{
    X() : X( 0 ) { } // X::X(int)を呼ぶ
    X( int ) : X( 0.0 ) { } // X::X(double)を呼ぶ
    X( double ) { }
} ;

struct X
{
    int member ;
    X() : X( 0 )
    { /* 処理2 */ }
    X( int value ) : member( value )
    { /* 処理1 */ }
} ;

X x ;

struct X
{
    X() : X() {} // エラー、直接的な自分自身へのデリゲート
} ;

struct Y
{
    Y() : Y(0) { } // エラー、間接的な自分自身へのデリゲート
    Y(int) : Y(0.0) { } // エラー、間接的な自分自身へのデリゲート
    Y(double) : Y() { } // エラー、間接的な自分自身へのデリゲート
} ;