C++とは

本書ではC++11のコア言語を解説する。

C++は、1998年に最初のC++の標準規格が正式に制定された。これをC++98と呼ぶ。C++の標準規格は、2003年にマイナーアップデートされた。これをC++03と呼ぶ。C++03では、文面の記述の誤りや矛盾点を修正し、僅かな新機能を追加した。そして、2011年に、始めてのメジャーアップデートとなる大幅な変更を含んだC++11規格が制定された。C++11では、多くのコア言語機能やライブラリが追加された。また、文面の記述も大幅に見なおされた。

将来に目を向けると、2014年には、再びマイナーアップデートであるC++14の正式発行が予定されている。次のメジャーアップデートは、非公式にC++1yと呼ばれているが、2017年を予定している。

用語（Definitions）

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

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

文法記法（Syntax notation）

本書では、言語の文法を記述するのに、規格に準じた文法記法を用いる。

個々の文法は、文法カテゴリー（syntactic category）として定義される。ある文法カテゴリーは、複数の文法カテゴリーや、具体的な文法を持つことができる。複数の文法カテゴリーは、改行で示される。

文法カテゴリー:
    サブ文法カテゴリー category
    category

サブ文法カテゴリー:
    Syntactic

この例では、以下の二つの文法が定義されることになる。

Syntactic category
category

また、省略可能な文法カテゴリーは、「文法カテゴリー_opt」と表記される。

{ 式opt }

この場合、式は書いても書かなくてもよい。

本書では、分かりやすさを重視するため、規格ほどの厳密な文法記法を用いることはない。文法カテゴリーは、常に日本語で表記される。

C++メモリーモデル（The C++ memory model）

C++では、メモリー領域のことを、ストレージ（storage）と呼ぶ。ストレージの最小単位は、バイトである。1バイトが何ビットであるかは定められていないが、少なくとも、8ビット以上であることが保証されている。最低8ビットである理由は、UTF-8の、ひとつのコード単位を格納できるようにするためである。メモリーは、連続したバイト列で表される。すべてのバイトは、ユニークなアドレスを持つ。

C++オブジェクトモデル（The C++ object model）

オブジェクトは、メモリー上に構築される。intやfloatといった基本型や、ユーザーが定義したクラスも、すべてオブジェクトとして構築される。ただし、関数は、オブジェクトではない。オブジェクトは、変数の定義や、newによって生成される。

// int型のオブジェクト
int x ;
int * pointer = new int ;

// Fooクラス型のオブジェクト
class Foo { } ;
Foo foo ;
Foo * foo_pointer = new Foo ;

オブジェクトは、型や、ストレージの有効期間、生存期間を持つ。

プログラムの実行（Program execution）

この項目の多くは、スレッドの競合と同期に関する話なので、省略する。

翻訳単位（Separate translation）

プログラムは、ソースファイルという単位に分割される。ソースファイルとは、プリプロセッサが実行された後のソースコードである。

ソースファイルの変換（Phase of translation）

ソースファイルは、コンパイルにかけられる前に、変換される。この変換の詳しい定義は略すが、特に知っておくべき変換が、いくつかある。

基本ソース文字セットではない文字は、UCNに変換される。

変換前

あ

変換後

\u3042

行末の\（バックスラッシュ）と、それに続く改行は、取り除かれる。

変換前

int \
value \
= 0 ;

変換後

int value = 0 ;

この改行の除去のルールは、注意を要する。例えば、

変換前

/\
/\
これはコメント
int va\
lue = 0 ;

変換後

//これはコメント
int value = 0 ;

連続する文字列リテラルのトークンは、連結される。

変換前

"aaa"
"bbb" ;

変換後

"aaabbb" ;

文字セット（Character sets）

C++は、ソースファイルの文字コードを定めていない。ソースファイル内の文字は、環境依存の文字コードで表現される。

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
_ { } [ ] # ( ) < > % : ; . ? * + - / ^ & | ~ ! = , \ " '

\u3042      あ
\u3043      い
\U00003044  う

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

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

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

トークン（Tokens）

C++には、5種類のトークン(token)がある。識別子、キーワード、リテラル、演算子、その他の区切り文字である。

空白、水平タブ、垂直タブ、改行、フォームフィード、コメントは無視される。

ただし、空白文字は、トークンを区切るために文法上必要になることもある。

コメント（Comments）

コメントには、二種類ある。/* */で囲まれた、複数行にわたるコメントと、//から始まり行末までの、一行コメントである。

/* ここからコメント開始
これはコメント
これもコメント
ここでコメント終わり*/

// これは一行コメント。改行までがコメントとなる。

コメントは、/*、で始まり、*/で終わる。この形式のコメントは、ネストできない。

/* これはコメント*/

/*ここから



ここまでコメント*/

/* /* これはエラー。ネストしている。*/ */

//で始まるコメントは、行末までが、コメントとなる。これは、/**/形式のコメントの中にも、書くことができる。

// これは一行コメント。行末までがコメントとなる。


/*
// これは正しいコード。
*/

識別子（Identifiers）

識別子には、大文字小文字のアルファベット、_（アンダースコア）、数字、ユニバーサル文字名、その他の実装依存の文字が使える。大文字と小文字は区別される。

int aaa ;
int AAA ; // aaaとは別の識別子、大文字と小文字は、区別される。
int bbb ;
int this_is_an_identifier ;
int n1234567890 ;
int \u3042 ; // ユニバーサル文字名
int 変数 ;

ただし、識別子の先頭は、数字から始まってはならない。

// エラー
int 0aaa ;

また、キーワードや予約語は、識別子として使うことができない。

// エラー、templateはキーワードである。
int template ;
// エラー、andは代替表現である。
int and ;

以下の識別子は、特定の文法上の場所で現れた場合に、特別な意味を持つ。これは俗に、文脈依存キーワードとも呼ばれている。

final override

特定の文法は、識別子が現れることがない場所なので、この文脈依存キーワードは、通常通り何の問題もなく識別子として使うことができる。

int final ; // OK
int override ; // OK

以下のような記述も合法だ。

// OK、クラス名finalをfinalに指定
class final final { } ;

struct base
{
    virtual void override() { }
}

struct derived : base
{
    // OK、virtual関数名overrideにoverrideを指定
    virtual void override() override { }
} ;

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 __ ; // エラー、ダブルアンダースコア

キーワード（Keywords）

C++では、以下のキーワードが使われている。これらのキーワードは、プログラム中で特別な意味を持つので、識別子に使うことはできない。

alignas     continue        friend      register            true
alignof     decltype        goto        reinterpret_cast    try      
asm         default         if          return              typedef 
auto        delete          inline      short               typeid  
bool        do              int         signed              typename
break       double          long        sizeof              union   
case        dynamic_cast    mutable     static              unsigned
catch       else            namespace   static_assert       using   
char        enum            new         static_cast         virtual 
char16_t    explicit        noexcept    struct              void    
char32_t    export          nullptr     switch              volatile
class       extern          operator    template            wchar_t 
const       false           private     this                while   
constexpr   float           protected   thread_local    
const_cast  for             public      throw           

以下は、キーワードではないが、記号と同じ意味を持つので、識別子に使うことはできない。これは、代替表現（alternative representation）と呼ばれている。

and and_eq bitand bitor compl not not_eq or or_eq xor xor_eq

リテラル（Literals）

ここでは、リテラルについて解説している。型については、型（Types）を参照。

// 10進数リテラル
1234 ;

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

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

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

// signed int
auto type1 = 0 ;

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

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

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

1.0 ;
123456789.0 ;
3.14 ;
0.00000001 ;

// 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 ;

// 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 ;

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

// 型は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' ;  // 改行
'\\' ; // バックスラッシュ

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


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

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

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

"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"" ;

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

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

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

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

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

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

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 t = true ;
bool f = false ;

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

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

宣言と定義（Declarations and definitions）

C++には、名前という概念が存在する。変数や関数、クラス等には、名前をつけられる。名前を使うには、必ず、あらかじめ、その名前が宣言されていなければならない。

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

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

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

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

// 宣言
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( true, "" ) ; // 宣言
[[ ]] ; // 宣言
 ; // 宣言

ODR（One definition rule）

ODR（One definition rule）とは、定義は原則として、ひとつしか書けないというルールである。

多くの場合、同じ宣言は、いくつでも書ける。ただし、変数、関数、クラス型、enum型、テンプレートの、同じ定義は、ひとつしか書くことができない。

// 同じ宣言はいくつでも書ける。
void f() ; void f() ; void f() ; void f() ;

// 定義はひとつしか書けない。
void f() { }

// エラー、定義が重複している
void f() { }

定義は、プログラムのすべての翻訳単位で、一つでなければならない。なぜ定義はひとつしか書けないのか。定義が複数あると、問題があるからだ。

// 定義が二つある。
int x ;
int x ;
// どっちのx？
x = 0 ;

// 定義が二つある
void f() { }
void f() { }

// どっちのf()？
f() ;

このような問題を防ぐために、定義は、原則として一つでなければならないとされている。

原則としてというのは、例外があるのだ。もし、本当に、定義を一箇所でしか書けないと、困ることがある。たとえば、クラスだ。

// 翻訳単位1 A.cpp
// 定義
struct C
{
    int x ;
} ;

C c ; // OK

// 翻訳単位2 B.cpp
// 宣言
struct C ;

C c ; // エラー

翻訳単位2で、クラスCの変数を定義するためには、クラスCは、定義されていなければならない。しかし、すでに、別の翻訳単位で、定義は書かれている。B.cppにも定義を書いてしまうと、ODRに違反する。これは一体、どうすればいいのか。

このため、C++では、クラス型、enum型、外部リンケージを持つインライン関数、クラステンプレート、外部リンケージを持つ関数テンプレート、クラステンプレートのstaticデータメンバー、クラステンプレートのメンバー関数、具体的な型を完全に指定していないテンプレートの特殊化に限り、ある条件を満たせば、別の翻訳単位での、定義の重複を認めている。ある条件とは何か。これには、大きく分けて、二つある。

// 翻訳単位1 A.cpp
struct C
{
    int x ;
} ;

// 翻訳単位2 B.cpp
struct C
{
public : // エラー。
    int x ;
} ;

// ヘッダーファイル C.h
struct C
{
    int x ;
} ;

// 翻訳単位1 A.cpp
#include "C.h"

C c ;

// 翻訳単位2 B.cpp
#include "C.h"

C c ;

// ヘッダーファイル C.h
class C
{
    void member()
    {
        f() ; // fという名前の、何らかの関数を呼び出す。
    }
} ;

// 翻訳単位1 A.cpp

namespace A
{ void f() {} }

// f()はA::f()を呼び出す
using A::f ;

#include "C.h"

// 翻訳単位2 B.cpp

namespace B
{ void f() {} }

// f()はB::f()を呼び出す
using B::f ;

#include "C.h"

スコープ（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が使われる。
}

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

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

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

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は使えない。

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

void f()
{
    {
        label : ;
    }

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

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

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


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

namespace NS
{
    using type = int ;
}

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

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

namespace NS
{ // 名前空間、NS

}

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

namespace 
{ // 無名名前空間

}

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

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

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
} ;

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

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

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

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が使われる。テンプレート仮引数ではない。
} ;

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
} ;

class ClassName {} ;

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

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

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

名前探索（Name lookup）

あるスコープにおいて、ある名前が使われているとき、その名前が何を意味するのかということを決定するのを、名前探索（Name lookup）と呼ぶ。これは一見簡単そうに思える。しかし、この名前を決定するというルールは、非常に難しい。

Name lookupには、大きく分けて、三種類ある。Qualified name lookup、Unqualified name lookup、Argument-dependent name lookupだ。

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
    
}

namespace N1 { namespace N2 {
    int x ;
} }

N1::N2::x ;

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と同じ
    }
}

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

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

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

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

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

lib::operator +( x, x ) ;

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を呼び出す。
}

プログラムとリンケージ（Program and linkage）

C++において、プログラム(program)とは、ひとつ以上の翻訳単位(translation unit)が組み合わさったものである。翻訳単位というのは、一連の宣言で構成されている。

よくあるC++の実装としては、翻訳単位は、ソースファイルという単位で分けられている。

同じオブジェクト、リファレンス、関数、型、テンプレート、名前空間、値を指し示す名前が、宣言によって別のスコープに導入された時、その名前はリンケージ(linkage)を持つ。

• 名前が外部リンケージ(external linkage)を持つ場合、その名前が指し示すエンティティは、他の翻訳単位の任意のスコープの中や、同じ翻訳単位の別のスコープの中から参照できる。
• 名前が内部リンケージ(internal linkage)を持つ場合、その名前が指し示すエンティティは、同じ翻訳単位の別のスコープから参照できる。つまり、別の翻訳単位からは参照できないということを意味する。

名前がリンケージを持たない場合、その名前が指し示すエンティティは、他のスコープから参照できない。

ある名前がリンケージを持つのか持たないのか、リンケージを持つ場合、外部リンケージなのか内部リンケージなのかというルールは複雑である。

基本的な考え方としては、グローバル名前空間を含む名前空間スコープの名前は、ほとんどが外部リンケージを持つ。内部リンケージを持つものは、大抵、明示的な指定子を伴う。リンケージを持たないエンティティは、そもそも名前を持たない場合が多い。

名前空間スコープの名前で、内部リンケージを持つものは、以下の通り。

• 明示的にstaticと宣言されている変数、関数、関数テンプレート

  static int x ;
  static void f() { }
  template < typename T >
  static void f() { }
  

• 明示的にconstかconstexprと宣言されていて、明示的にexternと宣言されておらず、前方で外部リンケージをもつと宣言されてもいないもの

  const int x = 0 ;
  constexpr int y = 0 ;
  

• 無名unionのデータメンバー

  static union { int x ; } ;
  

無名名前空間か、無名名前空間内で、直接的、間接的に宣言された名前空間は、内部リンケージを持つ。

// この無名名前空間は内部リンケージを持つ
namespace { }

namespace 
{
    // 名前空間internalは内部リンケージを持つ
    namespace internal
    {
        // 名前空間indirectは内部リンケージを持つ
        namespace indirect { }
    } 
}

これ以外の名前空間は、すべて外部リンケージを持つ。例えば、グローバル名前空間も外部リンケージを持つ。

名前空間スコープを持つ、次に挙げる種類の名前はすべて、属する名前空間スコープと同じリンケージを持つ。

• 変数
• 関数

• 名前のあるクラス、もしくは、typedef宣言によって定義された無名クラスで、typedef名をもつクラス

  // グローバル名前空間
  
  // 外部リンケージを持つ
  struct Named { } ;
  
  // 外部リンケージを持つ
  typedef struct { } Typedef_named ;
  

• 名前のあるenum、もしくは、typedef宣言によって定義された無名enumで、typedef名をもつもの

• 列挙子は、その属するenumのリンケージに従う

  // fooのリンケージはEのリンケージと同じ
  enum E { foo } ;
  

• テンプレート

つまり、名前空間のリンケージに従う。

// グローバル名前空間

namespace ns
{
    int foo ; // 外部リンケージ
}

namespace
{
    int bar ; // 内部リンケージ
}

メンバー関数、staticデータメンバー、クラススコープの名前のあるクラスやenum、クラススコープのtypedef宣言で定義された無名クラスや無名enumでtypedef名をもつものは、その属するクラスが外部リンケージを持つ場合、外部リンケージを持つ。

ブロックスコープで定義された、関数名と、extern宣言された変数名は、リンケージを持つ。

void f()
{
    extern void g() ; // リンケージを持つ
    extern int global ; // リンケージを持つ

    g() ; // OK
    global = 123 ; // OK
}

// 別の翻訳単位
void g() { }
int global ;

もし、ブロックスコープの外の直前の名前空間スコープで、同じ名前、同じエンティティでリンケージだけが違う前方宣言がなされていた場合、ブロックスコープのリンケージ指定は無視され、前方宣言のリンケージが使われる。

// グローバル名前空間
static void f();            // 内部リンケージ
static int i = 0;           // 内部リンケージ

void g() {

    extern void f();        // 内部リンケージ
    int i;                  // リンケージなし
    {
        extern void f();    // 内部リンケージ
        extern int i;       // 外部リンケージ
    }

この例では、名前iのオブジェクトは3つ存在する、それぞれ、内部リンケージ、リンケージなし、外部リンケージをもつ、別のオブジェクトを指し示している。

もし、ブロックスコープの名前と、前方宣言された名前空間スコープの名前で、名前に適合するエンティティが複数あった場合、エラーとなる。そのような重複がない場合、ブロックスコープのextern指定した名前は、外部リンケージを持つ。

ブロックスコープで宣言された名前でリンケージを持つものが、すでに前方宣言されていない場合は、ブロックスコープを包む直前の名前空間のメンバーとなる。ただし、名前空間スコープのメンバーの名前として現れることはない。

namespace ns
{
    void f()
    {
        extern void h() ; // 名前空間nsのメンバーとなる
        h() ; // OK
    }

    void g()
    {
        h() ; // エラー、名前hは宣言されていない
    }

    void h() { } // ns::hの宣言と定義
}

// これはns::hとは関係がない、別のエンティティ
void h() { }

ここまでの条件に当てはまらなかった名前は、リンケージを持たない。特に、ブロックスコープで宣言された名前のほとんどは、すでに上げた条件にあてはまらない限り、リンケージを持たない。

型のうち、リンケージを持つものは以下の通り。

• 名前を持つクラス型、もしくはenum型、typedef宣言内で定義された無名クラス型や無名enum型だが、typedef名を持つもので、その名前がリンケージを持つもの
• リンケージを持つクラスの中の、無名クラスと無名enumのメンバー

• クラステンプレートの特殊化

  template < typename T >
  void f() { }
  
  void g()
  {
      f<int>() ;
  }
  

  この例では、f<int>のみがリンケージを持つ。f<short>やf<double>のような型は、特殊化されていないので、リンケージを持たない

• 基本型

• クラスとenum以外の複合型で、リンケージを持つ型が複合しているもの。

  たとえば、int *やint **と言った型リンケージを持つ

• リンケージをもつ型がCV修飾された型

リンケージを持たない型は、リンケージを持つ関数やクラスで使うことはできない。ただし、以下の場合は使うことができる。

• エンティティがC言語リンケージをもつ場合
• エンティティが無名名前空間で宣言されている場合
• エンティティがODRの文脈で使われていない場合、もしくは、同じ翻訳単位で宣言されている場合

異なるスコープで宣言された同一の二つの名前は、以下の条件をすべて満たした場合、同じ変数、関数、型、enum、テンプレート、名前空間を指し示す。

• 名前は両方とも、ともに外部リンケージを持つか、ともに内部リンケージを持ち、同じ翻訳単位で宣言されている。
• 名前は両方とも、同じ名前空間のメンバーか、派生によらない同じクラスのメンバーを指し示している
• 名前が両方とも関数を指し示す場合は、関数の仮引数の型リストが同一であること
• 名前が両方とも関数テンプレートを指し示す場合は、シグネチャが同じであること

プログラムの開始と終了（Start and termination）

#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 ;
    }
}

auto ptr = &main ; // エラー

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

int main( ) { }

return 0 ;

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 ;
}

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

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

ストレージ(storage duration)

規格上、ストレージという用語は正しくなく、ストレージの有効期間(storage duration)という用語が正しいのだが、本書では多くの箇所で、簡単にするため、単にストレージという言葉を使っている。

ストレージの有効期間には、様々なものがある。その具体的な実装方法は規定されていない。規格はC++の実装の選択肢をなるべく制限しないように書かれているので、細部は規定していない。たとえば、規格はC++のインタープリター実装を禁止していない。ここでは、よくある古典的な実装の一例が、各ストレージをどのように実装しているかを、簡単に記述するが、規格の規定ではないことに注意。

静的ストレージとも呼ばれるstaticストレージの有効期間(static storage duration)は、staticキーワードをつけて宣言したローカル変数やデータメンバー、thread_localをつけずに宣言した名前空間スコープの変数などが該当する。

既存のよくあるC++の実装では、静的ストレージは、プログラムのコードなどと一緒にバイナリ上に配置され、そのままメモリ上に読み込まれている。

スレッドストレージの有効期間(thread storage duration)は、thread_localキーワードをつけて宣言した変数が該当する。この変数は、スレッドごとに異なるオブジェクトが割り当てられる。スレッドの解説は本書の範疇ではないので、詳しくは説明しない。

既存のよくあるC++の実装では、スレッドストレージは、TLS（Thread Local Storage）などと呼ばれる、実装依存のスレッドごとに割り当てられた何らかのストレージ、あるいはストレージを指し示すハンドルなどから確保している。

自動ストレージの有効期間(automatic storage duration)は、ブロックスコープで明示的にregisterつきで宣言された変数、あるいは、staticやexternつきで宣言されていない変数が該当する。thread_localつきの変数宣言は暗黙的にstaticでもあるので、該当しない。

既存のよくあるC++の実装では、自動ストレージの有効期間は、スタックと呼ばれる特別なメモリから割り当てられる。

動的ストレージの有効期間(dynamic storage duration)を持つストレージ上のオブジェクトは、new式によって動的に作成され、delete式によって破棄される。

C++実装は、オブジェクトを構築する動的ストレージを確保するためのグローバルな確保関数(allocation function)と、動的ストレージを解放するための解放関数(deallocation function)を提供している。

確保関数は、operator newとoperator new[]で、解放関数はoperator deleteとoperator delete[]となる。

C++の標準ライブラリは、デフォルトの確保関数と解放関数の定義を提供している。これはオーバーロードして、独自の定義を与えることもできる。

確保関数、解放関数のシグネチャは、以下の通り。

void* operator new(std::size_t);
void* operator new[](std::size_t);
void operator delete(void*);
void operator delete[](void*);
void operator delete(void*, std::size_t) noexcept;
void operator delete[](void*, std::size_t) noexcept;

最後の二つの解放関数は、二番目の仮引数に、確保したストレージのサイズが渡される。

オブジェクトの寿命(Object lifetime)

オブジェクトの寿命(lifetime)の始まりは、オブジェクトの型のサイズとアライメントに適切に対応したストレージが確保された後、もしオブジェクトが非トリビアル初期化を持つならば、その初期化が終わった時点である。

非トリビアル初期化(non-trivial initialization)とは、オブジェクトの型がクラスかアグリゲートで、そのメンバーがひとつでもトリビアルデフォルトコンストラクター以外で初期化されるものをいう。

オブジェクトの寿命の終わりは、オブジェクトが非トリビアルデストラクターを持つのならば、デストラクター呼び出しを開始した時点、そうでなければ、オブジェクトの占めるストレージが解放されるか再利用された時点である。

型(Types)

トリビアルにコピー可能な型のオブジェクトは、その内部表現のバイト列を、charかunsigned charの配列にコピーできる。コピーされたcharかunsigned charの配列を、再びオブジェクトにコピーしなおした場合、オブジェクトは元の値を保持する。

// トリビアルにコピー可能な型Tのオブジェクト
T object ;
// Tを表現するバイト列のサイズ
constexpr std::size_t size = sizeof(T) ;
// T型と同じサイズの配列
unsigned char buffer[size] ;

// 配列にコピー
std::memcpy( buffer, &object, size ) ;
// 元のオブジェクトにコピーしなおす
std::memcpy( &object, buffer, size ) ;

// objectの値は元のまま

トリビアルにコピー可能な型Tのオブジェクトを指し示すポインターが二つあるとして、オブジェクトは基本クラスとしてのサブオブジェクトではない場合、内部表現のバイト列をポインターを経由してコピーすると、コピーされた方はコピーした方の値になる。

// Tはトリビアルにコピー可能な型
// ポインターはオブジェクトを指し示しているとする
T * ptr1 ;
T * ptr2 ;

std::memcpy( ptr1, ptr2, sizeof(T) ) ;

// ptr1の指し示すオブジェクトは、ptr2の指し示すオブジェクトと同じ値になる

ある型Tのオブジェクトのオブジェクト表現(object representation)は、Nをsizeof(T)とすると、N個のunsigned char型のオブジェクトになる。オブジェクトの値表現(value representation)は、T型の値を保持するためのビット列である。トリビアルにコピー可能な型の場合、値表現は、オブジェクト表現のビット列の値とすることができる。この値は実装依存のビット列の値である。

宣言されているが定義されていないクラス、一部のenum、大きさの分からない配列や不完全な要素型の配列は、不完全に定義されたオブジェクト型である。このような不完全に定義されたオブジェクト型は、そのサイズやストレージ上のレイアウトが、まだ定まっていない。オブジェクトは、不完全な型を持ったまま定義されてはならない。

struct incomplete ; // 不完全型

struct error
{
    incomplete i ; // エラー、不完全な型をもったまま定義
} ;

クラス型は、翻訳単位のある箇所では不完全で、後に完全になることができる。その場合でも、クラスの型は変わらない。

配列の型は、要素として不完全なクラス型を含み、不完全となることがある。もし、クラスが後に完全になったならば、そのような配列型も、その時点で完全になる。

class X ; // 不完全型
using type = X [10] ; // OK、不完全型

type a ; // エラー、配列の要素型が不完全

// クラスXを完全にする
class X { } ;

type b ; // OK、配列の要素型は完全

宣言された配列は要素数を不定とすることができ、その時点では不完全な型となる。そのような配列は、後に完全に定義することができる。配列の型は、要素数が指定される前と後とで異なる。要素の型をTとすると、要素数が指定される前の型は、「T型の要素数不定の配列型」であり、要素数がNに定まった後は、「T型のN要素数の配列」となる。

extern int a[] ; // int型の要素数不定の配列型

int a[10] ; // int型の要素数10の配列型

オブジェクト型(object type)という用語は、CV修飾されているかもしれない型で、関数型、リファレンス型、void型以外の型のことである。

演算型(Arithmetic type)、enum型、ポインター型、メンバーへのポインター型、std::nullptr_t型、そしてこれらの型のCV修飾された型をひっくるめて、スカラー型(scalar type)と呼ぶ。スカラー型とPODクラス、またそのような型の配列と、そのような型がCV修飾された型をひっくるめて、POD型と呼ぶ。スカラー型とトリビアルにコピー可能なクラス型、そのような型の配列、非volatileでconst修飾されたそれらの型をひっくるめて、トリビアルにコピー可能な型(trivially copyable type)と呼ぶ。スカラー型、トリビアルクラス型、そのような型の配列、そのような型のCV修飾された型をひっくるめて、トリビアル型(trivial type)と呼ぶ。スカラー型、標準レイアウトクラス型、そのような型の配列、そのような型のCV修飾された型をひっくるめて、標準レイアウト型(standard layout type)と呼ぶ。

リテラル型(literal type)とは、以下の条件のいずれかひとつを満たす型のことである。

• void
• スカラー型
• リファレンス型
• リテラル型の配列

• クラス型で、以下の条件をすべて満たすもの

  • トリビアルデストラクターを持つ
  • アグリゲート型か、少なくとも一つのconstexprコンストラクターか、constexprコンストラクターテンプレートを持ち、そのコンストラクターとコンストラクターテンプレートが、コピーやムーブのコンストラクターではない
  • 非staticデータメンバーと基本クラスはすべて、非volatileなリテラル型である

T1型とT2型が同じであるならば、T1とT2は、レイアウト互換型(layout-compatible type)である。

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

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

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

signed char
short int
int
long int
long long int

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

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
}

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

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

#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型への型変換
}

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

int x ;
x = 0 ;

int f() { return 0 ; }

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

int f() { return 0 ; }

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

int f() { return 0 ; }

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

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() ;
}

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

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

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

#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 ; } ;

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

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

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

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

#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() ;
}

lvalueからrvalueへの型変換（Lvalue-to-rvalue conversion）

本書では、煩雑を避けるために省略しているが、多くの標準型変換は、ある型のprvalueの値を、別の型のprvalueの値に変換するようになっている。そのため、標準型変換の際には、必要な場合、glvalueが、自動的にprvalueに変換される。これを、lvalueからrvalueへの型変換という。変換できるglvalueは、関数と配列以外である。

この変換は、通常、まず意識することがない。

配列からポインターへの型変換（Array-to-pointer conversion）

配列とポインターは、よく混同される。その理由の一つに、配列名が、あたかもポインターのように振舞うということがある。

int a[10] ;
// pは、aの先頭要素を指す。
int * p = a ;

// どちらも、配列aの先頭要素に0を代入する
*a = 0 ;
*p = 0 ;

これは、配列からポインターへの型変換によるものである。配列名は、配列の先頭要素へのポインターとして扱われる。

int a[10] ;


int * p1 = a ; // &a[0]と同じ
int (* p2 )[10] = &a ; // int [10]へのポインター

ここで、変数aの型は、int [10]であって、int *ではない。ただし、int *に暗黙のうちに型変換されるので、あたかもポインターのように振舞う。

多くの人は、これを暗黙の型変換としては意識していない。配列からポインターへの型変換は、非常によく使われる変換であって、多くの式では、配列名は、自動的に、配列の先頭要素へのポインターに型変換される。

関数からポインターへの型変換（Function-to-pointer conversion）

関数の名前は、その関数へのポインターに型変換される。

void f( void ) {}

int main()
{
    // typeは関数ポインターの型
    using type = void (*) (void) ;

    // 同じ意味。
    type p1 = f ;
    type p2 = &f ;
}

fの型は、関数であって、関数ポインターではない。関数ポインターとは、&fである。しかし、関数は、暗黙のうちに、関数ポインターに型変換されるので、関数名fは、関数ポインターとしても使うことができる。

この型変換も、非常によく使われる。多くの場合は、自動的に、関数は関数ポインターに変換される。

ただし、この型変換は、非staticなメンバー関数には適用されない。ただし、staticなメンバー関数は、この標準変換が適用される。

struct C
{

    void f(void) {}
    static void g(void) {}
} ;

// エラー
void ( C:: * error )(void) = C::f ;
// OK
void ( C::* ok )(void) = &C::f ;

// staticなメンバー関数は、普通の関数と同じように、変換できる
void (*ptr)(void) = C::g ;
void (*ptr2)(void) = &C::g ; // ただし、こちらの方が分かりやすい

このような暗黙の型変換があるとはいえ、通常、関数ポインターを扱う際には、明示的に単項演算子である&演算子を使ったほうが、分かりやすい。

CV修飾子の型変換（Qualification conversions）

ある型Tへのポインターは、あるconstまたはvolatile付きの型Tへのポインターに変換できる。

int * p ;
int const * cp = p ;
int volatile * vp = p ;
int const volatile * cvp = p ;

cvp = cp ;
cvp = vp ;

これは、より少ないCV修飾子へのポインターから、より多いCV修飾子へのポインターに、暗黙のうちに型変換できるということである。

ただし、ポインターのポインターの場合は、注意を要する。

int ** p ;

// エラー
int const ** cp = p ;

// これはOK
int const * const * cp = p ;

なぜか。実は、この型変換を認めてしまうと、const性に穴が空いてしまうのだ。

int main()
{
    int const x = 0 ;
    int * p ;

    // これはエラー。
    p = &x ;

    // もしこれが認められていたとする。
    // 実際はエラー。
    int const ** cpp = &p ;

    // cppを経由して、pを書き換えることができてしまう。
    *cpp = &x ;

    // pは、xを参照できてしまう。
    *p = 0 ;
}

このため、ある型をTとした場合、T **から、T const **への型変換は、認められていない。T **から、T const * const *への変換はできる。

int * p = nullptr ; 
int const * const * p2 = &p ; // OK

整数の変換順位（Integer conversion rank）

整数型には、変換順位というものが存在する。これは、標準型変換や、リスト初期化で考慮される、整数型の優先順位である。これは、それほど複雑な順位ではない。基本的には、型のサイズの大小によって決定される。もっとも、多くの場合、型のサイズというのは、実装依存なのだが。

基本的な変換順位は、以下のようになる。

signed char < short int < int < long int < long long int

unsignedな整数型の順位は、対応するsingedな型と同じである。

この他にも、いくつか細かいルールがある。

charとsigned charと、unsigned charは、同じ順位である。

boolは、最も低い順位となる。

char16_t、char32_t、wchar_tの順位は、実装が割り当てる内部的な型に依存する。従って、これらの変換順位は、実装依存である。

拡張整数型、つまり、実装が独自に定義する整数型は、実装依存の順位になる。

整数のプロモーション（Integral promotions）

整数のプロモーションとは、変換順位の低い型から、高い型へ、型変換することである。ただし、単に順位が低い型から高い型への型変換なら、何でもいいというわけではない。

bool, char16_t, char32_t、wchar_t以外の整数型で、intより変換順位の低い整数型、つまり、char、short、その他の実装独自の拡張整数型は、もし、int型が、その値をすべて表現できる場合、intに変換できる。

short s = 0 ;
int i = s ; // 整数のプロモーション
long l = s ; // これは、整数の型変換

intより低い順位の整数型から、int型への変換ということに注意しなければならない。longやlong longへの変換、または、charからshortへの変換などは、プロモーションではなく、整数の型変換に分類される。

char16_t、char32_t、wchar_tは、実装の都合による内部的な整数型に変換できる。内部的な整数型というのは、int、unsigned int、long int、unsigned long int、long long int、unsigned long long intのいずれかである。もし、これらのどの型でも、すべての値を表現できないならば、実装依存の整数型に変換することができる。

今、int型で、char16_tとchar32_tの取りうるすべての値が表現できるものとすると、

char16_t c16 = u'あ' ;
char32_t c32 = U'あ' ;
wchar_t wc = L'あ' ;

int x = 0 ;
x = c16 ; // xの値は0x3042
x = c32 ; // xの値は0x3042
x = wc ; // xの値は実装依存

int型とwchar_t型のサイズは、実装により異なるので、このコードは、実際のC++の実装では、動く保証はない。

基底型が指定されていないunscoped enum型は、int、unsigned int、long int、unsigned long int、long long int、unsigned long long intのうち、enum型のすべての値を表現できる最初の型に変換できる。もし、どの標準整数型でもすべての値を表現できない場合、すべての値を表現できる実装依存の拡張整数型のうち、もっとも変換順位の低い型が選ばれる。もし、順位の同じ整数型が二つある場合、つまり、signedとunsignedとが違う場合、signedな整数型の方が選ばれる。

基底型が指定されてるunscoped enum型は、指定された基底型に変換できる。その場合で、さらに整数のプロモーションが適用できる場合も、プロモーションとみなされる。例えば、

enum E : short { value } ;

short s = value ; // これは整数のプロモーション
int i = value ; // これも整数のプロモーション

このように、enumの場合は、int型以外への変換でも、プロモーションになる。

int型への代入では、enum型が、基底型であるshortに変換された後、さらにintに変換されている。これは、どちらもプロモーションである。

ビットフィールドは、すべての値を表現できる場合、intに変換できる。

struct A
{
    int x:8 ;
} ;

int main()
{
    A a = {0} ;
    int x = a.x ; // 整数のプロモーション
}

もし、ビットフィールドの値が、intより大きいが、unsigned int型で表現できる場合は、unsigned intに変換できる。値がunsigned intより大きい場合は、整数のプロモーションは行われない。整数の型変換が行われる。

bool型の値は、int型に変換できる。falseは0となり、trueは1となる。

int a = true ; // aは1
int b = false ; // bは0

以上が、整数のプロモーションである。これに当てはまらない整数型同士の型変換は、すべて、次に述べる整数の型変換である。

整数の型変換（Integral conversions）

整数型は、他の整数型に型変換できる。ほんの一例を示すと、

short s = 0 ;
int i = s ; // shortからintへの変換
s = i ; // intからshortへの変換

unsigned int ui = i ; // intからunsigned intへの変換
i = ui ; // unsigned intからintへの変換

long l = s ; // shortからlongへの変換
long long ll = l ; // longからlong longへの変換。

整数のプロモーション以外の整数の型変換は、すべて、整数の型変換になる。この違いは、オーバーロード解決などに影響するので、重要である。

整数の型変換は、危険である。変換先の型が、変換元の値を表現できない場合がある。

例えば、今、signed charは8ビットで、intは16ビットだと仮定する。

#include <limits>

int main()
{
    int i = std::numeric_limits<signed char>::max() + 1 ;
    signed char c = i ; // どうなる？
}

signed charは、intの取りうる値をすべて表現できるわけではない。この場合、どうなってしまうのか。

変換先の整数型がunsignedの場合、結果の値は、変換元の対応する下位桁の値である。

具体的な例を示して説明する。

// unsigned charが8ビット、unsigned intが16ビットとする

int main()
{
    unsigned int ui = 1234 ;
    unsigned char uc = ui ; // 210
}

この場合、unsigned int型は、16ビット、uiの値は、2進数で0000010011010010である。unsigned char型は8ビット。つまり、この場合の対応する下位桁の値は、2進数で11010010（uiの下位8ビット）である。よって、ucは、10進数で210となる。

unsignedの場合、変換先の型が、変換元の値を表現できないとしても、その値がどうなるかだけは、保証されている。もっとも、値を完全に保持できないので、危険なことには変わりないのだが。

変換先の整数型がsignedの場合は、非常に危険である。変換先の整数型が、変換元の値を表現できる場合、値は変わらない。表現できない場合、その値は実装依存である。

今仮に、int型は、signed char型の取りうる値をすべて表現できるが、signed char型は、int型の取りうる値をすべて表現することはできないとする。また、signed charは8ビット、intは16ビットとする。signed charの最小値は-127、最大値は127。intの最小値は-32767、最大値は32767とする。

int main()
{
    signed char c = 100 ;
    int i = c ; // iの値は100

    signed char value = 1000 ; // 値は実装依存

}

iの値は、100である。なぜなら、今仮定した環境では、int型は100を表現できるからである。valueの値は、実装依存であり、分からない。なぜならば、signed char型は、1000を表現できないからだ。その場合、変換先のsignedな整数型の値は、実装依存である。

浮動小数点数のプロモーション（Floating point promotion）

float型の値は、double型の値に変換できる。このとき、値は変わらない。つまり、floatからdoubleへの変換は、まったく同じ値が表現できることを意味している。

float f = 3.14 ;
double d = f ; // dの値は3.14

この変換を、浮動小数点数のプロモーションという。

浮動小数点数の型変換（Floating point conversions）

浮動小数点数のプロモーション以外の、浮動小数点数同士の型変換を、浮動小数点数の型変換という。

double d = 0.0 ;
float f = 0.0 ;
long double ld = 0.0 ;

f = d ; // doubleからfloatへの型変換
ld = f ; // floatからlong doubleへの型変換
ld = d ; // doubleからlong doubleへの型変換

もし、変換先の型が、変換元の型の値を、すべて表現できるのならば、値は変わらない。値を正確に表現できない場合は、最も近い値が選ばれる。この近似値がどのように選ばれるかは、実装依存である。近似値すら表現できない場合の挙動は、未定義である。

浮動小数点数と整数の間の型変換（Floating-integral conversions）

浮動小数点数型は、整数型に変換できる。このとき、小数部分は切り捨てられる。小数部分を切り捨てた後の値が、変換先の整数型で表現できない場合、挙動は未定義である。

int x = 1.9 ; // xの値は、1
int y = 1.9999 ; // yの値は、1
int z = 0.9999 ; // zの値は、0

整数型、あるいはunscoped enum型は、浮動小数点数型に変換できる。結果は、可能であれば、まったく同じ値になる。近似値で表現できる場合、実装依存の方法によって、近似値が選ばれる。値を表現できない場合の挙動は、未定義である。

float f = 1 ; // fの値は、1.0f

ポインターの型変換（Pointer conversions）

nullポインター定数とは、整数型定数で、0であるものか、std::nullptr_t型である。

0 ; // nullポインター定数
1 ; // これはnullポインター定数ではない
nullptr ; // nullポインター定数。型はstd::nullptr_t

0がnullポインター定数として扱われるのは、歴史的な理由である。

nullポインター定数は、どんなポインター型にでも変換できる。この値を、nullポインター値（null pointer value）という。nullポインター定数同士を比較すると、等しいと評価される。

int * a = nullptr ;
char * c = nullptr ;
int ** pp = nullptr ;

bool b = (nullptr == nullptr) ; // true

nullポインター定数を、CV修飾付きの型へのポインターに変換する場合、このポインターの型変換のみが行われる。CV修飾子の型変換ではない。

// ポインターの型変換のみが行われる。
// CV修飾子の型変換は行われない。
int const * p = nullptr ;

整数型定数のnullポインター定数は、std::nullptr_t型に変換できる。結果の値は、nullポインターである。

std::nullptr_t null = 0 ;

あるオブジェクトへのポインター型は、voidへのポインターに変換できる。

int x = 0 ;
int * int_pointer = &x ;
void * void_pointer = int_pointer ; // int *からvoid *に変換できる

この時、CV修飾子が付いていた場合、消すことはできない。

int x = 0 ;
int const * int_pointer = &x ;

void * error = int_pointer ; // エラー
void const * ok = int_pointer ; // OK

void *に変換した場合、ポインターの値は、変換元のオブジェクトのストレージの、先頭を指し示す。値がnullポインターの場合は、変換先の型のnullポインターになる。

派生クラスのポインターから、基本クラスのポインターに変換することができる。

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

Derived * p = nullptr ;
Base * bp = p ; // OK。Derived *からBase *への変換

もし、基本クラスにアクセス出来ない場合や、曖昧な場合は、エラーとなる。

// 基本クラスにアクセス出来ない場合
struct Base { } ;
struct Derived : private Base { } ;

Derived * d = nullptr ;
Base * b = d ; // エラー。Baseにはアクセス出来ないので、変換できない

// 曖昧な場合
struct Base { } ;
struct Wrap1 : Base { } ;
struct Wrap2 : Base { } ;

// Derivedは、基本クラスとしてふたつのBaseを持っている。
struct Derived : Wrap1, Wrap2 { } ;

Derived * ptr = nullptr ;

// エラー
// Wrap1::Baseと、Wrap2::Baseのどちらなのかが曖昧
Base * ambiguous_base = ptr ;

// OK
// Wrap1::Base
Base * Wrap1_base = static_cast<Wrap1 *>(ptr) ;

派生クラスのポインターから基本クラスポインターへの変換の結果は、派生クラスの中の、基本クラス部分を指す。これは、変換の結果、ポインターの値が変わる可能性がある。実装に依存するので、あまり具体的な例を挙げたくはないが、例えば、以下のようなコードは、多くの実装で、ポインターの値が変わる。

#include <cstdio>

struct Base1 { int x ; } ;
struct Base2 { int x ; } ;
struct Derived : Base1, Base2 { } ;



int main()
{
    Derived d ;

    // dへのポインター
    Derived * d_ptr = &d ;
    std::printf("d_ptr : %p\n", d_ptr) ;

    // 基本クラスのポインターへ型変換
    Base1 * b1_ptr = d_ptr ;
    Base2 * b2_ptr = d_ptr ;

    // 多くの実装では、
    // b1_ptrとb2_ptrのどちらかが、d_ptrと同じ値ではない。
    std::printf("b1_ptr : %p\n", b1_ptr) ;
    std::printf("b2_ptr : %p\n", b2_ptr) ;

    // 派生クラスへキャスト（標準型変換の逆変換）
    Derived * d_ptr_from_b1 = static_cast<Derived *>(b1_ptr) ;
    Derived * d_ptr_from_b2 = static_cast<Derived *>(b2_ptr) ;

    // 多くの実装では、
    // d_ptrと同じ値になる。
    std::printf("d_ptr_from_b1 : %p\n", d_ptr_from_b1) ;
    std::printf("d_ptr_from_b2 : %p\n", d_ptr_from_b1) ;
}

このように、基本クラスと派生クラスの間のポインターのキャストは、ポインターの値の変わる可能性がある。このような型変換には、単に値をそのまま使う、reinterpret_castは使えない。

変換元のポインターの値がnullポインターの場合は、変換先の型のnullポインターになる。

メンバーへのポインターの型変換（Pointer to member conversions）

nullポインター定数は、メンバーへのポインターにも変換できる。変換された結果の値を、nullメンバーポインター値（null member pointer value）という。

struct C { int data ; } ;

int C::* ptr = nullptr ;

nullメンバーポインター値は、他のメンバーへのポインターの値と比較できる。

struct C { int data ; } ;

int C::* ptr1 = nullptr ;
int C::* ptr2 = &C::data ;

bool b = ( ptr1 == ptr2 ) ; // false

boolの型変換（Boolean conversions）

整数、浮動小数点数、unscoped enum、ポインター、メンバーへのポインターは、boolに変換できる。ゼロ値、nullポインター値、nullメンバーポインター値は、falseに変換される。それ以外の値はすべて、trueに変換される。

bool b1 = 0 ; // false
bool b2 = 1 ; // true
bool b3 = -1 ; // true

bool b4 = nullptr ; // false

int x = 0 ; 
bool b5 = &x ; // true

優先順位と評価順序

式には、優先順位と評価順序がある。

優先順位とは、ある式の中で、異なる式が複数使われた場合、どちらが先に評価されるのかという順位である。この優先順位は、人間にとって自然になるように設計されているので、通常、式の優先順位を気にする必要はない。

// 1 + (2 * 3)
// operator *が優先される
1 + 2 * 3 ;

int x ;
// operator +が優先される
x = 1 + 1 ;

評価順序とは、ある式の中で、優先順位の同じ式が複数使われた場合、どちらを先に評価するかという順序である。これは、式ごとに、「左から右（Left-To-Right）」、あるいは「右から左（Right-To-Left）」のどちらかになる。

たとえば、operator +は、「左から右」である。

// (1 + 1) + 1 と同じ
1 + 1 + 1 ;

一方、operator = は、「右から左」である。

int x ; int y ;
// x = (y = 0) と同じ
x = y = 0 ;

これも、人間にとって自然になるように設計されている。通常、気にする必要はない。

未評価オペランド（unevaluated operand）

typeid演算子、sizeof演算子、noexcept演算子、decltype型指定子では、あるいは未評価オペランド（unevaluated operand）というものが使われる。このオペランドは文字通り、評価されない式である。

オペランドの式は評価されないが、式を評価した結果の型は、通常の評価される式と何ら変わりない。

int f()
{
    std::cout << "hello" << std::endl ;
    return 0 ;
}

int main()
{
    // int x ; と同等
    // 関数fは呼ばれない
    decltype( f() ) x ;
}

この例では、オペランドの式の結果の型を、変数xとして宣言、定義している。関数呼び出しの結果の型は、関数の戻り値の型になるので、型はintである。ただし、式自体は評価されないので、実行時に関数が呼ばれることはない。つまり、標準出力にhelloと出力されることはない。

この未評価式は、評価されないということを除けば、通常の式と全く同じように扱われる。例えば、オーバーロード解決やテンプレートのインスタンス化なども、通常の式と同じように働く。

// 関数の宣言だけでいい。定義は必要ない
double f(int) ;
int f(double) ;

int main()
{
    // double x ; と同等
    decltype( f(0) ) x ;
    // int y ; と同等
    decltype( f(0.0) ) y ;
}

この例では、関数fは、宣言だけされていて、定義がない。しかし、これは全く問題がない。なぜならば、未評価式は評価されないので、関数fが呼ばれることはない。呼ばれることがなければ、定義も必要はない。

一次式（Primary expressions）

一次式には、多くの細かな種類がある。例えば、リテラルや名前も一次式である。ここでは、一次式の中でも、特に重要なものを説明する。

// スコープはグローバル
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 ; // クラス
}

(0) ; // 括弧式

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

ラムダ式（Lambda expressions）

ラムダ式（lambda expression）は、関数オブジェクトを簡単に記述するための式である。以下のような文法になる。

[ ラムダキャプチャーopt ] ( 仮引数 ) mutableopt 例外指定opt -> 戻り値の型opt

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

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

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

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

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

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

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

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

[]{}

{ return 式 ; }

// エラー、戻り値の型は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 ; } ) ;
}

#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 {} ;

// 初期化はできる。
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
        } ;
    } ;
}

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

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

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

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

struct C
{
    int x ;
    void f()
    {
        [=]{ x ; } ; // thisをコピーキャプチャーする
        [&]{ x ; } ; // 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はローカル変数のコピー
    }
} ;

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

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

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

後置式（Postfix expressions）

後置式は、主にオペランドの後ろに演算子を書くことから、そう呼ばれている。後置式の評価順序はすべて、「左から右」である。

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

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

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

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 ;
}

式 ( 引数のリスト )

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() ;
}

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() ;

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

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

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関数呼び出しの順番は分からない
}

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

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

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

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

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

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

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

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

auto(0) ; // エラー

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

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

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

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

static_cast< decltype(x) >(x) ;

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) ; 

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

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

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

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

void() ; // 結果はvoid

#include <initializer_list>

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

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

// このコードは、疑似デストラクター呼び出しの文法を示すためだけの例である
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 ; // デストラクターが暗黙的に呼ばれる。
}

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 ) ;
}

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>() ;
}

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

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() ;
}

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
}

式 ++
式 --

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

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

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

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

dynamic_cast < 型名 > ( 式 )

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クラスの場合*/ )
    {
        // 特別な処理
    }

    // 共通の処理
}

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) ;
}

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ポインターが返される
    }
}

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

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

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

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) ;
}

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) ;
}

typeid ( 式 )
typeid ( 型名 )

#include <typeinfo>

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

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

}

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 ;
}

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

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

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

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

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

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

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

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

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

// 実引数の型を、表示してくれるはずの便利な関数
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) ;
}

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

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< 型名 >( 式 )

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

void f(Base & base)
{
    // Derived *からBase *に標準型変換で変換できるので、キャストできる
    Derived & derived = static_cast<Derived &>(base) ;
}

int main()
{
    int x = 0 ;
    static_cast<int &&>(x) ;
}

// short t(0) は可能なので変換できる
static_cast<short>(0) ;

// float t(0) は可能なので変換できる
static_cast<float>(0) ;

int main()
{
    static_cast<void>( 0 ) ;
    static_cast<void>( 1 + 1 ) ;    
} 

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) ;

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 < 型名 > ( 式 )

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 < 型名 > ( 式 )

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) ;
} 

int main()
{
    int const * const * const * const c = nullptr ;
    int *** ptr = const_cast<int ***>(c) ;
} 

int main()
{
    int const x = 0 ;
    // エラー、const以外の型変換を行っている。
    short * ptr = const_cast<short *>(&x) ;
} 

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)) ;
} 

void f( int ) {}

int main()
{
    using type = void (*)(int) ;
    type const ptr = nullptr ;

    // エラー、関数ポインターはキャストできない
    type p = const_cast<type>(ptr) ;
} 

単項式（Unary expressions）

単項式は、オペランドをひとつしか取らないことより、そう呼ばれている。単項式の評価順序はすべて、「右から左」である。

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 ;

++ 式
-- 式

int x = 0 ;
int result = ++x ;
// ここで、result = 1, x = 1

sizeof ( 未評価式 )
sizeof ( 型名 )
sizeof ... ( 識別子 )

// 1
sizeof(char) ;
// int型のオブジェクトのサイズ
sizeof(int) ;

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 ) ;
}

// sizeof(int) * 10 と同じ
sizeof( int [10] ) ;

char a[10] ;
// sizeof(char) * 10 = 1 * 10 = 10
sizeof( a ) ;

// この型は配列ではなく、char
// sizeof(char)と同じ
sizeof( a[0] ) ;

#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
}

::opt new 型名 new初期化子opt
::opt new ( 式リスト ) 型名 new初期化子opt

class C {} ;
int main()
{
    // int型のオブジェクトを生成する
    int * i = new int ;
    // C型のオブジェクトを生成する
    C * c = new C ;
}

int main()
{
    try
    {
        new int ;
    }
    catch ( std::bad_alloc )
    {
        // newが失敗した
    }
}

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 ;
}

::opt delete 式
::opt delete [ ] 式

int main()
{
    int * ptr = new int ;
    int * array_ptr = new int[1] ;

    delete ptr ;
    delete[] array_ptr ;
}

struct C
{
    operator int *() { return new int ; }
} ;

int main()
{
    C c ;
    // C::operator int *()を呼び出し、
    // 戻り値を解放する。
    delete c ;
}

// オーバーロードあり
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 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 ( 型名 )

struct C
{
    char c ; int i ; double d ;
} ;

void f()
{
    // char型のアライメント要求を返す
    alignof( char ) ;
    // int型のアライメント要求を返す
    alignof( int ) ;
    // double型のアライメント要求を返す
    alignof( double ) ;
    // C型のアライメント要求を返す
    alignof( C ) ;
}

noexcept ( 未評価式 )

// false
noexcept( throw 0 ) ;

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

void f( Base & ref )
{
    // false
    noexcept( dynamic_cast<Derived & >( ref ) ) ;
}

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

void f( Base * ptr )
{
    // false
    noexcept( typeid( *ptr ) ) ;
}

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
}

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

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
}

キャスト形式による明示的型変換（Explicit type conversion (cast notation)）

注意：C形式のキャストには様々な問題があるので、使ってはならない。

( 型名 ) 式

これは、悪名高いC形式のキャストである。

int main()
{
    int i = 0 ;
    double * ptr = (double *) &i ;
}

C形式のキャストは、static_castとreinterpret_castとconst_castを組み合わせた働きをする。組み合わせは、以下の順序で決定される。

1. const_cast
2. static_cast
3. static_castとconst_cast
4. reinterpret_cast
5. reinterpret_castとconst_cast

上から下に評価していき、変換できる組み合わせが見つかったところで、そのキャストを使って変換する。

ただし、C形式のキャストでは、static_castに特別な変更を三つ加える。クラスのアクセス指定を無視できる機能である。

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

int main()
{
    Derived d ;

    Base & ref1 = (Base &) d ; // OK
    Base & ref2 = static_cast<Base &>(d) ; // ill-formed
}

struct Base { } ;
struct Derived : private Base { int x ; } ;

int main()
{
    int Base::* ptr1 = (int Base::*) &Derived::x ; // OK
    int Base::* ptr2 = static_cast<int Base::*>(&Derived::x) ; // ill-formed
}

struct Base { int x ; } ;
struct Derived : private Base { } ;

int main()
{
    Derived d ;

    d.x = 0 ; // ill-formed. アクセス指定のため

    int Derived::* ptr = (int Derived::*) &Base::x ; // well-formed.
    d.*ptr = 0 ; // well-formed. C形式のキャストを使ったため、アクセス指定を無視できている
}

C形式のキャストでしかできないキャストとは、クラスのアクセス指定を無視し、しかもクラス階層のナビゲーションを行うキャストのことである。

これらのキャストは、reinterpret_castでもできる。ただし、reinterpret_castは、クラス階層のナビゲーションを行わないので、正しく動かない。static_castは、クラス階層のナビゲーションを行うので、正しく動く。

アクセス指定を無視できるキャストをしなければならない場合というのは、現実には存在しないはずである。アクセス指定を無視するぐらいならば、最初からpublicにしておけばいい。

reinterpret_castは必要である。C++が必要とされる環境では、ポインターの内部的な値を、そのまま別の型のポインターとして使わなければならない場合も存在する。また、既存のCのコードとの互換性のため、const_castも残念ながら必要である。しかし、アクセス指定は、C++に新しく追加された概念であるので、互換性の問題も存在しないし、また、アクセス指定を無視しなければならない場合というのも、全く考えられない。従って、アクセス指定を無視できるという理由で、C形式のキャストを使ってはならない。

そもそも、C形式のキャストは根本的に邪悪であるので、使ってはならない。C形式のキャストの問題点は、できることが多すぎるということだ。安全なキャストも、危険なキャストも、全く同じ文法で行うことができる。C++では、この問題を解決するために、キャストを三つに分けた。static_cast、reinterpret_cast、const_castである。C++では、この新しい形式のキャストを使うべきである。以下にその概要と簡単な使い分けをまとめる。

static_castは、ほとんどが安全なキャストである。static_castは、型変換を安全にするため、値を変えることもある。値を変更するので、static_castは、クラス階層のナビゲーションを行うことができる。派生クラスと基本クラスとの間のポインターの型変換は、ポインターの内部的な値が変わる可能性があるからだ。ポインターの値は、もとより実装依存であるが、最も多くの環境で再現できるコードは、複数の基本クラスを使うものだ。

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

struct Derived : Base1, Base2 { } ;


int main()
{
    Derived d ;
    Derived * ptr = &d ;

    // 基本クラスへのキャスト
    Base1 * base1 = static_cast<Base1 *>( ptr ) ;
    Base2 * base2 = static_cast<Base2 *>( ptr ) ;

    // 派生クラスへのキャスト
    Derived * d1 = static_cast<Derived *>( base1 ) ;
    Derived * d2 = static_cast<Derived *>( base2 ) ;


    // 派生クラスのポインターの値
    std::printf( "Derived *: %p\n", ptr ) ;

    // 基本クラスのポインターの値は同じか？
    std::printf( "Base1 *: %p\n", base1 ) ;
    std::printf( "Base2 *: %p\n", base2 ) ;

    // 派生クラスに戻した場合はどうか？
    std::printf( "from Base1 * to Derived *: %p\n", d1 ) ;
    std::printf( "from Base1 * to Derived *: %p\n", d2 ) ;
}

複数の基本クラスの場合、基本クラスのサブオブジェクトが複数あるので、派生クラスと基本クラスのポインターの間で、同じ値を使うことができない。従って、基本クラスへのポインターにキャストするには、ストレージ上の、その基本クラスのサブオブジェクトを指すポインターを返さなければならない。また、派生クラスへのポインターにキャストするには、値を戻さなければならない。

このため、クラス階層のナビゲーションには、static_castかdynamic_castを用いなければならない。

reinterpret_castは、危険で愚直なキャストである。reinterpret_castは、値を変えない。ただ、その値の型だけを変更する。reinterpret_castは、クラス階層のナビゲーションができない。

const_castは、CV修飾子を外すキャストである。

もし、どのキャストを使うべきなのか判断できない場合は、まずstatic_castを使っておけば問題はない。もし、static_castが失敗した場合、本当にそのキャストは安全なのかということを確かめてから、reinterpret_castを使うべきである。const_castは、既存のCのコードの利用以外に使ってはならない。

メンバーへのポインター演算子（Pointer-to-member operators）

式 .* 式
式 ->* 式

メンバーへのポインター演算子は、「左から右」に評価される。

メンバーへのポインター演算子は、クラスのメンバーへのポインターを使って、クラスのオブジェクトのメンバーにアクセスするための演算子である。クラスのメンバーへのポインターを参照するためには、参照するクラスのオブジェクトが必要である。

.*演算子の第一オペランドには、クラスのオブジェクトを指定する。->*演算子の第一オペランドには、クラスへのポインターを指定する。第二オペランドには、クラスのメンバーへのポインターを指定する。

struct C
{
    int member ;
} ;

int main()
{
    int C::* mem_ptr = &C::member ;

    C c ;
    c.*mem_ptr = 0 ;

    C * ptr = &c ;
    ptr->*mem_ptr = 0 ;
}

メンバー関数の呼び出しの際は、演算子の優先順位に気をつけなければならない。

struct C
{
    void member() {} 
} ;

int main()
{
    void (C::* mem_ptr)() = &C::member ;

    C c ;
    (c.*mem_ptr)() ;

    C * ptr = &c ;
    (ptr->*mem_ptr)() ;
}

なぜならば、メンバーへのポインター演算子の式より、関数呼び出し式の優先順位の方が高いので、c.*mem_ptr()という式は、c.*( mem_ptr() )という式に解釈されてしまう。これは、mem_ptrという名前に対して、関数呼び出し式を適用した後、その結果を、クラスのメンバーへのポインターとして使う式である。このように解釈されることを避けるために、括弧式を使わなければならない。

その他の細かいルールについては、クラスメンバーアクセスと同じである。

乗除算の演算子（Multiplicative operators）

式 * 式
式 / 式
式 % 式

乗除算の演算子は、「左から右」に評価される。

*演算子と/演算子のオペランドは、数値型かunscoped enum型でなければならない。%演算子のオペランドは、整数型かunscoped enum型でなければならない。オペランドには、通常通り数値に関する標準型変換が適用される。式を参照。

*演算子は、乗算を意味する。

/演算子は、除算を意味する。%演算子は、第一オペランドを第二オペランドで割った余りを意味する。第二オペランドの値が0の場合の挙動は未定義である。/演算子の結果の型が整数の場合、小数部分は切り捨てられる。

int main()
{
    2 * 3 ; // 6
    10 / 5 ; // 2
    3 % 2 ; // 1

    3 / 2 ; // 結果は整数型、小数部分が切り捨てられるので、結果は1

    3.0 / 2.0 ; // 結果は浮動小数点数型の1.5
}

以下は間違っている例である。

// このコードは間違っている例
int main()
{
    // ゼロ除算
    1 / 0 ;

    // %演算子のオペランドに浮動小数点数型は使えない
    3.0 % 2.0 ;
}

加減算の演算子（Additive operators）

式 + 式
式 - 式

加減算の演算子は、「左から右」に評価される。

int main()
{
    1 + 1 ; // 2
    1 - 1 ; // 0
}

int main()
{
    int array[3] ;
    int * ptr = &array[1] ;

    // OK
    ptr + 1 ;
    1 + ptr ;
    ptr + (-1) ;
    (-1) + ptr ;
    ptr - ptr ;
    ptr - 1 ;
    ptr - (-1) ;

    // エラー
    ptr + ptr ; // +演算子の両オペランドがポインターとなっている
    1 - ptr ; // -演算子の左オペランドが整数で右オペランドがポインターとなっている
}

int main()
{
    int array[10] ;
    int * ptr = &array[5] ;

    ptr + 2 ; // &array[5 + 2]と同じ
    ptr - 2 ; // &array[5 - 2]と同じ
}

int main()
{
    int array[10] ;
    // 配列の最後の要素を指す
    int * ptr = &array[9] ;

    // 配列の最後の要素のひとつ後ろを指す
    int * one_past_the_last = ptr + 1 ;
    // 配列の最後の要素を指す
    int * last = one_past_the_last - 1 ;
}

int main()
{
    int a[1] ;
    int * p1 = &a[0] ; // 最後の要素

    int * p2 = p1 + 1 ; // OK、最後の一つ後の要素
    int * p3 = p2 + 1 ; // 挙動は未定義 
}

int main()
{
    int array[10] ;
    int * P = &array[2] ;
    int * Q = &array[7] ;

    P - Q ; // 2 - 7 = -5
    Q - P ; // 7 - 2 = 5
}

void f( int * ptr )
{
    ptr == ptr + 0 ; // true
    ptr == ptr - 0 ; // true
}

シフト演算子（Shift operators）

式 << 式
式 >> 式

シフト演算子のオペランドは、整数型かunscoped enum型でなければならない。オペランドには、整数のプロモーションが行われる。結果の型は、整数のプロモーションが行われた後のオペランドの型になる。

左シフト、E1 << E2の結果は、E1をE2ビット、左にシフトしたものとなる。シフトされた後のビットは、0で埋められる。もし、E1の型がunsignedならば、結果の値は、E1 × 2^E2を、E1の最大値+1で剰余したものとなる。

// コメント内の値は2進数である。
int main()
{
    // 1101
    unsigned int bits = 9 ;

    bits << 1 ; // 11010
    bits << 2 ; // 110100
}

E1の型がsignedの場合、E1が負数でなく、E1 × 2^E2が表現可能であれば、その値になる。その他の場合は未定義である。これは、signedな整数型の内部表現が2の補数であるとは保証していないので、このようになっている。

// コメント内の値は2進数である
int main()
{
    // 1101
    int bits = 9 ;

    bits << 1 ; // 11010
    bits << 2 ; // 110100

    -1 << 1 ; // 結果は未定義
}

右シフト、E1 >> E2の結果は、E1をE2ビット、右にシフトしたものとなる。もし、E1の型がunsignedか、signedで正の数ならば、結果の値は、E1 ÷ 2^E2の整数部分になる。

// コメント内の値は2進数である
int main()
{
    // 1101
    unsigned int value = 9 ;

    value >> 1 ; // 110
    value >> 2 ; // 11

    int signed_value = 9 ;

    signed_value >> 1 ; // 110
    signed_value >> 2 ; // 11
}

E1の型がsignedで、値が負数の場合、挙動は未定義である。

int main()
{
    -1 >> 1 ; // 結果は未定義
}

右オペランドの値が負数であったり、整数のプローモーション後の左オペランドのビット数以上の場合の挙動は未定義である。

// この環境では、1バイトは8ビット
// sizeof(unsigned int)は2とする。
// すなわち、この環境では、unsigned intは16ビットとなる。
int main()
{
    unsigned int value = 1 ;
    value << -1 ; // 未定義
    value >> -1 ; // 未定義

    value << 16 ; // 未定義
    value >> 16 ; // 未定義

    value << 17 ; // 未定義
    value >> 17 ; // 未定義
}

シフト演算には、未定義の部分が非常に多い。ただし、多くの現実の環境では、何らかの具体的な意味が定義されていて、時として、そのような未定義の挙動に依存したコードを書かなければならない場合がある。その場合、特定の環境に依存したコードだという正しい認識を持たなければならない。

関係演算子（Relational operators）

式 < 式
式 > 式
式 <= 式
式 >= 式

関係演算子は「左から右」に評価される。

関係演算子のオペランドには、数値型、enum型、ポインター型を使うことができる。各演算子の意味は、以下のようになっている。

A < B

AはBより小さい

A > B

AはBより大きい

A <= B

AはBより小さいか、等しい

A >= B

AはBより大きいか、等しい

結果の型はboolとなる。両オペランドが数値型かenum型の場合、不等号の関係が正しければtrueを、そうでなければfalseを返す。

void f( int a, int b )
{
    a < b ;
    a > b ;
    a <= b ;
    a >= b ;
}

式の結果の型はboolである。

ポインター同士の比較に関しては、未規定な部分が多い。ここでは、規格により保証されていることだけを説明する。

同じ型の二つのポインター、pとqが、同じオブジェクトか関数を指している場合、もしくは、同じ配列の最後の要素のひとつ後の要素を指している場合、もしくは、両方ともnullの場合は、p<=qとp>=qはtrueとなり、p<qとp>qはfalseとなる。

int main()
{
    int object = 0 ;
    int * p = &object ;
    int * q = &object ;

    p <= q ; // true
    p >= q ; // true

    p < q ; // false
    p > q ; // false
}

同じ型の二つのポインター、pとqが、異なるオブジェクトを差しており、そのオブジェクトは同じオブジェクトのメンバーではなく、また同じ配列内の要素ではなく、異なる関数でもなく、あるいは、どちらか片方の値のみがnullの場合、p<q, p>q, p<=q, p>=qの結果は、未規定である。

int main()
{
    int object1 ;
    int object2 ;

    int * p = &object1 ;
    int * q = &object2 ;

    p <= q ; // 結果は未規定
    p >= q ; // 結果は未規定

    p < q ; // 結果は未規定
    p > q ; // 結果は未規定

    p < nullptr ; // 結果は未規定
}

同じ型の二つのポインター、pとqが、同じ配列の要素を指している場合、添字の大きい要素の方が、より大きいと評価される。

int main()
{
    int array[2] ;

    int * p = &array[0] ;
    int * q = &array[1] ;

    p < q ; // true
    p > q ; // false

    p <= q ; // true
    p >= q ; // false

これと同様に、pとqが指しているものが、同じ型の同じクラスのオブジェクトのサブオブジェクトである場合は、同じアクセスコントロール下にある場合、後に宣言されたメンバーの方が、ポインター同士の比較演算では、大きいと評価される。

struct S
{
// 同じアクセスコントロール下
    int a ;
    int b ; // bが後に宣言されている
} ;

int main()
{
    S object ;
    // 同じオブジェクトのサブオブジェクト
    int * p = &object.a ;
    int * q = &object.b ;

    p < q ; // true
    p > q ; // false
} ;

これと似ているが、ただしクラスのメンバーのアクセスコントロールが異なる場合、結果は未規定である。

struct S
{
public :
    int a ;
private :
    int b ;

    void f()
    {
        &a < &b ; // 結果は未規定
    }
} ;

二つのポインター、pとqが、unionの同じオブジェクトの非staticなデータメンバーを指している場合、等しいと評価される。

union Object
{
    int x ;
    int y ;
} ;

int main()
{
    Object object ;
    int * p = &object.x ;
    int * q = &object.y ;

    p < q ; // false
    p > q ; // false

    p <= q ; // true
    p >= q ; // true

    p == q ; // true
}

二つのポインターが、同じ配列内の要素を指している場合、添字の大きい要素を指すポインターが、大きいと評価される。また、これはどちらか片方のポインターが、配列の範囲を超えていても、評価できる。

int main()
{
    int a[2] ;
    int * p1 = &a[0] ;
    int * p2 = &a[1] ;

    p1 < p2 ; // true

    int * p3 = p2 + 1 ; // p3は配列の範囲外を指す

    p1 < p3 ; // OK、結果はtrue
}

voidへのポインター型は、比較することができる。また、片方のオペランドがvoidへのポインター型で、もう片方が別のポインター型である場合、もう片方のオペランドが、標準型変換によってvoidへのポインター型に変換されるので、比較することができる。もし、両方のポインターが、同じアドレスであった場合かnullポインターの場合は、等しいと評価される。それ以外は、未規定である。

int main()
{
    int object = 0 ;

    int * ptr = &object ;
    void * p = ptr ;
    void * q = ptr ;

    p < q ; // false
    p > q ; // false

    p <= q ; // true
    p >= q ; // true

    // 標準型変換によって、別のポインター型とも比較できる
    p <= ptr ; // true    
}

これ以外の比較の結果は、すべて未規定となっている。未定義ではなく、未規定なので、実装によっては、意味のある結果を返すこともある。しかし、実装に依存する挙動なので、移植性に欠ける。

等価演算子（Equality operators）

式 == 式
式 != 式

==演算子（等しい）と、!=演算子（等しくない）は、関係演算子とオペランドや結果の型、評価の方法は同じである。ただし比較の意味は、「等しい」か、「等しくない」かである。

int main()
{
    1 == 1 ; // true
    1 != 1 ; // false

    1 == 2 ; // false
    1 != 2 ; // true
}

同じ型のポインターの場合、ともにアドレスが同じか、ともにnullポインターの場合、trueと評価される。

==演算子は、代入演算子である=演算子と間違えやすいので、注意しなければならない。

void f( int x )
{
    if ( x = 1 ) // 間違い
    {
        // 処理
    } else {
        // 処理
    }
}

この例では、if文の条件式の結果は、代入式の結果となってしまう。それは、1であるので、このif文は常にtrueであると評価されてしまう。

ビット列論理積演算子（Bitwise AND operator）

式 & 式

ビット列論理積演算子は、両オペランドの各ビットごとの論理積（AND）を返す。オペランドは整数型か、unscoped enum型でなければならない。

ビット列排他的論理和演算子（Bitwise exclusive OR operator）

式 ^ 式

ビット列排他的論理和演算子は、両オペランドの各ビットごとの排他的論理和（exclusive OR）を返す。オペランドは整数型か、unscoped enum型でなければならない。

ビット列論理和演算子（Bitwise inclusive OR operator）

式 | 式

ビット列論理和演算子は、両オペランドの各ビットごとの論理和（inclusive OR）を返す。オペランドは整数型か、unscoped enum型でなければならない。

論理積演算子（Logical AND operator）

式 && 式

&&演算子は「左から右」に評価される。

論理積演算子は、オペランドの論理積を返す演算子である。両オペランドはboolに変換される。結果の型はboolである。両方のオペランドがtrueであれば、結果はtrue。それ以外はfalseとなる。

true && true ; // true
true && false ; // false
false && true ; // false
false && false ; // false

第一オペランドを評価した結果がfalseの場合、第二オペランドは評価されない。なぜならば、第一オペランドがfalseであれば、第二オペランドを評価するまでもなく、結果はfalseであると決定できるからである。

bool f() { return false ; }
bool g() { return true ; }

int main()
{
    // g()は呼ばれない。結果はfalse
    f() && g() ;
}

この例では、第一オペランドである関数fの呼び出しはfalseを返すので、第二オペランドの関数gの呼び出しが評価されることはない。つまり、関数gは呼ばれない。

第二オペランドが評価される時、第一オペランドの評価によって生じた値の計算や副作用は、すべて行われている。

int main()
{
    int value = 0 ;

    ++value // 値は1になるので、trueと評価される
        &&
    value ; // 値はすでに1となっているので、trueと評価される
}

論理和演算子（Logical OR operator）

式 || 式

||演算子は、「左から右」に評価される。

論理和演算子は、オペランドの論理和を返す演算子である。両オペランドはboolに変換される。結果の型はboolである。オペランドが片方でもtrueと評価される場合、結果はtrueとなる。両オペランドがfalseの場合に、結果はfalseとなる。

int main()
{
    true || true ; // true
    true || false ; // true
    false || true ; // true
    false || false ; // false
}

第一オペランドを評価した結果がtrueの場合、第二オペランドは評価されない。なぜならば、第一オペランドがtrueであれば、第二オペランドを評価するまでもなく、結果はtrueとなるからである。

bool f() { return true ; }
bool g() { return false ; }

int main()
{
    // g()は呼ばれない。結果はtrue
    f() || g() ;
}

論理積と同じように、第二オペランドが評価される場合、第一オペランドの評価によって生じた値の計算や副作用は、すべて行われている。

条件演算子（Conditional operator）

式 ? 式 : 代入式

条件演算子は「左から右」に評価される。

条件演算子は、三つのオペランドを取る。C++には他に三つのオペランドを取る演算子がないことから、三項演算子といえば、条件演算子の代名詞のように使われている。しかし、正式名称は条件式であり、演算子の名称は条件演算子である。

条件演算子の第一オペランドはboolに変換される。値がtrueであれば、第二オペランドの式が評価され、その結果が返される。値がfalseであれば、第三オペランドの式が評価され、その結果が返される。第二オペランドと第三オペランドは、どちらか片方しか評価されない。

bool cond() ;
int e1() ;
int e2() ;

int main()
{
    true ? 1 : 2 ; // 1
    false ? 1 : 2 ; // 2

    // 関数condの戻り値によって、関数e1、あるいはe2が呼ばれ、その戻り値が返される。
    // e1とe2は、どちらか片方しか呼ばれない。
    cond() ? e1() : e2() ;
}

実は、条件演算子は見た目ほど簡単ではない。特に、結果の型をどのようにして決定するかということが、非常に難しい。ここでは、結果の型を決定する完全な詳細は説明しないが、特に重要だと思われる事を取りあげる。

条件演算子の第二第三オペランドには、結果がvoid型となる式を使うことができる。

void f() {}

int main()
{
    true ? f() : f() ;

    int * ptr = new int ;
    true ? delete ptr : delete ptr ;

    true ? throw 0 : throw 0 ;
}

片方のオペランドがvoidで、もう片方がvoidではない場合、エラーである。

void f() {}
int main()
{
    true ? 0 : f() ; // エラー
    true ? f() : 0 ; // エラー
}

ただし、片方のオペランドがthrow式の場合に限り、もう片方のオペランドに、voidではない式でも使うことができる。結果はprvalueの値で、型はthrow式ではない方のオペランドの型になる。

void f() {}

int main()
{
    // OK
    // xに0を代入する
    int x = true ? 0 : throw 0 ;

    // エラー
    // 戻り値に123を代入しようとしているが、prvalueには代入できない
    (true ? x : throw 0) = 123 ;

    true ? throw 0 : f() ; // OK
}

両オペランドが、ともに同じ値カテゴリーで、同じ型の場合は、条件演算子の結果は、その値カテゴリーと型になる。

int f() { return 0 ; }

int main()
{
    int x = 0 ;

    // 両オペランドとも、lvalueのint型
    // 結果はlvalueのint
    ( true ? x : x ) = 0 ; // lvalueなので代入も可能

    // 両オペランドとも、xvalueのint型
    // 結果はxvalueのint
    true ? std::move(x) : std::move(x) ;

    // 両オペランドとも、prvalueのint型
    // 結果はprvalueのint
    true ? f() : f() ;
}

もし、オペランドの値カテゴリーや型が違う場合、暗黙の型変換によって、お互いの型と値カテゴリーを一致させようという試みがなされる。この変換の詳細は、非常に複雑で、通常は意識する必要はないため、本書では省略する。

代入と複合代入演算子（Assignment and compound assignment operators）

式 代入演算子 式

代入演算子:以下のうちどれか
= *= /= %= += -= >>= <<= &= ^= |=

代入演算子（=）と、複合代入演算子は、「右から左」に評価される。

代入演算子は、左側のオペランドに、右側のオペランドの値を代入する。左側のオペランドは変更可能なlvalueでなければならない。結果として、左側のオペランドのlvalueを返す。

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

初期化と混同しないように注意。

int main()
{
    int x = 0 ; // これは初期化
    x = 0 ; // これは代入
}

=を代入演算子といい、その他の演算子を、複合代入演算子という。

クラスの代入に関する詳細は、クラスオブジェクトのコピーとムーブや、オーバーロードの代入を参照。

複合代入演算子の式、E1 op = E2は、E1 = E1 op E2と同じである。ただし、E1という式は、一度しか評価されない。opには、任意の複合代入演算子の一部が入る。

int main()
{
    int x = 0 ;

    x += 1 ; // x = x + 1と同じ
    x *= 2 ; // x = x * 2と同じ
}

右側のオペランドには、初期化リストを使うことができる。

左側のオペランドがスカラー型の場合、ある型Tの変数をxとすると、x = {v}という式は、x = T(v)という式と同じ意味になる。ただし、初期化リストなので、縮小変換は禁止されている。x = {}という式は、x = T()という式と同じ意味になる。

int main()
{
    int x ;
    x = {1} ; // x = int(1) と同じ
    x = {} ; // x = int()と同じ
    short s ;
    s = {x} ; // エラー、縮小変換は禁止されている。
}

それ以外の場合は、初期化リストを実引数として、ユーザー定義の代入演算子が呼び出される。

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

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

コンマ演算子（Comma operator）

式 , 式

コンマ演算子は、「左から右」に評価される。

コンマ演算子は、まず左のオペランドの式が評価され、次に、右のオペランドの式が評価される。左のオペランドの式を評価した結果は破棄され、右のオペランドの結果が、コンマ演算子の結果として、そのまま返される。結果の型や値、値カテゴリーは、右のオペランドの式を評価した結果と全くおなじになる。

int main()
{
    1, 2 ; // 2
    1, 2, 3, 4, 5 ; // 5
}

右のオペランドの式が評価される前に、左のオペランドの式の値計算や副作用は、すでに行われている。

int f() ;
int g() ;

int main()
{
    int i = 0 ;
    // 左のオペランドのiは、すでにインクリメントされている。
    ++i, i ;
    // 関数gが呼ばれる前に、関数fはすでに呼ばれ終わっている。
    f() , g() ;    
}

コンマが特別な意味を持つ場面では、コンマ演算子を使うには、明示的に括弧で囲まなければならない。コンマが特別な意味を持つ場面には、例えば、関数の実引数リストや、初期化リストなどがある。

void f(int, int, int) {}
int main()
{
    int x ;
    // 括弧が必要
    f( 1, (x=0, x), 2) ;
}

この例では、関数fは三つの引数を取る。二つめの引数は、括弧式に囲まれたコンマ演算子の式である。これは変数xに0を代入した後、そのxを引数として渡している。

定数式（Constant expressions）

定数式（constant expression）とは、値がコンパイル時に決定できる式のことである。定数式かどうかということは、C++のいくつかの場面で、重要になってくる。例えば、配列を宣言する時、要素数は定数式でなければならない。

int main()
{
    // 整数リテラルは定数式
    int a[5] ;

    // const修飾されていて、初期化式が定数式であるオブジェクトは定数式
    int const n = 5 ;
    int b[n] ; // OK

    int m = 5 ; // これは定数式ではない
    int c[m] ; // エラー
}

注意：この解説は、C++14のドラフトN3797を参考にしている。正式なC++14規格では変更される可能性がある。また、C++11ではない。

ある式eを評価した際に、以下に挙げる式を評価しない場合、式eはコア定数式(core constant expression)である。

• this、ただし、eの一部として評価されるconstexpr関数かconstexprコンストラクター内を除く
• リテラルクラスのconstexprコンストラクター、constexpr関数、トリビアルデストラクターの暗黙の呼び出しを除く、関数の呼び出し
• 未定義のconstexpr関数か未定義のconstexprコンストラクターの呼び出し

• 実装の制約を超える式

  実装の制約とは、仮引数やテンプレート仮引数の数の最大値のような、コンピューターが有限であることに起因する様々な制約。

• 未定義の挙動を含む処理

  例えば、符号付き整数のオーバーフローや、一部のポインター演算や、ゼロ除算や、一部のシフト演算など。

• ラムダ式

• lvalueからrvalueへの変換、ただし以下の場合を除く

  • 非volatileのglvalueの整数かenumの型が、初期化前か定数式による初期化後の非volatileのconstオブジェクトを参照する場合

    文字列リテラルによる配列が該当する

  • 非volatileのglvalueが、constexprで定義された非volatileオブジェクトか、そのようなオブジェクトの変更可能なサブオブジェクトを参照する場合
  • 非volatileのリテラル型のglvalueが、式eの初期化にともなって寿命が開始した非volatileオブジェクトを参照する時
• lvalueからrvalueへの変換か、unionの使われていないメンバーかサブオブジェクトを参照するglvalueの変更

• リファレンス型の変数かデータメンバーを参照する名前、ただし、リファレンスが以下のいずれかの方法で初期化された後の場合を除く。

  • 定数式で初期化された場合
  • 式eの評価とともに寿命が始まったオブジェクトの非staticデータメンバー
• cv void *からオブジェクトへのポインター型への型変換
• dynamic_cast
• reinterpret_cast
• 疑似デストラクター呼び出し
• オブジェクトの変更、ただし、式eの評価とともに寿命が始まった非volatileオブジェクトを参照する非volatileのリテラル型のlvalueに対して適用されたものを除く
• ポリモーフィックなクラス型のglvalueをオペランドに指定したtypeid式
• new式
• delete式
• 結果が未規定となる比較演算子と等号、不等号演算子
• throw式

式が整数型かスコープなしenum型で、暗黙にprvalueに型変換でき、型変換した式がコア定数式であるような式を、整数定数式(integral constant expression)という。

このような整数定数式は、配列の宣言の添字や、ビットフィールドや、enum初期化子や、アライメントなどに使える。

T型に変換された定数式(converted constant expression)とは、暗黙にT型のprvalueに変換された式のことで、その変換された式がコア定数式で、暗黙の型変換には、ユーザー定義型変換、lvalueからrvalueへの変換、整数のプロモーション、ナロー変換以外の整数の型変換だけが使われているものを言う。

変換された定数式は、new式、case式、内部型が固定されたenum初期化子、配列の範囲など、整数かenumの非型テンプレート実引数など、型変換が必要な定数式の文脈で使われる。

ここまで解説して、始めて定数式の定義ができるようになる。

定数式(constant expression)とはコア定数式のうち、glvalueのstaticストレージか、関数か、prvalueコア定数式である。

prvalueコア定数式の場合、その値のオブジェクトとサブオブジェクトが、以下の条件をすべて満たす場合のみ、定数式になる。

• リファレンス型の非staticデータメンバーはすべて、staticストレージ上のオブジェクトか、関数を参照していること
• オブジェクトかサブオブジェクトがポインター型の場合、その値は、staticストレージ上のオブジェクトへのアドレスか、staticストレージ上のオブジェクトを超えたアドレスか、関数のアドレスか、nullポインターであること

C++規格は、浮動小数点数の計算精度を規定していないため、C++の実装でコンパイル時と実行時で、浮動小数点数の計算結果が変わったとしても、その実装は規格準拠である。

bool f()
{
    char array[ 1 + int( 1 + 0.2 - 0.1 - 0.1 ) ] ; // コンパイル時評価される
    int size = 1 + int( 1 + 0.2 - 0.1 - 0.1 ) ; // 実行時評価される可能性がある

    return sizeof( array ) == size ;
}

このような関数fの戻り値がtrueかfalseか、C++規格は規定することができない。

リテラルクラス型の式が、整数定数式を必要とする文脈で用いられた場合、その式は文脈上、整数型かスコープなしenum型に暗黙に変換される。その場合に使われる変換関数は、constexprでなければならない。

ラベル文（Labeled statement）

識別子 : 文
case 定数式 : 文
default : 文

文にはラベルを付けることができる。ラベルとは、その文を指す識別子である。文にラベルを付けるための文を、ラベル文（label statement）という。ラベル文には、必ず後続する文が存在しなければならない。

void f()
{
    label :
// エラー、ラベルに続く文がない
} // ブロックの終わり

void g()
{
// OK、ラベルに続く文がある
    label_1 : /* 式文 */ ;
    label_2 : { /* 複合文 */ } ;
}

識別子ラベル（identifier label）は、識別子を宣言する。この識別子は、goto文でしか使えない。

int main()
{
label_1 : ;
label_2 : ;
label_3 : ;

    goto label_2 ;
} 

ラベルの識別子のスコープは、宣言された関数内である。ラベルを再宣言することはできない。ラベルの識別子は、宣言する前にgoto文で使うことができる。

// ラベルのスコープは、宣言された関数内
void f() { label_f : ; }
void g()
{
    goto label_f ; // エラー、この関数のスコープのラベルではない
}

// ラベルを再宣言することはできない
void h()
{
    label_h : ; // label_hの宣言
    label_h : ; // エラー、ラベルの再宣言はできない
}

// ラベルの識別子は、宣言する前にgoto文で使うことができる
void i()
{
// 識別子label_iは、この時点では、まだ宣言されていないが、使うことができる
    goto label_i ;
label_i ;
}

ラベルの識別子は、独自の名前空間を持つので、他の識別子と混同されることはない。

int main()
{
    identifier : ; // ラベルの識別子
    int identifier ; // 変数の識別子

    goto identifier ; // ラベルの識別子が使われる
    identifier = 0 ; // 変数の識別子が使われる
}

caseラベルとdefaultラベルは、switch文の中でしか使うことができない。

int main()
{
    switch(0)
    {
        case 0 : ;
        default : ; 
    }
}

式文（Expression statement）

式opt ;

式文（expression statement）とは、式を書く事のできる文である。文の多くは、この式文に該当する。式文は、セミコロン（;）を終端記号として用いる。式文は、書かれている式を評価する。

int main()
{
    0 ; // 式は0
    1 + 1 ; // 式は1 + 1

    // これは式文ではなく、return文
    return 0 ; 
}

式文は、式を省略することもできる。式を省略した式文を、null文という。

    /* 式を省略*/ ; // null文

    ;;;; // null文が四つ
    ;;;;;;;; // null文が八つ

null文は、評価すべき式がないので、何もしない文である。null文はたとえば、ブロックの終りにラベル文を書きたい場合や、for文やwhile文のようなループを、単に回したい場合などに、使うことができる。

int main()
{
    // 単にループを回すだけのfor文
    for ( int i = 0 ; i != 10 ; ++i ) ;

label : ; // ラベル文には、後続する文が必要。
}

複合文、ブロック（Compound statement or block）

{ ひとつ以上の文opt }

複合文、またはブロックという文は、文をひとつしか書けない場所に、複数の文を書くことができる文である。

void f( bool b )
{
    if ( b )
        /*ここにはひとつの文しか書けない*/ ;

    if ( b )
    {
        // いくらでも好きなだけ文を書くことができる。
    }
}

複合文は、ブロックスコープを定義する。

int main()
{ // ブロックスコープ
    { // 新たなブロックスコープ
    }
}

選択文（Selection statements）

選択文は、複数あるフローのうち、どれかひとつを選ぶ文のことである。

もし、選択文の中の文が、複合文ではなかった場合、その文を複合文で囲んだ場合と同じになる。

void f( bool b )
{
    if ( b )
        int x ;

    x = 0 ; // エラー、xは宣言されていない
}

このコードは、以下のコードと同等であるため、if文の次の式文で、xという名前を見つけられない。

void f( bool b )
{
    if ( b )
    { int x ; }

    x = 0 ; // エラー、xは宣言されていない
}

条件について

条件:
    式
    宣言

条件には、式か宣言を書くことができる。条件は、if文やswitch文だけではなく、while文などでも使われる。

void f()
{
    if ( true ) ;
    if ( int x = 1 ) ;
}

条件に宣言を書くことができる理由は、コードを単純にするためである。

// 何か処理をして結果を返す関数
int do_something() ;

int main()
{
    int result = do_something() ;
    if ( result )
    {
        // 処理
    }
}

条件には宣言を書く事ができるため、以下のように書くことができる。

if ( int result = do_something() )

if ( 条件 ) 文
if ( 条件 ) 文 else 文

int main()
{
    if ( true ) // 一つ目の文が実行される
        /*一つ目の文*/ ;

    if ( false ) // 一つ目の文は実行されない
        /*一つ目の文*/ ;

    if ( true ) // 一つ目の文が実行される
        /*一つ目の文*/ ;
    else
        /*二つ目の文*/ ;

    if ( false ) // 二つ目の文が実行される
        /*一つ目の文*/ ;
    else
        /*二つ目の文*/ ;
}

int main()
{
    if ( false ) // #1
        if ( true ) ; // #2

    else { } // #2のif文に対応するelse
}

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 ; // #1のif文に対応するelse
}

int main()
{
    if ( false ) // #1
    { if ( true ) ; }

    else ; // #1のif文に対応するelse
}

switch( 条件 ) 文 

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(1)
{
    case 1 :
        /* 処理 */ ;
    break ;

    case 2 :
        /* 処理 */ ;
    break ;

    default :
        /* 処理 */ ;
}

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.
}

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
}

int main()
{
    // switch内の文は実行されない
    switch( 0 )
    {
        case 999 :
            std::cout << "hello" << std::endl ;
        break ;
        case 123456 :
            std::cout << "hello" << std::endl ;
        break ;
    }
}

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 ;
    }
}

void f( int const value )
{
    switch( value )
    {
        case 3 :
        case 5 :
        case 7 :
            /* 何らかの処理 */ ;
    }
}

繰り返し文（Iteration statements）

繰り返し文（Iteration statements）は、ループを書くための文である。

繰り返し文の中の文は、暗黙的に、ブロックスコープを定義する。このブロックスコープは、文の実行のループ一回ごとに、出入りする。例えば、

while ( true )
    int i ;

という文は、以下のように書いたものとみなされる。

while ( true )
{ int i ; }

従って、繰り返し文の中の変数は、ループが回されるごとに、生成、破棄されることになる。

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

int main()
{
    while ( true )
    { // 生成、破棄を繰り返す
        C c ;
    }
}

while ( 条件 ) 文

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 ( T t = x ) 文

label:
{
    T t = x;
    if (t)
    {
        文
        goto label;
    }
}

#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 文 while ( 式 ) ;

int main()
{
    // 一度だけ文を実行
    do {
        std::cout << "hello" << std::endl ; 
    } while ( false ) ;


    // 無限ループ
    do {
        std::cout << "hello" << std::endl ; 
    } while ( true ) ;
}

for ( for初期化文 条件opt ; 式opt ) 文

for初期化文:
    式文
    宣言

for ( for初期化文 条件 ; 式 ) 文

{
    for初期化文
    while ( 条件 )
    {
        文
        式 ;
    }
}

int main()
{
    // カウンター用の変数の宣言
    int i = 0 ; 

    while ( i != 10 )
    {
        // 処理
        ++i ;
    }
}

int main()
{
    for ( int i = 0 ; i != 10 ; ++i )
    {
        // 処理
    }
}

int main()
{
    // 条件を省略、for ( ; true ; ) と同じ
    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; 
        // 処理
    }
}

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 ;
}

宣言文（Declaration statement）

ブロック宣言 ;

宣言文は、あるブロックの中に、新しい識別子を導入するための文である。ブロック宣言や、その他の宣言についての詳細は、宣言、宣言子、クラスを参照。

int main()
{
    int a ; // int型の識別子aという変数の宣言

    void f(void) ; // void (void)型の識別子fという関数の宣言

}

自動ストレージの有効期間を持つ変数は、宣言文が実行されるたびに、初期化される。また、宣言されているブロックから抜ける際に、破棄される。

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

int main()
{
    {
        Object object ; // 生成
    } // ブロックスコープから抜ける際に破棄される
}

ジャンプ文を使えば、宣言文の後から前に実行を移すことが可能である。その場合、宣言文によって生成されたオブジェクトは破棄され、宣言文の実行と共に、再び生成、初期化される。

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

int main()
{
label :
    Object object ; // 変数objectが生成、初期化される

    goto label ; // 変数objectは破棄される
}

この例では、Objectクラスの変数objectは、gotoで宣言文の前にジャンプするたびに、破棄されることになる。

goto文やswitch文などのジャンプ文を使えば、自動変数の宣言文を実行せずに、通り越すコードが書ける。

// goto文の例
void f()
{
    // labelという名前のラベル文にジャンプする
    goto label ;

    int value ; // 自動変数の宣言文

label : ;
// valueの宣言文を、実行せずに通り越してしまった。
}

// switch文の例
void g( int value )
{
    switch ( value )
    {
        int value ; // 変数の宣言文

        // 宣言文を飛び越えてしまっている。
        case 0 : break ;
        case 1 : break ;
        default : break ;
    }
}

このようなコードは、ほぼすべての場合、エラーとなるので、書くべきではない。では、変数の宣言文を通り越してもエラーとならない場合は何か。これは、相当の制限を受ける。まず、変数の型は、スカラー型か、trivialなデフォルトコンストラクターとtrivialなデストラクターを持つクラス型でなければならない。また、そのような型にCV修飾子を加えた型と、配列型でもよい。その上で、初期化子が存在していてはならない。

struct POD { } ;
// trivialではないコンストラクターを持つクラス
struct Object { Object() {} } ;

int main()
{
    // 変数の宣言文を飛び越えるgoto文
    goto label ;

    // エラー
    // 変数の型はスカラー型だが、初期化子がある。
    int value = 0; 

    int scalar ; // OK

    // エラー
    // 変数のクラス型がtrivialではないコンストラクターを持っている
    Object object ;

    POD pod ; // OK

label : ;
}

すべてのstatic変数とthread_local変数は、他のあらゆる初期化に先立って、ゼロ初期化される。

int main()
{
    goto label ;
    static int value ; // static変数は必ずゼロ初期化される
label : 
    // この場合、valueは0であることが保証されている
    if ( value == 0 ) ;
}

ブロックスコープ内のstatic変数とthread_local変数は、定数初期化による早期の初期化が行われない場合、宣言に始めて処理が到達した際に、初期化される。

// 定数初期化できない型
struct X
{
    int member ;
    X( int value ) : member( value ) { }
} ;

void f()
{
    // xのゼロ初期化はすでに行われている
    static X x(123) ;
    // この時点で、xの初期化は完了している。
}

ブロックスコープ内のstatic変数とthread_local変数が定数初期化されている場合、実装は早期に初期化を行なってもかまわない。ただし、行われるという保証はない。

// 定数初期化できる型
struct X
{
    int member ;
    constexpr X( int value ) : member(value) { }
} ;

// 定数初期化できない型
struct Y
{
    int member ;
    Y( int value ) : member(value) { }
} ;

int g()
{
    goto label ; // 宣言文を飛び越してしまっている。

    // constexpr指定子が使われていないことに注意
    // xはstatic変数であり、constexprコンストラクターを使っているため、定数初期化である
    static X x( 123 ) ;
    // constexprコンストラクターを使っていないため、定数初期化ではない
    static Y y( 123 ) ;

label : 
    // xは初期化されているかもしれないし、初期化されていないかもしれない
    // yは初期化されていない
    // 両方とも、ゼロ初期化は保証されている
}

この例では、関数gのstaticローカル変数xとyの宣言文には、処理が到達しない。そのため、xとyが初期化されている保証はない。ただし、xは定数初期化なので、実装によっては、早期初期化されている可能性がある。ゼロ初期化だけは常に保証されている。

static変数とthread_local変数は、宣言文の実行のたびに初期化されることはない。

int f( int x )
{
    // 一回だけ初期化される
    // 定数初期化なので、いつ初期化されるかは定められていない
    // ただし、ゼロ初期化はすでに行われている
    static int value = 1 ;
    // この時点で、初期化は完了していることが保証されている
 
    int temp = value ;
    value = x ;

    return temp ;
}

int main()
{
    f(2) ; // 1
    f(3) ; // 2
    f(4) ; // 3
}

もし、static変数とthread_local変数の初期化が、例外がthrowされたことにより終了した場合は、初期化は未完了だとみなされる。そのような場合、次に宣言文を実行した際に、再び初期化が試みられる。

int flag = 0 ;

struct X
{
    X()
    {
        if ( flag++ == 0 )
            throw 0 ;
    }

} ;

void f()
{
    static X x ;
}

int main()
{
    try
    {
        f() ; // 関数fのstaticローカル変数xの初期化は未完了
    }
    catch ( ... ) { }
    f() ; // 関数fのstaticローカル変数xの初期化完了

}

もし、static変数とthread_local変数の宣言文の初期化が再帰した場合、挙動は未定義である。

int f( int i )
{
    static int s = f(2*i); // エラー、初期化が再帰している
    return i+1;
}

この例では、static変数sの初期化が終わらなければ、関数fはreturn文を実行できない。しかし、sの初期化は、再帰している。この場合、挙動は未定義である。

曖昧解決（Ambiguity resolution）

関数形式のキャストを用いた式文と、宣言文とは、文法が曖昧になる場合がある。その場合、宣言文だと解釈される。

int main()
{
    int x = 0 ;
// 不必要な括弧がついた宣言文？　それともキャスト？
    int(x) ;
}

この場合、int(x) ;という文は、キャストを含む式文ではなく、宣言文になる。したがって、上記の例は、変数xの再定義となるので、エラーである。

単純宣言（simple-declaration）

単純宣言（simple-declaration）は、大きく分けて三つに分割できる。

アトリビュート指定子 指定子 宣言子 ;

変数や関数の宣言などは、この単純宣言で書かれることになる。

単純宣言のアトリビュート指定子は、宣言子のエンティティに属する。詳しくは、アトリビュートを参照。

指定子というのは、intやclass C、typedefなどを指す。指定子は複数指定できる。

宣言子は、変数や関数、型などを、ひとつ宣言する。宣言子も複数指定できる。

// int型の変数xの宣言
int // 指定子
x // 宣言子
;

// int const * const型の変数pの宣言
const int // 指定子
* const p // 宣言子
;

// typeという名前のint型を宣言。
typedef int // 指定子
type // 宣言子
;

宣言子を複数指定できることには、注意が必要である。例えば、ひとつの宣言文で、複数の変数を宣言することもできる。

// int型で、それぞれa, b, c, dという名前の変数を宣言
// 宣言子は4個
int a, b, c, d ;

これは、比較的分かりやすい。しかし、ポインターや配列、関数などという型は、宣言子で指定するので、ひとつの宣言文で、複数の宣言子を使うということは、非常に読みにくいコードを書く事もできてしまうのである。

int * a, b, c[5], (*d)(void) ;

この文は非常に分かりにくい。この文を細かく区切って解説すると、以下のようになる。

int // 指定子
* a, // int *型の変数
b, // int型の変数
c[5], // int [5]型の変数
(*d)(void) // int(*)(void)型の変数、引数を取らずint型の戻り値を返す関数ポインター
;

ひとつの宣言文で複数の宣言子を書くことは避けるべきである。

static_assert宣言（static_assert-declaration）

static_assert ( 定数式 , 文字列リテラル ) ;

static_assert宣言は、条件付きのコンパイルエラーを引き起こすための宣言である。static_assertの定数式はboolに変換される。結果がtrueならば、何もしない。結果がfalseならば、コンパイルエラーを引き起こす。いわば、コンパイル時のassertとして働くのである。結果がfalseの場合、C++のコンパイラーは文字列リテラルをエラーメッセージとして、何らかの方法で表示する。

static_assert( true, "" ) ; // コンパイルが通る
static_assert( false, "" ) ; // コンパイルエラー

// コンパイルエラー
// 何らかの方法で、helloと表示される。
static_assert( false, "hello" ) ;

具体的な利用例としては、今、int型のサイズが4バイトであることを前提としたコードを書きたいとする。このコードは当然ながらポータビリティがない。そこで、int型のサイズが4バイトではない環境では、コンパイルエラーになってほしい。これは、以下のように書ける。

static_assert( sizeof(int) == 4, "sizeof(int) must be 4") ;

sizeof(int)が4ではない環境のC++のコンパイラーでは、このコードはコンパイルエラーになる。また、文字列リテラルが、何らかの方法で表示される。

また別の例では、以下のような関数があるとする。

// 仕様：Derived型はBase型から派生されていること
template < typename Base, typename Derived >
void f( Base base, Derived derived )
{
// 処理
}

この関数では、Derivedという型は、Baseという型から派生されていることを前提とした処理を行う。そこで、もしユーザーがうっかり、そのような要求を満たさない型を渡した場合、エラーになって欲しい。これは、以下のように書ける。

#include <type_traits>

template < typename Base, typename Derived >
void f( Base base, Derived derived )
{
    static_assert(
        !std::is_same<Base, Derived>::value // 同じ型でなければtrue
        && std::is_base_of<Base, Derived>::value // DerivedがBaseから派生されていればtrue
        , "Derived must derive Base.") ;

// 処理
}

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

int main()
{
    Base b ; Derived d ;

    f(b, d) ; // OK
    f(b, b) ; // エラー
}

このように、テンプレート引数の型が、あらかじめ定められた要求を満たしていない場合、static_assertを使ってコンパイルエラーにすることもできる。

static_assertの文字列リテラルには、基本ソース文字セットを使うことができる。C++の実装は、基本ソース文字セット以外の文字を、エラーメッセージとして表示する義務がない。我々日本人としては、日本語を使いたいところだが、すべてのコンパイラーに日本語の文字コードのサポートを義務づけるのが現実的ではない。そのため規格では、現実的に最低限保証できる文字しかサポートを義務づけていない。もちろん、コンパイラーがstatic_assertの日本語表示をサポートするのは自由である。しかし、サポートする義務がない以上、static_assertの文字列リテラルに基本ソース文字セット以外の文字を使うのは、ポータビリティ上の問題がある。

// 文字列リテラルが表示されるかどうかは実装依存
static_assert( sizeof(int) == 4, u"このコードはint型のサイズは4であることを前提にしている" ) ;

指定子（Specifiers）

指定子には、ストレージクラス指定子、関数指定子、typedef指定子、friend指定子、constexpr指定子、型指定子がある。

指定子は、組み合わせて使うことができる場合もある。例えば、typedef指定子と型指定子は、組み合わせて使うことができる。その際、指定子の順番には、意味が無い。以下の2行のコードは、全く同じ意味である。

// int型の別名typeを宣言
// typedefはtypedef指定子、intは型指定子、typeは宣言子
typedef int type ;
int typedef type ;

もちろん、指定子と宣言子は違うので、以下はエラーである。

// エラー、*は宣言子。宣言子の後に指定子を書く事はできない
int * typedef type ;

// グローバル名前空間のスコープ
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() ;
}

// インライン関数
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 int integer ;
// これ以降、typedef名integerは、int型とおなじように使える。

integer main()
{
    integer x = 0 ;
    integer y = x ;
}

using 識別子 = 型名 ;

using integer = int ;

// 同じ意味
typedef void (*type)(void) ;
using type = void (*)(void) ;

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 int * type ;

// aの型はint const *
const int * a ; 
// bの型は、int * const 
const type b ; 

const int // 指定子
* a // 宣言子
;

const type // 指定子、typeの型は int *
b // 宣言子
;

constexpr int value = 0 ;

void f()
{
    constexpr std::size_t size = 10 ;
    int a[size] ;
}

struct literal
{
    int a ;
} ;

struct non_literal
{
    non_literal() { }
} ;

int main()
{
    constexpr literal a{} ; // OK
    constexpr non_literal b{} ; // エラー
}

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 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() ;
}

struct point
{
    int x ;
    int y ;

    constexpr S( int x, int y )
        : x(x), y(y)
    { }
} ;

constexpr S s( 10, 10 ) ;

// OK、定数式になる実引数がある
constexpr int f( bool b )
{
    return b ? throw 0 : 0 ;
}

// エラー、絶対に定数式にならない。
constexpr int g( )
{
    throw ;
}

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、ただし通常の関数
}

struct S
{
    constexpr int f() ; // constになる
} ;

constexpr int f() const ;

// OK、リテラル型
struct literal
{
    constexpr int f() { return 0 ; }
} ;

// エラー、リテラル型ではない
struct non_literal
{
    non_literal() { }
    constexpr int f() { return 0 ; }   
} ;

constexpr int a = 0 ;

// エラー、初期化されていない
constexpr int b ;


struct non_literal { non_literal() { } } ;
// エラー、リテラル型ではない
constexpr non_literal c{ } ;

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)() ; // 疑似デストラクターの呼び出し
}

enumの宣言（Enumeration declarations）

enum指定子は、名前付きの定数と型を宣言、定義する。enum（Enumeration）は、歴史的に列挙型と呼ばれている。enum型の名前は、enum名といい、enumが宣言する定数のことを、列挙子（enumerator）と呼ぶ。

// Eはenum名、valueは列挙子
enum E { value = 0 } ;

本書では、enumの機能を四種類に大別して解説する。unscoped enum、scoped enum、enum基底（enum-base）、enum宣言（opaque-enum-declaration）である。

enum指定子:
    enum 識別子opt enum基底opt { 列挙子リスト }

// 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 GlobalEnum { a, b } ;

GlobalEnum e1 = a ;
GlobalEnum e2 = b ;

int main()
{
    enum LocalEnum { c, d } ;
    LocalEnum e1 = c ;
    LocalEnum e2 = d ;
}

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 ; // ->による参照
}

// 識別子あり
enum E { a } ;

// 識別子なし
enum { b } ;

enum struct 識別子 enum基底opt { 列挙子リスト } ;
enum class 識別子 enum基底opt { 列挙子リスト } ;

enum struct scoped_enum_1 { a, b, c } ;
enum class scoped_enum_2 { a, b, c } ;

enum struct E { value } ;

value ; // エラー、scoped enumの列挙子は、このように参照できない
E::value ; // OK

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は宣言されている。
}

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と同じ

enum struct E { value } ;
template < int N > struct C { } ;

void f( E e )
{
    // switch文のcaseラベル
    switch( e )
    { case E::value : ; }

    // 非型テンプレート実引数
    C< E::value > c ;
}

enum基底:
    : 型指定子

enum E : int { } ; // 内部型はint

enum struct Foo : int { } ; // 内部型はint
enum struct Bar : unsigned int { } ; // 内部型はunsigned int

enum Error : float { } ; // エラー、enum基底が整数型ではない

enum struct E { } ; // scoped enumのデフォルトの内部型はint

enum E { } ; // 内部型は定められない。

enum 識別子 enum基底 ;
enum struct 識別子 enum基底opt ;
enum class 識別子 enum基底opt ;

enum struct Foo : unsigned int ; // 内部型はunsigned int
enum class Bar ; // enum基底が省略された場合、内部型はint

enum E1 : int ; // 内部型はint

enum E2 ; // エラー、unscoped enumの宣言では、enum基底を省略してはならない。

// 翻訳単位 1

enum ID : int { /* 自動的に生成される多数の列挙子 */ } ;

// 翻訳単位 2

enum ID : int ; // enum宣言
void f( ID id ) // IDを引数にとる関数
{
    int x = id ;
    id = static_cast<ID>(0) ;
}

// クラスCのヘッダーファイル
// C.h
enum struct ID { /* 自動的に生成される多数の列挙子 */ } ;

class C
{
public :
    // 外部に公開するメンバー

private :
    ID id ;
} ;

// クラスCのヘッダーファイル
// C.h

enum struct ID : int ;

class C { /* メンバー */ } ;

// クラスCのソースコード
// C.cpp

enum struct ID : int  { /* 自動的に生成される多数の列挙子 */ } ;

// メンバーの実装

名前空間（Namespaces）

名前空間とは、宣言の集まりに名前をつける機能である。名前空間の名前は、::演算子によって、宣言を参照するために使うことができる。名前空間は、複数定義することができる。グローバルスコープも、一種の名前空間スコープとして扱われる。

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
}

// 最初の定義
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 識別子 = 名前空間の名前 ;

namespace Perfect_cpp
{
    int x ;
}

int main()
{
   Perfect_cpp::x = 0 ;
}

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 識別子 ;

namespace NS { int name ; }

int main()
{
    name = 0 ; // エラー、名前nameは宣言されていない

    using NS::name ;
    name = 0 ; // NS::nameと解釈される
    NS::name = 0 ; // 明示的なスコープの指定
}

// ブロックスコープ外でもusing宣言は使える
using NS::name ;

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

int main()
{
    using NS::C ; // OK、テンプレート名は指定できる
    using NS::C<int> ; // エラー、テンプレート識別子は指定できない
}

namespace NS { }
using NS ; // エラー

namespace NS
{
    enum struct E { scoped } ;
    enum { unscoped } ;
}

int main()
{
    using NS::unscoped ; // OK、unscoped enumの列挙子
    using NS::E::scoped ; // エラー、scoped enumの列挙子は指定できない
}

int name  ; // グローバルスコープのname
namespace NS { int name ; } // NS名前空間のname

int main()
{
    // ここではまだ、名前が隠されてはいない
    name = 0 ; // ::nameを意味する

    using NS::name ; // このusing宣言は::nameを隠す
    name = 0 ; // NS::nameを意味する
}

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)を呼ぶ
}

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

using NS::C ;

namespace NS
{
    template < typename T >
    class C<T * > { } ; // ポインター型への部分的特殊化
}

int main()
{
    C<int * > c ; // 部分的特殊化が使われる。
}

namespace NS { int value ; }

class Base
{
public :
    void f() { } 
} ;

class Derived : private Base
{
public :
    using Base::f ; // OK、基本クラスのメンバー名
    using NS::value ; // エラー、基本クラスのメンバーではない
} ;

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)を呼ぶ
}

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 ;
} ;

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

int C::value ;

using C::x ; // エラー、これはクラスのメンバー宣言ではない
using C::value ; // エラー、同上

using namespace 名前空間名 ;

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

int main()
{
    using namespace NS ;

    a = 0 ; // NS::a
    f() ; // NS::f
    C c ; // NS::C
}

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 ; // エラー、クラススコープ内では使用できない
} ;

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 ;
}

int name  ; // グローバルスコープのname
namespace NS { int name ; } // NS名前空間のname

int main()
{
    // ここではまだ、名前が隠されてはいない
    name = 0 ; // ::nameを意味する

    using namespace NS ; // 名前探索にNS名前空間内のメンバーを追加
    name = 0 ; // エラー、::nameとNS::nameとで、どちらを使うべきか曖昧
}

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には影響しない
}

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 )
}

リンケージ指定（Linkage specifications）

関数型、外部リンケージを持つ関数名、外部リンケージを持つ変数名には、言語リンケージ（language linkage）という概念がある。リンケージ指定（Linkage specification）は、言語リンケージを指定するための文法である。リンケージ指定と、ストレージクラス指定子のextern指定子とは、別物である。

注意、実装依存の話：言語リンケージは、C++と他のプログラミング言語との間での、関数名や変数名の相互利用のための機能である。異なる言語間で名前を相互利用するには、共通の仕組みが必要である。これには、たとえば名前マングリングを始めとして、レジスターの使い方、引数のスタックへの積み方などの様々な要素がある。しかし、これらはいずれも本書の範疇を超えるので解説しない。

extern 文字列リテラル { 宣言リスト }
extern 文字列リテラル 宣言

標準では、C++言語リンケージと、C言語リンケージを定めている。C++の場合、文字列リテラルは"C++"となり、C言語の場合、文字列リテラルは"C"となる。何も指定しない場合、デフォルトでC++言語リンケージとなる。異なるリンケージ指定がされた名前は、たとえその他のシグネチャーがすべて同じであったとしても、別の型として認識される。その他の文字列がどのような扱いを受けるかは、実装依存である。

// 関数型へのC言語リンケージの指定
extern "C" typedef void function_type() ;
// 関数名へのC言語リンケージの指定
extern "C" int f() ;
// 変数名へのC言語リンケージの指定
extern "C" int value ;

{ }を使う方のリンケージ指定子は、複数の宣言に対して、一括して言語リンケージを指定するための文法である。

// 関数名f, g, hは、すべてC言語リンケージを持つ
extern "C"
{
    void f() ;
    void g() ;
    void h() ;
}

// C_functions.hというヘッダーファイルで宣言されているすべての関数型、関数名、変数名は、C言語リンケージを持つ
extern "C"
{
    #include "C_functions.h"
}

リンケージ指定をしない場合、デフォルトでC++言語リンケージだとみなされる。通常、C++言語リンケージを指定する必要はない。

// デフォルトのC++言語リンケージ
void g() ;
// 明示的な指定
extern "C++" void g() ;

リンケージ指定はネストすることができる。その場合、一番内側のリンケージ指定が使われる。言語リンケージは、スコープをつくらない。

extern "C"
{
    void f() ; // C言語リンケージ
    extern "C++"
    {
        void g() ; // C++言語リンケージ
    }
}

リンケージ指定は、名前空間スコープの中でのみ、使うことができる。ブロックスコープ内などでは使えない。

C言語リンケージは、クラスのメンバーに適用しても無視される。

extern "C"
{
    class C
    {
        void f() ; // C++言語リンケージ
    } ;
}

C言語リンケージを持つ同名の関数が、複数あってはならない。これにより、C言語リンケージを持つ関数は、オーバーロードできない。

extern "C"
{
// エラー、C言語リンケージを持つ同名の関数が複数ある
    void f(int) ;
    void f(double) ;
}

// OK、互いに異なる言語リンケージを持つ
void g() ;
extern "C" void g() ;

このルールは、たとえ関数が名前付きの名前空間の中で宣言されていても、同様である。

namespace A
{
    extern "C" void f() ;
}

namespace B
{
    extern "C" void f() ; // エラー、A::fとB::fは同じ関数を参照する
    void f() ; // OK、C++言語リンケージを持つ
}

このように、たとえ名前空間が違ったとしても、C言語リンケージを持つ関数は、名前が衝突してはならない。これは、名前空間という仕組みが存在しないC言語からでも使えるようにするための仕様である。ただし、C言語リンケージを持つ関数を、C++側から、名前空間の中で宣言して、通常通り使うことはできる。

namespace NS
{
    extern "C" void f() { }
}

int main()
{

    NS::f() ; // OK
}

これにより、C言語で書かれた関数を、何らかの名前空間の中にいれて、C++側から使うこともできる。

// ヘッダーファイル、C_functions.hは、C言語で書かれているものとする
namespace obsolete_C_lib
{
    extern "C"
    {
        #include "C_functions.h"
    }
}

アトリビュート（Attributes）

NOTE: アトリビュートの解説は、C++14となる予定の現時点での最新ドラフト、N3797を参考にしている。

アトリビュート(attribute)は、属性とも呼ばれ、ソースコードに追加的な情報を指定するための文法である。

アトリビュートの文法は、以下のようになる。

[[ アトリビュートリスト ]]

アトリビュートは、文法上、実に様々な箇所に書くことができる。アトリビュートリストには、アトリビュート用のトークンを指定することができる。このトークンは、アトリビュートの中だけで通用する識別子であり、予約語ではない。

アトリビュートは、特定のC++実装の独自機能を、独自の文法を使わずに表現するために追加された。また、C++規格でも、アトリビュート用の機能をいくつか定めている。

// OK
alignas(16) char buf[16] ;

struct S
{
// OK
    alignas(16) char buf[16] ;
} ;

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 struct alignas(16) E1 : int
{ value } ;
enum alignas(16) E2
{ value } ;

template < typename ... Types >
struct alignas( Types ... ) // パック展開
S { } ;

// 代入式
alignas( 4, 8, 16 ) char b1[128] ;
// 型
alignas( short, int, long ) char b2[128] ;

// 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( 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 ; 

// この関数は決してreturnしない
[[ noreturn ]] void f()
{
// なぜならば、必ずthrowするからだ
    throw 0 ;
}

void f() ; // エラー、最初の宣言だがnoreturnがない
[[ noreturn ]] void f() ;

型名（Type names）

キャスト、sizeof、alignof、new、typeidでは、型の名前を指定する。これには、型名が用いられる。型名とは、変数や関数を宣言する場合と同じ指定子と宣言子だが、名前を省略したものである。

int value ;         // int型の変数
int                 // 型名
int array[10] ;     // 配列型の変数
int [10]            // 型名
int (*p)(void) ;    // 関数ポインター型の変数
int (*)(void)       // 型名

ただし、あまりにも複雑な型名は、typedefやエイリアス宣言でtypedef名を定義した方が分かりやすい。

曖昧解決（Ambiguity resolution）

宣言文は、文法上、曖昧になる場合がある。これは、通常気にする必要はない。ただし、まれにこの曖昧性に引っかかり、不可解なコンパイルエラーを引き起こす可能性がある。

仮引数名に無駄な括弧のある関数の宣言と、初期化式に関数形式のキャストを用いた変数の宣言は曖昧である。その場合、=が使われていると、初期化であるとみなされる。また、仮引数の周りの不必要な括弧は取り除かれる。その結果、変数の宣言のつもりで書いたコードが、関数の宣言とみなされてしまうことがある。

struct S { S(int) { } } ;

int main()
{
    double d = 0.0 ;

    S w( int(d) ); // S(int)型の関数の宣言、dは仮引数名、無駄な括弧
    S x( int() ); // S(int)型の関数の宣言、仮引数名の省略、無駄な括弧

    S y( static_cast<int>(d) ); // S型の変数yの宣言
    S z = int(d); // S型の変数zの宣言
}

一般に、この曖昧解決の結果、変数を宣言したいのに、関数の宣言とみなされてしまい、コンパイルエラーになることがある。この文法上の曖昧性を避けるためには、static_castなどの他のキャストを使うか、=を使った初期化に書き換える必要がある。

関数形式のキャストと型名は、曖昧になることがある。例えば、int()というコードは、関数形式のキャストにも、int(void)型の関数の型名にも解釈できる。この場合、型名が期待される場所では、常に型名として解釈される。

template < int N > struct C { } ;

int main()
{
    int x = int() ; // OK、intは関数形式のキャスト
    C<int()> ; // エラー、int()は型名
    C<int(0)> ; // OK
    
    sizeof(int()) ; // エラー、int()は型名
    sizeof(int(0)) ; // OK
}

宣言子の意味（Meaning of declarators）

単純宣言は、指定子と宣言子で構成される。

指定子 宣言子 ;

宣言子は、必ず、識別子を持たなければならない。この識別子を、規格上では、宣言識別子（declarator-id）と名付けている。この識別子は、宣言される名前となる。

int name1 ; // name1はint型の変数の名前
int * name2 ; // name2 はint *型の変数の名前
int name3(void) ; // name3 はint (void)型の関数の名前

static, thread_local, extern, register, mutable, friend, inline, virtual, typedefといった指定子は、この宣言子の識別子に適用される。

宣言子の識別子の意味は、指定子と宣言子の組み合わせによって決定される。

// 識別子aはint型の変数
int     // 指定子
a ;     // 宣言子、
// 識別子bはint型のtypedef名
typedef int // 指定子
b ;         // 宣言子

変数、関数、型は、すべてこの指定子と宣言子の組み合わせによって宣言される。宣言子は、識別子の他にも、様々な文法があり、それによって、指定子の型を変更する。これには、ポインター、リファレンス、メンバーへのポインター、配列、関数、デフォルト実引数がある。

* CV修飾子opt 識別子

int * a ; // intへのポインター型

typedef const int * type1 ;
typedef int const * type2 ;
typedef int * const type3 ;

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なポインター

int & * ptr_to_ref ; // エラー、リファレンスへのポインターは存在しない

void func( void ) { } // 型はvoid (void)

void g()
{
    void (*ptr_func)( void ) = &func ;
    ptr_func() ; // 関数呼び出し

    int array[5] ; // 型はint [5]
    int (*ptr_array)[5] = &array ;
}

& 識別子
&& 識別子

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を代入
}

void f( int obj )
{
    int const & a = obj ; // OK、int constへのリファレンス
    int & const b = obj ; // エラー、リファレンスへの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 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
}

int obj ;

// クラスの例
struct S
{
    int & ref ;
    S() : ref(obj) { }
} ;

// extern指定子の例
// このリファレンスは単なる宣言。
// 実体はどこか別の場所で定義されている
extern int & external_ref ;

// 関数の仮引数と戻り値の型の例
int & f( int & ref ) { return ref ; }

void f()
{
    int * ptr = nullptr ;
    int & ref = *ptr ; // エラー、nullポインターを参照している
}

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 &&
}

::opt ネストされたクラス名 * CV修飾子opt 識別子

struct S
{
    void func(void) { }
    int value ;
} ;

void ( S:: * ptr_func )( void ) = &S::func ;
int S:: * ptr_value = &S::value ;

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 ; // エラー

識別子 [ 定数式opt ] 

int a[5] ; // 要素数5のint型の配列
float b[123] ; // 要素数123のfloat型の配列

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型

int a[3][5][7] ;

int a[0] ; // エラー
int b[-1] ; // エラー

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]

識別子 ( 仮引数リスト ) 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] ;

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 ) { } // 定義

関数の定義（Function definitions）

関数の定義:
    関数の宣言 関数の本体

関数の本体:
    コンストラクター初期化子opt 複合文
    関数tryブロック
    = default ;
    = delete ;

関数の定義とは、関数の宣言に続けて、関数の本体の書かれている関数宣言である。

void f() ; // 宣言
void f() {} // 定義

void // 指定子
g() // 宣言子
{ } // 関数の本体

関数は、名前空間スコープか、クラススコープの中でのみ、定義できる。

// グローバル名前空間スコープ
void f() {}
// クラススコープ
struct S { void f() {} } ;

void g()
{
    void h(){} ; // エラー、関数のブロックスコープの中では定義できない
}

コンストラクター初期化子は、クラスのコンストラクターで用いる。詳しくは、クラスのコンストラクターと、クラスの初期化を参照。

関数の定義には、複合文の他に、関数tryブロックを使うこともできる。

void f()
try
{
// 関数の本体
}
catch ( ... )
{
// 例外ハンドラー
} 

関数tryブロックについて詳しくは、例外を参照。

関数の本体では、__func__（ダブルアンダースコアであることに注意）という名前の変数が、以下のようにあらかじめ定義されている。

static const char __func__[] = "関数名" ;

「関数名」とは、実装依存の文字列である。C++規格では、この実装依存の文字列の意味は、何も規定されていない。この機能はC言語から取り入れられたものである。C99規格では、関数本体の属する関数の名前を表す、実装依存の文字列とされている。いずれにせよ、具体的な文字列については、何も規定されていない。

関数の宣言 = default ;

struct S
{
    S() = default ; // default定義
    S(int){ } 
} ;

関数の宣言 = 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 ; // エラー
}

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] ; // エラー
}

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、ムーブはできる
}

初期化子（Initializers）

宣言子の宣言する変数に対して、初期値を指定することができる。この初期値を指定するための文法を、初期化子（Initializer）という。この初期化子の項目で解説している初期化は、宣言文以外にも、関数の仮引数を実引数で初期化することや、関数の戻り値の初期化、new式やクラスのメンバー初期化子などにも適用される。

初期化子の文法と意味について解説する前に、まず基本的な三つの初期化について解説しなければならない。ゼロ初期化、デフォルト初期化、値初期化である。

static int x ; // 0で初期化される
static float f ; // 0がfloat型に変換されて初期化される
static int * ptr ; // 0がnullポインターに変換されて初期化される

struct Base { int x ; } ;
struct Derived : Base
{
    int y ;
} ;

// 非staticなデータメンバー、基本クラスのサブオブジェクトが、それぞれゼロ初期化される
static Derived d ;

union U
{
    int x ;
    double d ; 
} ;

class A
{
public :
    A() { }
} ;

class B
{
private :
    B() { }
} ;

int main()
{
    A a ; // デフォルトコンストラクターが呼ばれる
    B b ; // エラー、デフォルトコンストラクターにアクセスできない
}

int main()
{
    int x ; // 初期化は行われない
}

struct X { } ;
struct Y { Y() { } } ;

int main()
{
    int const a ; // エラー、intはユーザー定義コンストラクターを持つクラス型ではない
    X const b ; // エラー、Xはユーザー定義コンストラクターを持つクラス型ではない

    Y const c ; // OK
}

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

struct A
{
    A() { }
} ;

struct B
{
// ユーザー提供のコンストラクターがない
// 暗黙に定義されたコンストラクターはトリビアルではない
    A a ;
    int x ;
} ;

struct S
{
    S() : x(1) { }
    int x ;
} ;

S s ; // staticストレージの期間を持つオブジェクト

int main()
{
    int x() ; // int (void)型の関数xの宣言
}

struct S
{
    S()
    : x() // メンバー初期化子
    { }
    int x ;
}

int main()
{
    new int() ; // new、初期化子として空の括弧
    int() ; // 関数形式のキャスト
}

struct S { } ;

int main()
{
    S s ; // デフォルト初期化される
}

int main()
{
    int i ; // 値は不定
    double d ; // 値は不定
}

// グローバル名前空間
int x ; // staticストレージ、ゼロ初期化される
thread_local int y ; // threadストレージ、ゼロ初期化される

T x = a ;

T x(a) ;
T x{a} ;

// 目的の型はT
// 元の型はint
T x = 0 ;

// 目的の型はT
// 元の型は存在しない（ひとつの初期化リスト）
T x = { } ;
T x({ }) ;
T x{ } ;

// 目的の型はT
// 元の型は存在しない（括弧で囲まれた式リスト）
T x(1, 2, 3)

// リスト初期化される
T x = { } ;
T x({ }) ;
T x{ } ;

// int (void)型の関数xの宣言
// int x(void) ; と同じ
int x() ; 

 // 関数形式のキャスト
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 *に変換できない
}

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]

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

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 = { } ;

int x[100] = {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 } }
} ;

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" ;

// 要素数は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 } ;

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 と同じ、参照先は変わらない
}

// 関数の仮引数
void f( int & ) ;

// 関数の戻り値の型
int & g() ;
auto g() -> int & ;

// クラス定義のクラスメンバーの宣言
struct S { int & ref ; } ;

// extern指定子（refは別の場所で定義されている）
extern int & ref ;

// 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

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;
}

#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修飾子が少ないので、リファレンス互換ではない
} ;

// int &に暗黙的に変換できるクラス
struct Integer
{
    int object ;
    operator int & () { return object ; }
} ;

int main()
{
    Integer object ;
    int & ref = object ; // OK、暗黙的にリファレンス互換なlvalueに変換できる
} ;

#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() ;
}

#include <utility>

int f() { return 0 ; }

int main()
{
    // OK、prvalueで初期化できる
    int && prvalue_ref = f() ;

    // OK、xvalueで初期化できる
    int object ;
    int && xvalue_ref = std::move( object ) ;
}

int object ;
int && ref = object ; // エラー、lvalueでは初期化できない

#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での初期化
}

#include <utility>

// int &&に暗黙的に変換できるクラス
struct Integer
{
    int object ;
    operator int && () { return std::move(object) ; }
} ;

int main()
{
    Integer object ;
    int && ref = object ; // OK、暗黙的にリファレンス互換なrvalueに変換できる
}

int main()
{
    int && ref = 0 ; // 一時オブジェクトが生成される
}

T x( { } ) ; // 直接初期化
T x{ } ; // 直接初期化
T x = { } ; // コピー初期化

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 ) ;

トリビアルにコピー可能なクラス（trivially copyable class）

トリビアルにコピー可能なクラス（trivially copyable class）とは、クラスのオブジェクトを構成するバイト列の値を、そのままコピーできるクラスのことである。詳しくは、型を参照。

あるクラスがtrivially copyable classとなるには、以下の条件をすべて満たさなければならない。

非trivialな、コピーコンストラクター、ムーブコンストラクター、コピー代入演算子、ムーブ代入演算子を持たないこと。trivialなデストラクターを持っていること。

つまり、これらの特別なメンバー関数を、ユーザー定義してはならない。また、virtual関数やvirtual基本クラスも持つことはできない。trivialの詳しい定義については、クラスオブジェクトのコピーとムーブを参照。

ここで、「持たない」ということは、delete定義によって削除しても構わないということである。

struct A
{
    A( A const & ) =delete ;
    A( A && ) = delete ;
    A & operator = ( A const & ) = delete ;
    A & operator = ( A && ) = delete ;

    // trivialなデストラクターは、「持って」いなければならない

    int x ;
} ;

また、アクセス指定子が異なるメンバーを持っていても構わない。

上記のクラスAは、コピーもムーブもできないクラスであるが、trivially copyable classである。

トリビアルクラス（trivial class）

トリビアルクラス（trivial class）とは、trivially copyable classの条件に加えて、非トリビアルデフォルトコンストラクターを持たないクラスである。

標準レイアウトクラス（standard-layout class）

標準レイアウトクラス（standard-layout class）の詳しい説明については、クラスのメンバーを参照。

あるクラスが標準レイアウトクラスとなるためには、以下の条件をすべて満たさなければならない。

標準レイアウトクラスではない非staticメンバーをもたない。また、そのようなクラスへの配列やリファレンスも持たない。

virtual関数とvirtual基本クラスを持たない。

非staticデータメンバーは、すべて同じアクセス指定子である。

// 標準レイアウトクラス
struct S
{
// すべて同じアクセス指定子
    int x ;
    int y ;
    int z ;

// staticデータメンバーは、別のアクセス指定子でもよい
private :
    static int data ;
} ;
int S::data ;

標準レイアウトクラスではないクラスを基本クラスに持たない。

基本クラスに非staticデータメンバーがある場合は、クラスは非staticデータメンバーを持たない。クラスが非staticデータメンバーを持つ場合は、基本クラスは非staticデータメンバーを持たない。つまり、クラスとその基本クラス（複数可）の集合の中で、どれかひとつのクラスだけが、非staticなデータメンバーを持つことが許される。

struct Empty { } ;
struct Non_empty { int member ; } ;

// 以下は標準レイアウトクラス
struct A
// 基本クラスに非staticデータメンバーがある場合
    : Non_empty
{
// 非staticデータメンバーを持たない
} ;

struct B
// 基本クラスは非staticデータメンバーを持たない
    : Empty
{
// 非staticデータメンバーを持つ場合
    int data ;
} ;

// 以下は標準レイアウトクラスではない
// 基本クラスもクラスCも非staticデータメンバーを持っている
struct C
    : Non_empty
{
    int data ;
} ;

最初の非staticデータメンバーと、基本クラスとで、同じ型を使わない。

// 標準レイアウトクラスではない例
struct A { } ;
struct B
// 基本クラス
    : A
{
    A a ; // 最初の非staticデータメンバー
    int data ;
} ;

// 最初の非staticデータメンバーでなければよい
struct C : A
{
    int data ;
    A a ;
} ;

この制限は、基本クラスとデータメンバーとの間で、アドレスが重複するのを防ぐためである。

struct A { } ;
struct B : A { A a ; } ;

B obj ;

A * p1 = &obj ; // 基本クラスのサブオブジェクトへのアドレス
A * p2 = &obj.a ; // データメンバーへのアドレス

// p1 != p2が保証される

このような場合、もし、クラスBが標準レイアウトクラスであれば、基本クラスのサブオブジェクトへのアドレスと、データメンバーのサブオブジェクトへのアドレスが重複してしまう。つまり、p1とp2が同じ値になってしまう。異なるアドレスを得られるためには、このようなクラスを標準レイアウトクラスにすることはできない。

標準レイアウトクラスのうち、structとclassのキーワードで定義されるクラスを、特に標準レイアウトstructと言う。unionキーワードで定義されるクラスを、特に標準レイアウトunionという。

POD構造体（POD struct）

PODとは、Plain Old Dataの略である。これは、C言語の構造体に相当するクラスである。C++11では、クラスがPODの条件を満たした際に保証される動作を、trivially copyable classと、標準レイアウトクラスの二つの動作に細分化した。そのため、C++11では、特にPODにこだわる必要はない。

クラスがPODとなるためには、trivial classと標準レイアウトクラスの条件を満たし、さらに、PODではないクラスを非staticデータメンバーに持たないという条件が必要になる。

クラス名（Class names）

クラス宣言は、クラス名をスコープに導入する。クラス名は外側のスコープの名前を隠す。

もし、クラス名が宣言されたスコープ内で、同名の変数、関数、enumが宣言された場合は、どちらの宣言もスコープに存在することになる。その場合、クラス名を使うには、複雑型指定子を使う以外に方法がなくなる。

void name() { }
class name { } ;

name n ; // エラー、nameは関数名
class name n ; // OK、複雑型指定子

クラスのメンバー（Class members）

クラスのメンバー指定には、宣言文、関数の定義、using宣言、static_assert宣言、テンプレート宣言、エイリアス宣言を書くことができる。

struct Base { int value ; } ;

struct S : Base
{
    int data_member ; // 宣言文
    void member_function() { } // 関数の定義
    using Base::value ; // using宣言
    static_assert( true, "this must not be an error." ) ; // static_assert宣言
    template < typename T > struct Inner { } ; // テンプレート宣言
    using type = int ; // エイリアス宣言
} ;

このうち、クラスのメンバーとなるのは、データメンバーとメンバー関数、ネストされた型名、列挙子である。

struct S
{
    int x ; // データメンバー
    void f() { } ; // メンバー関数
    using type = int ; // ネストされた型名
    enum { id } ; // 列挙子
} ;

データメンバーは、俗にメンバー変数とも呼ばれている。クラス定義内で、変数の宣言文を書くと、データメンバーとなる。

クラスのメンバーを、クラスの定義内で複数回宣言することはできない。ただし、クラス内のクラスとenumに関しては、前方宣言することができる。

class Outer
{
    void f() ;
    void f() ; // エラー、複数回の宣言

    class Inner ; // クラス内クラスの宣言
    class Inner { } ; // OK、クラス内クラスの定義

    enum struct E : int ; // クラス内enumの宣言
    enum struct E : int { id } ; // OK、クラス内enumの定義
} ;

クラスは、}で閉じた所をもって、完全に定義されたとみなされる。たとえ、メンバー関数が定義されていなくても、クラス自体は完全に定義された型となる。

メンバーはコンストラクターで初期化できる。詳しくはコンストラクターを参照。メンバーは初期化子で初期化できる。詳しくは、staticデータメンバーと、基本クラスとデータメンバーの初期化を参照。

struct S
{
    S() : x(0) { } // コンストラクター
    int x = 0 ; // 初期化子
    static int data ;
} ;

int S::data = 0 ; // 初期化子

メンバーは、externやregister指定子と共に宣言することはできない。メンバーをthread_local指定子と共に宣言する場合は、static指定子も指定しなければならない。

struct S
{
    extern int a ; // エラー
    register int b ; // エラー
    thread_local int c ; // エラー

    // OK、staticと共に宣言している
    static thread_local int d ;
} ;

thread_local int S::d ; // 定義

基本的に、クラス名と同じ名前のメンバーを持つことはできない。これには、一部の例外が存在するが、本書では解説しない。

struct name
{
    static int name ;       // エラー
    void name() ;           // エラー
    static void name() ;    // エラー
    using name = int ;      // エラー
    enum { name } ;         // エラー    
    union { int name } ;    // エラー
} ;

unionではないクラスにおいて、同じアクセス指定下にある非staticデータメンバーは、クラスのオブジェクト上で、宣言された順番に確保される。つまり、先に宣言されたデータメンバーは、後に宣言されたデータメンバーよりも、上位のアドレスに配置される。ただし、実装は必要なパディングを差し挟むかもしれないので、後のデータメンバーが、先のデータメンバーの直後に配置されるという保証はない。

struct S
{
public :
// 同じアクセス指定下にある非staticデータメンバー
    int x ;
    int y ;
} ;

int main()
{
    S s ;
    int * p1 = &s.x ;
    int * p2 = &s.y ;

    // この式は、必ずtrueとなる
    p1 < p2 ;
    // この式がtrueとなる保証はない
    p1 + 1 == p2 ;
}

アクセス指定子が異なる非staticデータメンバーの配置に関しては、未規定である。

標準レイアウトstructのオブジェクトへのポインターは、reinterpret_castによって変換された場合、クラスの最初のメンバーへのポインターに変換できる。また、その逆も可能である。

struct S { int x ; } ;

int main()
{
    S s ;
    S * p1 = &s ;
    int * p2 = &s.x ;

    // 以下の2式は、trueとなることが保証されている
    p1 == reinterpret_cast< S * >( p2 ) ;
    p2 == reinterpret_cast< int * >( p1 ) ;
}

// 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 ;
} ;

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番目のメンバーは、レイアウト互換ではない
}

メンバー関数（Member functions）

クラスの定義内で宣言される関数を、クラスのメンバー関数（member function)という。メンバー関数はstatic指定子と共に宣言することができる。その場合、関数はstaticメンバー関数となる。staticメンバー関数ではないメンバー関数のことを、非staticメンバー関数という。ただし、friend指定子と共に宣言された関数は、メンバー関数ではない。

struct S
{
    void non_static_member_function() ; // 非staticメンバー関数
    static void static_member_function() ; // staticメンバー関数

    friend void friend_function() ; // これはメンバー関数ではない
} ;

メンバー関数は、クラス定義の内側でも外側でも定義することができる。クラス定義の内側で定義されたメンバー関数を、inlineメンバー関数という。これは、暗黙的にinline関数となる。クラス定義の外側でメンバー関数を定義する場合、クラスと同じ名前空間スコープ内で定義しなければならない。

struct S
{
    // inlineメンバー関数
    void inline_member_function()
    { /*定義*/ }

    void member_function() ; // メンバー関数の宣言
} ;

// クラスSと同じ名前空間スコープ
void S::member_function()
{ /*定義*/ }

クラス定義の外側でinlineメンバー関数の定義をすることもできる。それには、関数宣言か関数定義で、inline指定子を使えばよい。

struct S
{
    inline void f() ; 
    void g() ;
} ;

void S::f(){ }
inline void S::g() { }

クラス定義の外側でメンバー関数を定義するためには、メンバー関数の名前を、::演算子によって、クラス名で修飾しなければならない。

struct S
{
    void member() ;
} ;

void S::member(){ }

ローカルクラスでは、メンバー関数をクラス定義の外側で宣言する方法はない。

struct Object
{
    void f(){ }
    void g()
    {
        // 関数呼び出し
        f() ;
    }
} ;

int main()
{
    Object object ;
    // クラスのメンバーアクセス演算子と、関数呼び出し
    object.f() ;
}

struct S
{
    void none() ;
    void c() const ; // constメンバー関数
    void v() volatile ; // volatileメンバー関数
    void cv() const volatile ; // const volatileメンバー関数
} ;

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 *
    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 ; }
} ;

class X
{
    int value ;

    void f() const
    {
        this->value = 0 ; // エラー
    }
} ;

class X
{
    int value ;


    void f() const
    {
        X const * ptr = this ;
        ptr->value = 0 ; // エラー
    }
} ;

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修飾子を取り除くことはできない
}

struct X
{
    void c() const // constメンバー関数
    {
        // thisの型はX const *
        nc() ; // エラー、CV修飾子を取り除くことはできない
    } ;

    void nc() // 非constメンバー関数
    {
        // thisの型はX *
        c() ; // OK、CV修飾子を付け加えることはできる
    }
} ;

staticメンバー（Static members）

クラスのデータメンバーやメンバー関数は、クラス定義内で、static指定子と共に宣言することが出来る。そのように宣言されたメンバーを、クラスのstaticメンバーという。

struct S
{
    static int data_member ;
    static void member_function() ; 
} ;
int S::data_member ;

クラスXのstaticメンバーsは、::演算子を用いて、X::sのように参照することで、使うことができる。staticメンバーは、クラスのオブジェクトがなくても参照できるので、クラスのメンバーアクセス演算子を使う必要はない。しかし、クラスのメンバーアクセス演算子を使っても参照できる。

struct X
{
    static int s ;
} ;

int X::s ;

int main()
{
    // ::演算子による参照
    X::s ;

    // クラスのメンバーアクセス演算子でも参照することはできる
    X object ;
    object.s ;
}

クラスのメンバー関数内では、非修飾名を使った場合、クラスのstaticメンバー、enum名、ネストされた型が名前探索される。

struct X
{
    void f()
    {
        s ; // X::s
        value ; // X::value
        type obj ; // X::type
    }

    static int s ;
    enum { value } ;
    typedef int type ;
} ;
int X::s ;

staticメンバーにも、通常通りのアクセス指定が適用される。

struct S
{
    // エラー、同じ名前と仮引数のstatic関数と非static関数が存在する
    void same() ;
    static void same() ; 
} ;

struct S
{
    static int member ;
} ;
int S::member ;

int main()
{
    S a, b, c, d, e ;
    // すべて同じオブジェクトを参照する
    a.member ; b.member ; c.member ; e.member ;
}

struct S
{
    static int member ;
} ;

// クラス名 :: メンバー名
int S::member = 0 ;

struct S
{
    static const int constant_expression = 123 ; // 定数式
    static const int non_constant_expression ; // 宣言、定数式ではない
} ;
const int S::non_constant_expression = 123 ; // 定義

struct S
{
    static constexpr int constant_expression = 123 ; // 定数式
} ;

union（Unions）

unionというクラスは、クラスキーにunionキーワードを用いて宣言する。unionでは、非staticデータメンバーは、どれかひとつのみが有効である。これは、unionのオブジェクト内では、非staticデータメンバーのストレージは、共有されているからである。unionのサイズは、非staticデータメンバーのうち、最も大きな型を格納するのに十分なサイズとなる。

union U
{
    int i ;
    short s ;
    double d ;
} ;

int main()
{
    U u ;
    u.i = 0 ; // U::iが有効
    u.s = 0 ; // U::sが有効、U::iは有効ではなくなる

}

この例では、unionのサイズは、int, short, doubleのうちの、最もサイズが大きな型を格納するのに十分なだけのサイズである。データメンバーであるi, s, dは、同じストレージを共有している。

unionと、標準レイアウトクラスについては、クラスを参照。

unionは、通常のクラスに比べて、いくらか制限を受ける。unionはvirtual関数を持つことができない。unionは、基本クラスを持つことができない。unionは基本クラスになれない。unionは、リファレンス型の非staticデータメンバーを持つことができない。unionの非staticデータメンバーのうち、初期化子を持てるのは、ひとつだけである。

// エラーの例

// エラー、virtual関数を持てない
union U1 { virtual void f() { } } ;
// エラー、基本クラスを持てない
struct Base { } ;
union U : Base { } ;
// エラー、基本クラスになれない
union Union_base { } ;
union Derived : Union_base { } ;
// エラー、リファレンス型の非staticデータメンバーを持てない
union U2 { int & ref ; } ;
// エラー、非staticデータメンバーで、初期化子を持てるのは、ひとつだけ
union U3
{
    int x = 0 ; 
    int y = 0 ; // エラー、複数の初期化子、どちらか一つならエラーではない
} ;

その他は、通常のクラスと変わることがない。unionはメンバー関数を持てる。メンバー関数には、コンストラクターやデストラクター、演算子のオーバーロードも含まれる。アクセス指定も使える。staticデータメンバーならば、リファレンス型でも構わない。ネストされた型も使える。

unionの非staticデータメンバーが、非trivialなコンストラクター、コピーコンストラクター、ムーブコンストラクター、コピー代入演算子、ムーブ代入演算子、デストラクターを持っている場合、unionの対応するメンバーが、暗黙的にdeleteされる。そのため、これらのメンバーを使う場合には、union側で、ユーザー定義しなければならない。

union U
{
    std::string str ;
    std::vector<int> vec ;
} ;

int main()
{
    U u ; // エラー、コンストラクターとデストラクターがdelete定義されている。
}

この例では、strやvecは、非trivialなコンストラクターやデストラクターなどを持っているので、union側でも、それらを定義しなければならない。また、この例の場合、unionのコンストラクターやデストラクターは何もしないので、このunionを実際に使う場合には、placement newや、明示的なデストラクター呼び出しが必要になる。

union U
{
    std::string str ;
    std::vector<int> vec ;

    U() { }
    ~U() { }
} ;

int main()
{
    U u ;

    new ( &u.str ) std::string( "hello" ) ;
    u.str.~basic_string() ;

    new ( &u.vec ) std::vector<int> { 1, 2, 3 } ;
    u.vec.~vector() ;
}

もちろん、unionのコンストラクターやデストラクターで、どれかのデータメンバーの初期化、破棄をすることは可能である。しかし、どのデータメンバーが有効なのかということを、union内で把握するのは難しい。

union { メンバー指定opt } ;

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 ;
}

// グローバル名前空間スコープ
static union { int x ; int y ; } ;

int main()
{
    // 自動ストレージ
    union { int a } ;
    // staticストレージ
    static union { int b } ;
    // thread_localストレージ
    thread_local union { int c } ;
}

struct S
{
    union
    {
        int x ;
    } ;
} ;

// クラス名の省略されたunion
// 無名unionではない
union { int x ; } obj, * ptr ;

// xとyは共用メンバー
union U { int x ; int y ; }

// xとyは共用メンバー
struct S
{
    union { int x ; int y ; } ;
} ;

ビットフィールド（Bit-fields）

ビットフィールドは、以下のようなメンバー宣言子の文法で宣言できる。

識別子opt : 定数式

定数式は、0よりも大きい整数でなければならない。

struct S
{
    int // 型指定子
    x : 8 ; // ビットフィールドの宣言子
} ;

ビットフィールドの定数式は、データメンバーのサイズをビット数で指定する。ビットフィールドに関しては、ほとんどの挙動が実装依存である。特に、ビットフィールドがクラスオブジェクトのストレージ上でどのように表現されるのかということや、アライメントなどは、すべて実装依存である。また、実装は、ビットフィールドのメンバー同士を詰めて表現することが許されている。

struct S
{
    char x : 1 ;
    char y : 1 ;
} ;

ここで、sizeof(S)は、2以上になるとは限らない。例えば、sizeof(S)が1を返す実装もあり得る。

ビットフィールドの定数式は、オブジェクトのビット数を上回ることができる。その場合、上回ったビット数は、パディングとして確保されるが、オブジェクトの内部表現として使われることはない。

struct S
{
    int x : 1000 ;
} ;

ここで、sizeof(S)は、少なくとも1000ビット以上になる値を返す（規格では、1バイトあたりのビット数は定められていない）。ただし、S::xは、本来のint型以上の範囲の値を保持することはできない。int型のオブジェクトのビット数を上回った分は、単にパディングとして確保されているに過ぎない。

ビットフィールドの宣言子で、識別子を省略した場合、無名ビットフィールドとなる。無名ビットフィールドはクラスのメンバーではなく、初期化もされない。ただし、実装依存の方法で、クラスのオブジェクト内に存在する。一般的な実装では、無名ビットフィールドは、オブジェクトのレイアウトを調整するためのパディングとして用いられる。

struct S
{
    int x : 4 ;
    char : 3 ; // 無名ビットフィールド
    int y : 1 ;
} ;

あるコンパイラーでは、このような無名ビットフィールドにより、S::xとS::yの間に、3ビット分のパディングを挿入することができる。ただし、すでに述べたように、ビットフィールドの内部表現とアライメントは実装依存なので、これはすべてのコンパイラーに当てはまるわけではない。使用しているコンパイラーが、ビットフィールドをどのように実装しているかは、コンパイラー独自のマニュアルを参照すべきである。

無名ビットフィールドでは、特別に、定数式に0を指定することができる。

struct S
{
    int x : 4 ;
    char : 0 ; // 無名ビットフィールド
    int y : 4 ;
} ;

これは、無名ビットフィールドの次のビットフィールドのアライメントを、アロケーション単位の境界に配置させるための指定である。上記の構造体は、ある環境では、S::xとS::yが同一のアロケーション単位に配置されるかもしれないが、無名ビットフィールドを使うことで、X::yを別のアロケーション単位に配置できる。

ビットフィールドはstaticメンバーにはできない。ビットフィールドの型は、整数型かenum型でなければならない。符号が指定されていない整数型のビットフィールドの符号は実装依存である。

struct S
{
    static int error : 8 ; // エラー、ビットフィールドはstaticメンバーにはできない
    int impl : 8 ; // 符号は実装依存
    signed s : 8 ; // 符号はsigned
    unsigned u : 8 ; // 符号はunsigned
} ;

bool型のビットフィールドは、ビット数に関わらず、bool型の値を表現できる。

struct S
{
    bool a : 1 ;
    bool b : 2 ;
    bool c : 3 ;
} ;

int main()
{
    S s ;
    s.a = true ;
    s.b = false ;
    s.c = true ;
}

ビットフィールドのアドレスを得ることはできない。つまり、&演算子をビットフィールドに適用することはできない。

struct S
{
    int x : 8 ;
} ;

int main()
{
    S s ;
    &s.x ; // エラー
}

リファレンスは、ビットフィールドを参照することはできない。ただし、constなlvalueリファレンスの初期化子が、lvalueのビットフィールドの場合は、一時オブジェクトが生成され、そのオブジェクトを参照する。

struct S
{
    int x : 8 ;
} ;

int main()
{
    S s ;
    // エラー
    int & ref = s.x ;
    // OK
    // ただし、crefが参照するのは、生成された一時オブジェクトである
    // s.xではない
    int const & cref = s.x ;
}

クラス宣言のネスト（Nested class declarations）

クラスは、他のクラスの内側で宣言することができる。これを、ネストされたクラス（nested class）という。

class Outer
{
    class Inner { } ; // ネストされたクラス
} ;

int main()
{
    Outer::Inner object ;
}

ネストされたクラスのスコープは、外側のクラスのスコープに従う。これは、名前探索の際も、外側のクラスのスコープが影響するということである。

int x ; // グローバル変数

struct Outer
{
    int x ; // Outer::x
    struct Inner
    {
        void f()
        {
            sizeof(x) ; // OK、sizeofのオペランドは未評価式。Outer::xのサイズを返す
            x = 0 ; // エラー、Outer::xはOuterの非staticメンバー

            ::x = 0 ; // OK、グローバル変数
        }
    } ;
} ;

関数Inner::fの中で、xという名前を使うと、Outer::xが見つかる。これは、クラスInnerが、クラスOuterのスコープ内にあるためである。しかし、非staticデータメンバーであるOuter::xを使うためには、Outerのオブジェクトが必要なので、ここではエラーとなる。sizeofのオペランドは未評価式なので、問題はない。ただし、ここでのxは、Outer::xである。グローバル変数のxではない。

ネストされたクラスのメンバー関数やstaticデータメンバーは、通常のクラス通り、クラス定義の外側、同じ名前空間内で定義することができる。

// グローバル名前空間
struct Outer
{

    struct Inner
    {
        static int x ;
        void f() ;
    } ;
} ;

// 同じ名前空間内
int Outer::Inner::x = 0 ;
void Outer::Inner::f() { }

また通常通り、クラスの宣言だけをして、定義を後で書くこともできる。

struct Outer
{
    class Inner ; // 宣言
} ;

class Outer::Inner { } ; // 定義

ローカルクラス宣言（Local class declarations）

関数定義の中で、クラスを定義することができる。これをローカルクラス（local class）という。

int main()
{ // 関数定義
    class Local { } ; // ローカルクラス
    Local object ; // ローカルクラスのオブジェクト
}

ローカルクラスのスコープは、クラス定義の外側のスコープである。また、名前探索は、ローカルクラスが定義されている関数と同じとなる。

ローカルクラスは、定義されている関数内の自動変数を使うことは出来ない。typedef名やstatic変数などは使える。

int main()
{
    int x ; // ローカル変数

    typedef int type ;
    static int y ;

    class Local
    {
        void f()
        {
            x = 0 ; // エラー

            // typedef名やstatic変数などは使える
            type val ; // OK
            y = 0 ; // OK

            // OK、sizeofのオペランドは未評価式
            sizeof(x) ;
        }
    } ;
}

ローカルクラスは、通常のクラスより制限が多い。ローカルクラスをテンプレート宣言することはできない。メンバーテンプレートを持つこともできない。ローカルクラスのメンバー関数は、クラス定義内で定義されなければならない。ローカルクラスの外側でメンバー関数を定義する方法はない。staticデータメンバーを持つことはできない。

int main()
{
    // エラー、ローカルクラスはテンプレート宣言できない
    template < typename T > 
    class Local
    {
        // エラー、ローカルクラスはメンバーテンプレートを持てない。
        template < typename U > void f() { } 

        // OK、ただし、ローカルクラスの外側でメンバー関数を定義する方法はない
        void f() ;
        // エラー、ローカルクラスはstaticデータメンバーを持つことはできない。 
        static int x ;
    } ;
}

型名のネスト（Nested type names）

クラス内の型名を、ネストされた型名（nested type name）という。ネストされた型名を、クラスの外側で使うには、クラス名による修飾が必要である。

struct X
{
    typedef int I ;
    class Inner { } ;
    I member ;
} ;

X::I object ;

複数の基本クラス（Multiple base classes）

基本クラスは、複数指定することができる。これを、複数の基本クラスという。複数の基本クラスを指定することを、俗に、多重継承（Multiple Inheritance）ということがあるが、これは、C++の規格上、正しい用語ではない。継承は、基本クラスのメンバーを派生クラスも受け継ぐことを意味する用語であって、クラスの派生関係を表すのに使う言葉ではないからだ。

ただし、歴史的に言えば、Multiple Inheritanceという言葉を最初に使ったのは、他ならぬBjarne Stroustrupご本人である。当時、Stroustrup氏が複数の基本クラスの設計をしていた時に使った言葉が、多重継承であった。ちなみに、多重継承が初めて使われたコードは、Jerry Schwarzによって書かれたiostreamである。

複数の基本クラスは、コンマで区切ることによって指定する。

struct A { } ; struct B { } ; struct C { } ;
struct D
     : A, B, C
{ } ;

この例では、Dは、A、B、Cという3個の基本クラスを持っている。

同じクラスを複数、直接の基本クラスとして指定することは出来ない。間接の基本クラスとしては指定できる。

struct Base { } ;

struct Derived
     : Base, Base // エラー、直接の基本クラス
{ } ;

struct Derived1 : Base { } ;
struct Derived2 : Base { } ;
struct Derived3
     : Derived1, Derived2 // OK、間接の基本クラス
    { } ;

この場合、Derived3は、Baseクラスのサブオブジェクトを、2個持つことになる。

基本クラスに、virtualが指定されていない場合、非virtual基本クラス（non-virtual base class）となる。非virtual基本クラスには、それぞれ独立したサブオブジェクトが割り当てられる。

同じクラスが複数、非virtual基本クラスとして存在することは、基本クラスのメンバーの名前に対するオブジェクトが容易に曖昧になる。このとき、派生クラスから基本クラスのメンバーを使うには、名前を正しく修飾しなければならない。

struct Base { int member ; } ;
struct Derived1 : Base { } ;
struct Derived2 : Base { } ;

// Derived3には、2個のBaseサブオブジェクトが存在する
struct Derived3 : Derived1, Derived2
{
    void f()
    {
        member ; // エラー、曖昧
        Base::member ; // エラー、曖昧
        Derived1::member ; // OK
        Derived2::member ; // OK
    }
} ;

int main()
{
    Derived3 x ;
    x.member ; // エラー、曖昧
    x.Derived1::member ; // OK
    x.Derived2::member ; // OK
}

ただし、staticメンバーの名前は、曖昧にならない。これは、staticメンバーの利用には、クラスのオブジェクトは必要ないからである。

struct Base
{
    static void static_member() { }
    static int static_data_member ;
} ;
int Base::static_data_member = 0 ;

struct Derived1 : Base { } ;
struct Derived2 : Base { } ;

struct Derived3 : Derived1, Derived2
{
    void f()
    {
        static_member() ; // OK
        static_data_member ; // OK
    }
} ;

直接、間接の両方の基本クラスに、同じクラスを持つことは可能である。ただし、そのような派生クラスは、基本クラスの非staticメンバーを使うことができない。なぜなら、基本クラスの名前自体の曖昧性を解決する方法がないからだ。

struct Base
{
    int member() ; // 非staticメンバー
    static void static_member() { } // staticメンバー
} ;
struct Derived1 : Base { } ;

// Baseという名前自体が曖昧になる
struct Derived2 : Base, Derived1
{
    void f()
    {
        // Baseの非staticメンバーを使う方法はない

        static_member() ; // OK、staticメンバーは使える
    }
} ;

このため、直接、間接の両方で同じクラスを基本クラスに持つ派生クラスの利用は、かなり制限される。

基本クラスに、virtualが指定されている場合、virtual基本クラス（virtual base class）という。virtual基本クラスには、ひとつしかオブジェクトが割り当てられない。virtual基本クラスのオブジェクトは、派生クラスで共有される。

struct L { } ;
struct A : virtual L { } ;
struct B : virtual L { } ;
struct C : A, B { } ;

この例で、Cクラスには、Lのサブオブジェクトは1個存在する。これは、A、Bで共有される。

virtual基本クラスでは、サブオブジェクトが共有されているため、virtual基本クラスのメンバーは、曖昧にならない。

struct Base { int member ; } ;
struct Derived1 : virtual Base { } ;
struct Derived2 : virtual Base { } ;
struct Derived3 : Derived1, Derived2
{
    void f()
    {
        member ; // OK
    }
} ;

非virtual基本クラスとvirtual基本クラスは、両方持つことができる。

struct B { } ;
struct X : virtual B { } ;
struct Y : virtual B { } ;
struct Z : B { } ;
struct A : X, Y, Z { } ;

この例では、Aクラスには、Bのサブオブジェクトは、2個存在する。X、Yで共有されるサブオブジェクトと、Zのサブオブジェクトである。

メンバーの名前探索（Member name lookup）

メンバーの名前探索は、すこし難しい。派生クラスのメンバー名は、基本クラスのメンバー名を隠すということだ。あるメンバー名を名前探索する際に、派生クラスで名前が見つかった場合、その時点で名前探索は終了する。基本クラスのメンバーを探すことはない。

struct Base
{
    void f( int ) { }
} ;

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

int main()
{
    Derived object;
    object.f( 0 ) ; // Derived::f( double )が呼ばれる
}

ここで、Derivedクラスには、二つのfという名前のメンバーが存在する。Derived::fとBase::fである。もし、名前探索によって両方の名前が発見された場合、オーバーロード解決によって、Base::f(int)が選ばれるはずである。しかし、実際には、Derived::f(double)が選ばれる。これは、Derivedクラスに、fという名前のメンバーが存在するので、その時点で名前探索が終了するからである。Baseのメンバー名は発見されない。名前が発見されない以上、オーバーロード解決によって選ばれることもない。

これは、名前探索に対するルールなので、型は関係がない。

// fという名前のint型のデータメンバー
struct Base { int f ; } ;
// fという名前のvoid (void)型のメンバー関数
struct Derived : Base { void f( ) { } } ;

int main()
{
    Derived object;
    object.f = 0 ; // エラー、メンバー関数Derived::fに0を代入することはできない
    object.Base::f = 0 ; // OK、明示的な修飾
}

したがって、基本クラスと同じ名前のメンバーを派生クラスで使う際には、注意が必要である。

名前探索という仕組みを考えずに、この挙動を考えた場合、これは、派生クラスのメンバー名が、基本クラスのメンバー名を、隠していると考えることもできる。もし、基本クラスのメンバー名を隠したくない場合、using宣言を使うことができる。using宣言を使うと、基本クラスのメンバー名を、派生クラスのスコープに導入することができる。

struct Base
{
    void f( int ) { }
} ;

struct Derived : Base
{
    using Base::f ; // using宣言
    void f( double ) { }
} ;

int main()
{
    Derived object;
    object.f( 0 ) ; // Base::f( int )が呼ばれる
}

名前探索で、派生クラスのメンバーが見つからない場合は、直接の基本クラスのメンバーから、名前が探される。

struct Base { int member ; } ;
struct Derived : Base
{
    void f()
    {
        member ; // Base::member
    }
} ;

メンバー名を探す基本クラスは、直接の基本クラスだけである。間接の基本クラスのメンバーは、直接の基本クラスを通じて、探される。

struct A { int member ; } ;
struct B : A { } ;
struct C : B
{
    void f()
    {
        member ; // A::member
    } 
} ;

この例では、C::fでmemberという名前のメンバーを使っている。Cクラスにはmemberという名前のメンバーが見つからないので、名前探索はBクラスに移る。クラスは、基本クラスのメンバー名を継承している。そのため、Bクラスの基本クラスのAクラスのメンバー名は、Bクラスのスコープからも発見することができる。

直接の基本クラスが複数ある場合、それぞれの直接の基本クラスから、名前が探される。この際、複数のクラスから同じ名前が発見され、名前の意味が違う場合、名前探索は無効となる。

struct Base1 { void member( int ) { } } ;
struct Base2 { void member( double ) { } } ;
struct Derived : Base1, Base2 // 複数の直接の基本クラス
{
    void f()
    {
        member( 0 ) ; // エラー、名前探索が無効
        Base1::member( 0 ) ; // OK
    } 
} ;

これは、memberという名前に対し、複数の直接の基本クラスで、複数の同じ名前が見つかり、しかも意味が違っているので、名前検索が無効となる。その結果、memberという名前が見つからず、エラーとなる。

もし、この例で、Derivedから、明示的な修飾をせずに、両方の基本クラスのメンバー関数を呼び出したい場合、using宣言が使える。

struct Base1 { void member( int ) { } } ;
struct Base2 { void member( double ) { } } ;
struct Derived : Base1, Base2
{
    // 基本クラスのメンバー名をDerivedスコープで宣言する
    using Base1::member ;
    using Base2::member ;

    void f()
    {
        member( 0 ) ; // OK、オーバーロード解決により、Base1::member(int)が呼ばれる
    } 
} ;

この例は、複数の直接の基本クラスがある場合の制限である。複数の間接の基本クラスでは、名前探索が失敗することはない。ただし、名前探索の結果として、複数の名前が発見され、曖昧になることはある。

virtual関数（Virtual functions）

本書のサンプルコードは、解説する文法のための最小限のコードであり、virtual関数を持つクラスがvirtualデストラクターを持たないことがある。これは現実ではほとんどの場合、不適切である。

メンバー関数にvirtual指定子を指定すると、virtual関数となる。virtual関数を宣言しているクラス、あるいはvirtual関数を継承しているクラスは、ポリモーフィッククラス（polymorphic class）となる。

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

BaseとDerivedは、ポリモーフィッククラスである。

クラスがポリモーフィックであるかどうかということは、dynamic_castやtypeidを使う際に、重要である。

基本クラスのvirtual関数は、派生クラスのメンバーに、同じ名前、同じ仮引数リスト、同じCV修飾子、同じリファレンス修飾子という条件を満たすメンバー関数があった場合、オーバーライドされる。この時、派生クラスのメンバー関数は、virtual指定子がなくても、自動的にvirtual関数になる。

struct A { virtual void f() {} } ;
struct B : A { } ; // オーバーライドしない
struct C : A
{
    void f() { } // オーバーライド
} ;
struct D : C
{
    void f(int) { } // オーバーライドしない
    void f() const { } // オーバーライドしない
} ;

// リファレンス修飾子が違う例
struct Base { virtual void f() & { } } ;
struct Derived : Base { void f() && { } } ;

もちろん、virtualをつけてもよい。

struct Base { virtual f() { } } ;
struct Derived : Base { virtual f() { } }  ; // オーバーライド

派生クラスで、最後にオーバーライドしたvirtual関数を、ファイナルオーバーライダー（final overrider）と呼ぶ。あるクラスのオブジェクトに対して、virtual関数を呼び出す際は、オブジェクトの実行時の型によって、最後にオーバーライドしたvirtual関数が呼び出される。これは、基本クラスのポインターやリファレンスを経由してオブジェクトを使った場合でも、同様である。通常のメンバー関数は、virtual関数とは違い、実行時の型チェックを行わない。オブジェクトを指しているリファレンスやポインターの型によって、決定される。

// virtual関数と非virtual関数の違いの例
struct A
{
    virtual void virtual_function() { }
    void function() { }
} ;
struct B : A
{
    virtual void virtual_function() { }
    void function() { }
} ;
struct C : B
{
    virtual void virtual_function() { }
    void function() { }
} ;

void call( A & ref )
{
    ref.virtual_function() ;
    ref.function() ;
}

int main()
{
    A a ; B b ; C c ;

    call( a ) ; // A::virtual_function, A::functionが呼び出される
    call( b ) ; // B::virtual_function, A::functionが呼び出される
    call( c ) ; // C::virtual_function, A::functionが呼び出される
}

Aは、virtual_functionとfunctionという名前のvirtual関数を持っており、Aから派生しているB、Bから派生しているCは、オーバーライドしている。call関数の仮引数refは、オブジェクトの型が、実際に何であるかは、実行時にしか分からない。virtual関数であるvirtual_functionは、オブジェクトの型に合わせて正しく呼び出されるが、virtual関数ではないfunctionは、Aのメンバーが呼び出される。

virt指定子(virt-specifier)は、finalかoverrideで、virtual関数の宣言子の後、pure指定子の前に記述できる。

// virt指定子の文法の例示のための記述
virtual f() final override = 0 ;

finalが指定されたvirtual関数を持つクラスから派生したクラスが、同virtual関数をオーバーライドした場合はエラーになる。

struct base
{
    virtual void f() { }
} ;

struct derived
{
    virtual void f() final { }
} ;

struct ok : derived
{
// OK
} ;

struct error : derived
{
    // エラー、final指定されているderived::fをオーバーライド
    virtual void f() { }
} ;

virtual関数にfinalを指定すると、それ以上のオーバーライドを禁止できる。

overrideが指定されたvirtual関数が、基本クラスのメンバー関数をオーバーライドしていない場合、エラーとなる。

struct base
{
    virtual void virtual_function() { }
} ;

struct ok : base
{
    // OK、ok::virtual_functionはbase::virtual_functionをオーバーライドしている
    virtual void virtual_function() override { }
} ;

struct typo : base
{
    // OK、typo::virtal_functionはbase::virtual_functionとは別のvirtual関数
    virtual void virtal_function() { }
} ;

struct error : base
{
    // エラー、error::virtal_functionはオーバーライドしていない
    virtual void virtal_function() override { }
} ;

これにより、タイプミスによる些細な間違いをコンパイル時に検出できる。

オーバーライドであることに注意。以下のコードはエラーである。

struct base
{
    void f() { } // 非virtual関数
} ;

struct error : base
{
    // エラー、オーバーライドしていない
    virtual void f() override { }
} ;

finalとoverrideを両方指定することもできる。

virtual関数をオーバーライドする関数は、戻り値の型が同じでなくても構わない。ただし、何でもいいというわけではない。戻り値の型は、まったく同じ型か、相互変換可能（covariant）でなければならない。covariantは、以下のような条件をお互いに満たした型のことである。

今、関数D::fが、関数B::fをオーバーライドしているとする。

// D::f、B::fの例
struct B { virtual 戻り値の型 f() ; } ;
struct D : B { virtual 戻り値の型 f() ; } ;

その場合、戻り値の型は、以下の条件を満たさなければならない。

お互いにクラスへのポインター、もしくは、お互いにクラスへのlvalueリファレンス、もしくは、お互いにクラスへのrvalueリファレンスであること。

片方がポインターで片方がリファレンスの場合や、片方がlvalueリファレンスで片方がrvalueリファレンスの場合は、不適である。もちろん、ポインターでもリファレンスでもない型は不適である。また、クラスでもない型へのポインターやリファレンスも不適である。

// ポインター
struct B { virtual B * f() ; } ;
struct D : B { virtual D * f() ; } ;
// lvalueリファレンス
struct B { virtual B & f() ; } ;
struct D : B { virtual D & f() ; } ;
// rvalueリファレンス
struct B { virtual B && f() ; } ;
struct D : B { virtual D && f() ; } ;

B::fの戻り値の型のクラスは、D::fの戻り値の型のクラスと同じか、曖昧がなくアクセスできる基本クラスでなければならない。

オーバーライドしている関数が、基本クラスを戻り値に使っていたり、そもそもクラスの派生関係にない場合は、不適である。private派生していて、派生クラスからはアクセスできない場合や、基本クラスのサブオブジェクトが複数あって曖昧な場合はエラーとなる。

struct Base { } ; // 基本クラス
struct Derived : Base { } ; // 派生クラス
struct Other { } ; // BaseやDerivedとは派生関係にないクラス

// クラスが同じ
struct B { virtual Base & f() ; } ;
struct D : B { virtual Base & f() ; } ;

// B::fのクラスはD::fのクラスの基本クラス
struct B { virtual Base & f() ; } ;
struct D : B { virtual Derived & f() ; } ;

// エラー
struct B { virtual Derived & f() ; } ;
struct D : B { virtual Base & f() ; } ;

// エラー
struct B { virtual Base & f() ; } ;
struct D : B { virtual Other & f() ; } ;

両方のポインターは同じCV修飾子を持たなければならない。D::fの戻り値の型のクラスは、B::fの戻り値の型のクラスと同じCV修飾子を持つか、あるいは少ないCV修飾子を持たなければならない。

補足：ポインターに対するCV修飾子とは、T cv1 * cv2という型がある場合、cv2である。クラスに対するCV修飾子は、cv1である。

// int *に対するCV修飾子
int * const 
// intに対するCV修飾子
const int *
int const *

// 両方のポインターは同じCV修飾子を持たなければならない例

// ポインターのCV修飾子はconst
struct B { virtual B * const f() ; } ;
// OK
struct D : B { virtual D * const f() ; } ;

// エラーのDクラスの例、ポインターのCV修飾子が一致していない
struct D : B { virtual D * f() ; } ;
struct D : B { virtual D * volatile const f() ; } ;
struct D : B { virtual D * const volatile f() ; } ;

// D::fの戻り値の型のクラスは、B::fの戻り値の型のクラスと同じCV修飾子を持つか、
// あるいは少ないCV修飾子を持たなければならない例

// B::fの戻り値の型のクラスのCV修飾子はconst
struct B { virtual B const & f() ; } ;
// 問題ないDクラスの例、CV修飾子が同じか少ない
struct D : B { virtual D const & f() ; } ;
struct D : B { virtual D & f() ; } ;

// エラーのDクラスの例、CV修飾子が多い
struct D : B { virtual D volatile & f() ; } ;
struct D : B { virtual D const volatile & f() ; } ;

明示的な修飾を用いた場合は、virtual関数呼び出しが阻害される。これは、オーバーライドしたvirtual関数から、オーバーライドされたvirtual関数を呼び出すのに使える。

struct Base { virtual void f() { } } ;
struct Derived : Base
{
    virtual void f()
    {
        f() ; // Derived::fの呼び出し
        Base::f() ; // 明示的なBase::fの呼び出し
    }
} ;

virtual関数とdelete定義は併用できる。ただし、delete定義のvirtual関数を、非delete定義のvirtual関数でオーバーライドすることはできない。非delete定義のvirtual関数を、delete定義のvirtual関数でオーバーライドすることはできない。

// OK、delete定義のvirtual関数を、delete定義のvirtual関数でオーバーライドしている
struct Base { virtual void f() = delete ; } ;
struct Derived : Base { virtual void f() = delete ; } ;

// エラー、非delete定義ではないvirtual関数を、delete定義のvirtual関数でオーバーライドしている
struct Base { virtual void f() { } } ;
struct Derived : Base { virtual void f() = delete ; } ;

// エラー、delete定義のvirtual関数を、非delete定義のvirtual関数でオーバーライドしている
struct Base { virtual void f() = delete ; } ;
struct Derived : Base { virtual void f() { } } ;

アブストラクトクラス（Abstract classes）

ピュア指定子:
    = 0 

アブストラクトクラス（abstract class）は、抽象的な概念としてのクラスを実現する機能である。これは、例えば図形を表すクラスである、CircleやSquareなどといったクラスの基本クラスであるShapeや、動物を表すDogやCatなどといったクラスの基本クラスであるAnimalなど、異なるクラスに対する共通のインターフェースを提供する目的に使える。

struct Shape
{
    // 図形描画用の関数
    // Shapeクラスは抽象的な概念であり、具体的な描画方法を持たない
    // 単に共通のインターフェースとして提供される
    virtual void draw() = 0 ;
} ;

struct Circle : Shape
{
    virtual void draw() { /* 円を描画 */ }
} ;

struct Square : Shape
{
    virtual void draw() { /* 正方形を描画 */ }
} ;

void f( Shape * ptr )
{
    ptr->draw() ; // 実行時の型に応じて図形を描画する
}

ここでは、Shapeクラスというのは、具体的に描画する方法を持たない。そもそも、Shapeクラス自体のオブジェクトを使うことは想定されていない。このように、そのクラス自体は抽象的な概念であり、実体を持たない場合、ピュアvirtual関数を使うことで、共通のインターフェースとすることができる。

他の言語では、この機能を明確にクラスから分離して、「インターフェース」という名前の機能にしているものもある。C++では、抽象クラスも、制限はあるものの、クラスの一種である。

少なくともひとつのピュアvirtual関数を持つクラスは、アブストラクトクラスとなる。ピュアvirtual関数は、virtual関数の宣言に、ピュア指定子を書くことで宣言できる。

ピュア指定子:
    = 0 

struct abstract_class
{
    virtual void f() = 0 ;
} ;

ピュアvirtual関数は、呼ばれない限り、定義する必要はない。

struct Base
{
    virtual void f() = 0 ;
    virtual void g() = 0 ;
} ;

struct Derived
{
    virtual void g() { } 
} ;

void call_g( Base & base )
{
    base.g() ;
}

int main()
{
    Derived d ;
    call_g( d ) ;
}

一つの関数宣言にピュア指定子と定義を両方書くことはできない。

struct X
{
    // エラー
    virtual void f() = 0 { } ; 
} ;

ただし、複数の関数宣言を使えば、ひとつの関数にピュア指定子と定義を両方与えることができる。

struct X
{
// OK、ピュア指定子を与える関数宣言
    virtual void f() = 0 ;
} ;

// OK、定義を与える関数宣言
void X::f() { }

この仕様は、オブジェクトの破棄の際に何らかの処理を行いたい抽象クラスに使うことができる。デストラクターを純粋仮想関数かつ定義付きの関数とすることができる。

class Base
{
    int * ptr ;
public :
    Base( int value )
        : ptr( new int(value) )
    { } 
    virtual ~Base() = 0 ;
} ;

Base::~Base()
{
    delete ptr ;
}

ただし、デストラクターの呼び出しは、通常のメンバー関数とは異なっているので、注意が必要である。以下のコードを考える。

struct Base
{
    virtual void f() = 0 ;
    virtual ~Base() = 0 ;
} ;

void Base::f() { }
Base::~Base
{
// Derivedはすでに破棄されている。

    f() ; // エラー、Base::fのvirtual関数呼び出しの挙動は未定義
}

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

int main()
{
    Derived d ;
}

Baseのデストラクター呼び出しは問題がない。なぜならば、基本クラスのデストラクターは、あたかも明示的に直接呼び出されたかのように振る舞うからだ。virtual関数呼び出しではない。

ただし、デストラクターの中で未修飾名のfを呼び出すと、これはvirtual関数呼び出しになる。オブジェクトの構築中、破棄中にvirtual関数を呼び出した場合、オブジェクトの型が、あたかも最終的な派生クラスの型とみなされる。そのため、ここではBase::fがvirtual関数呼び出しされる。

Base::fは、定義が与えられてはいるものの、依然としてピュアvirtual関数であることに変わりはない。ピュアvirtual関数をvirtual関数呼び出しした場合の挙動は未定義である。そのため、上記のコードは、以下のように、明示的な修飾名で呼び出し、通常の関数呼び出しにしなければ、規格上、動作が保証されない。

Base::~Base
{
    Base::f() ; // OK、修飾名は通常の関数呼び出し
}

この、=0という文法は、初期化子や代入式とは、何の関係もない。ただ、C++の文法上、メンバー関数の宣言の中の、=0というトークン列を、特別な意味を持つものとして扱っているだけである。ピュア指定子を記述する位置は、virt-specifierの後である。

struct Base { virtual void f() { } }
struct abstract_class : Base
{
    virtual void f() override = 0 ; // virt-specifierの後
} ;

アブストラクトクラスは、他のクラスの基本クラスとして使うことしかできない。アブストラクトクラスのオブジェクトは、派生クラスのサブオブジェクトとしてのみ、存在することができる。

struct abstract_class
{
    virtual void f() = 0 ;
} ;

struct Derived : abstract_class
{
    void f() { }
} ;

アブストラクトクラスのオブジェクトを、直接作ることはできない。これには、変数や関数の仮引数、new式などが該当する。

struct abstract_class
{
    virtual void f() = 0 ;
} ;

// エラー、abstract_classのオブジェクトは作れない
void f( abstract_class param )
{
    abstract_class obj ; // エラー
    new abstract_class ; // エラー
}

アブストラクトクラスへのポインターやリファレンスは使える。

struct abstract_class
{
    virtual void f() = 0 ;
} ;

// OK、ポインターとリファレンスはよい
void f( abstract_class *, abstract_class & ) ;

ピュアvirtual関数を継承していて、ファイナルオーバーライダーがピュアvirtual関数である場合も、アブストラクトクラスとなる。これは例えば、アブストラクトクラスから派生されているクラスが、ピュアvirtual関数をオーバーライドしていなかった場合などが、該当する。

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

この場合、Derivedも、Baseと同じく、アブストラクトクラスになる。

派生クラスによって、ピュアvirtual関数ではないvirtual関数をオーバーライドして、ピュアvirtual関数にすることができる。その場合、派生クラスはアブストラクトクラスとなる。

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

int main()
{
    Base b ; // OK
    Derived d ; // エラー
}

この例では、Baseはアブストラクトクラスではない。Derivedはアブストラクトクラスである。

構築中、または破棄中のアブストラクトクラスのコンストラクターやデストラクターの中で、ピュアvirtual関数を呼び出した場合の挙動は、未定義である。

struct Base
{
    virtual void f() = 0 ;

    // この関数を、Baseのコンストラクターやデストラクターから呼ぶとエラー
    void g()
    { f() ; }

    // コンストラクター
    Base() // エラー、未定義の挙動
    { f() ; }

    // デストラクター
    ~Base() // エラー、未定義の挙動
    { f() ; }
} ;

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

    // Derivedはアブストラクトクラスではないので、問題はない
    Derived() { f() ; }
    ~Derived() { f() ; }
} ;

アクセス指定子（Access specifiers）

クラスのメンバーのアクセス指定は、ラベルにアクセス指定子（Access specifiers）を記述することで指定する。

アクセス指定子 : メンバー指定opt

アクセス指定 :
    private
    protected
    public

アクセス指定子とは、private、protected、publicのいずれかである。アクセス指定子が現れた場所から、次のアクセス指定子か、クラス定義の終了までの間のメンバーが、アクセス指定子の影響を受ける。

class X
{
    int a ; // デフォルトのprivate
public :
    int b ; // public
    int c ; // public
protected :
    int d ; // protected
private :
    int e ; // private
} ;

アクセス指定子には、順番や使用可能な回数の制限はない。好きな順番で、何度でも指定できる。

class X
{
public :
public :
protected :
public :
public :
private :
} ;

基本クラスと、基本クラスのメンバーへのアクセス指定（Accessibility of base classes and base class members）

あるクラスを、別のクラスの基本クラスとするとき、いずれかのアクセス指定子を指定する。

class Base { } ;

class Derived_by_public : public Base { } ; // public派生
class Derived_by_protected : protected Base { } ; // protected派生
class Derived_by_private : private Base { } ; // private派生

アクセス指定子がpublicの場合、基本クラスのpublicメンバーは、派生クラスのpublicメンバーとしてアクセス可能になり、基本クラスのprotectedメンバーは、派生クラスのprotectedメンバーとしてアクセス可能になる。

class Base
{
public :
    int public_member ;
protected :
    int protected_member ;
} ;

class Derived : public Base
{
    void f()
    {
        public_member ; // OK
        protected_member ; // OK
    }
} ;

int main()
{
    Derived d ;
    d.public_member ; // OK
}

アクセス指定子がprotectedの場合、基本クラスのpublicとprotectedメンバーは、派生クラスのprotectedメンバーとしてアクセス可能になる。

class Base
{
public :
    int public_member ;
protected :
    int protected_member ;
} ;

class Derived : protected Base
{
    void f()
    {
        public_member ; // OK、ただしprotectedメンバー
        protected_member ; // OK
    }
} ;

int main()
{
    Derived d ;
    d.public_member ; // エラー、Derivedからは、protectedメンバーである
}

アクセス指定子がprivateの場合、基本クラスのpublicとprotectedメンバーは、派生クラスのprivateメンバーとしてアクセス可能になる。

class Base
{
public :
    int public_member ;
protected :
    int protected_member ;
} ;

class Derived : private Base
{
    void f()
    {
        public_member ; // OK、ただし、privateメンバー
        protected_member ; // OK、ただし、privateメンバー
    }
} ;

class Derived2 : public Derived
{
    void f()
    {
        public_member ; // エラー、基本クラスのprivateメンバーにはアクセスできない
        protected_member ; // エラー、基本クラスのprivateメンバーにはアクセスできない
    }
} ;

int main()
{
    Derived d ;
    d.public_member ; // エラー、Derivedからは、privateメンバーである
}

基本クラスにアクセス指定子を指定しなかった場合、structキーワードで宣言されたクラスは、デフォルトでpublicに、classキーワードで宣言されたクラスは、デフォルトでprivateになる。

struct Base { } ;

// デフォルトのpublic派生
struct D1 : Base { } ; 
// デフォルトのprivate派生
class D2 : Base { } ;

どのアクセス指定子を指定して派生しても、基本クラスのprivateメンバーを派生クラスから使うことはできない。クラスAからprivate派生したクラスBから派生しているクラスCでは、クラスAのメンバーは使えないのも、この理由による。

// classキーワードで宣言されたクラスのメンバーはデフォルトでprivate
class Base { int private_member ; } ;

class Derived : public Base
{
// どのアクセス指定を用いても、基本クラスのprivate_memberは使えない
} ;

struct A { int public_member ; } ;
class B : private A { } ;
class C : public B
{
// クラスBは、クラスAからprivate派生しているため、ここではA::public_memberは使えない。
} ;

クラス名自体も、クラススコープ内の名前として扱われる。クラスAからprivate派生したクラスBから派生しているクラスCでは、クラスAのクラス名自体がprivateメンバーになってしまう。

// グローバル名前空間のスコープ
struct A { } ;
class B : private A { } ;
class C : public B
{
    void f()
    {
        A a1 ; // エラー、名前Aは、基本クラスのprivateメンバーのA
        ::A a2 ; // OK、名前::Aは、グローバル名前空間スコープ内のA
    }
} ;

この例では、クラスCのスコープ内で、非修飾名Aに対して、クラス名Aが発見されてしまうので、エラーになる。クラスCの中でクラスAを使いたい場合、明示的な修飾が必要である。

アクセス指定子は、staticメンバーにも適用される。publicなstaticメンバーを持つクラスを、protectedやprivateで派生すると、基本クラスからはアクセスできるが、派生クラスを介してアクセスできなくなってしまうこともある。

// グローバル名前空間のスコープ
struct A { static int data ; } ;
int A::data ; 

class B : private A { } ;
class C : public B
{
    void f()
    {
        data ; // エラー
        ::A::data ; // OK
    }
} ;

クラスCからは、名前dataは、基本クラスAのメンバーdataとして発見されるので、アクセスできない。しかし、クラスA自体は、名前空間に存在するので、明示的な修飾を使えば、アクセスできる。

protectedの場合、friendではないクラス外部の関数からアクセスできなくなる。

struct A { static int data ; }
int A::data ;

class B : protected A { } ;

int main()
{
    B::data ; // エラー
    A::data ; // OK
}

ここでは、B::dataとA::dataは、どちらも同じオブジェクトを指しているが、アクセス指定の違いにより、B::dataという修飾名では、クラスBのfriendではないmain関数からアクセスすることができない。

基本クラスにアクセス可能である場合、派生クラスへのポインター型から、基本クラスへのポインター型に型変換できる。

class A { } ;
class B : public A { } ;
class C : protected A
{
    void f()
    {
        static_cast< A * >( this ) ; // OK、アクセス可能
    }
} ;

int main()
{
    B b ;  
    static_cast< A * >( &b ) ; // OK、アクセス可能
    C c ;
    static_cast< A * >( &c ) ; // エラー、main関数からは、protectedメンバーにアクセスできない
    
}

friend（Friends）

クラスはfriendを宣言することができる。friendを宣言するには、friend指定子を使う。クラスのfriendとして宣言できるものは、関数かクラスである。クラスのfriendは、クラスのprivateとprotectedメンバーにアクセスできる。

class X
{
private :
    typedef int type ; // privateメンバー
    friend void f() ; // friend関数
    friend class Y ; // friendクラス
} ;

void f()
{
    X::type a ; // OK、関数void f(void)はXのfriend
}

class Y
{
    X::type member ; // OK、クラスYはXのfriend
    void f()
    {
        X::type member ; // OK、クラスYはXのfriend        
    }
} ;

friendクラスの宣言は、friend指定子に続けて、複雑型指定子、単純型指定子、typename指定子（名前解決を参照）のいずれかを宣言しなければならない。

複雑型指定子は、最も分かりやすい。

class X
{
    friend class Y ;
    friend struct Z ;
} ;

複雑型指定子を使う場合、クラスをあらかじめ宣言しておく必要はない。名前がクラスであることが、その時点で宣言されるからだ。

単純型指定子に名前を使う場合は、それより以前に、クラスを宣言しておく必要がある。

class Y ; // Yをクラスとして宣言

class X
{
    friend Y ; // OK、Yはクラスである
    friend Z ; // エラー、名前Zは見つからない

    friend class A ; // OK、Aはクラスとして、ここで宣言されている
} ;

あらかじめ名前が宣言されていない場合は、エラーとなる。

単純型指定子にテンプレート名を使うこともできる。

template < typename T >
class X
{
    friend T ; // OK
} ;

typename指定子を指定する場合は、以下のようになる。

template < typename T >
class X
{
    friend typename T::type ;
} ;

T::typeは、依存名を型として使っているので、typenameが必要である。

もし、型指定子がクラス型ではない場合、単に無視される。これは、テンプレートコードを書くときに便利である。

template < typename T >
class X
{
    friend T ;
} ;

X<int> x ; // OK、friend宣言は無視される

template < typename T >
class Y
{
    friend typename T::type ;
} ;

struct Z { typedef int type ; } ;

Y<Z> y ; // OK、friend宣言は無視される

無視されるのは、あくまで、型指定子がクラス型ではなかった場合である。すでに説明したように、単純型指定子で、名前が見つからなかった場合は、エラーになる。

friend関数の宣言は、通常通りの関数の宣言の文法に、friend指定子を記述する。前方宣言は必須ではない。friend関数には、ストレージクラス指定子を記述することはできない。

class X
{
    friend void f() ;
    friend int g( int, int, int ) ;
    friend X operator + ( X const &, X const & ) ;
} ;

friend関数として宣言された関数がオーバーロードされていた場合でも、friend関数として宣言したシグネチャの関数しか、friendにはならない。

void f( int ) ;
void f( double ) ;

class X
{
    friend void f( int ) ;
} ;

この例では、void f(int)のみが、Xのfriend関数になる。void f(double)は、friend関数にはならない。

他のクラスのメンバー関数も、friend関数として宣言できる。メンバー関数には、コンストラクターやデストラクターも含まれる。

class X ; // 名前Xをクラス型として宣言

class Y
{
public :
    void f( ) ; // メンバー関数
    Y & operator = ( X const & ) ; // 代入演算子
    Y() ; // コンストラクター
    ~Y() ; // デストラクター
} ;

class X
{
    // 以下4行は、すべて正しいfriend宣言
    friend void Y::f( ) ;
    friend Y & Y::operator = ( X const & ) ;
    friend Y::Y() ;
    friend Y::~Y() ;
} ;

friend宣言自体には、アクセス指定は適用されない。ただし、friend宣言の中でアクセスできない名前を使うことはできない。

class Y
{
private :
    void f( ) ; // privateメンバー
} ;

class X
{
    // エラー、Yのprivateメンバーにはアクセス出来ない
    // friend宣言の中の名前の使用には、アクセス指定が影響する
    friend void Y::f() ;

// アクセス指定は、friend宣言自体に影響を及ぼさない
// 以下3行のfriend宣言に、アクセス指定は何の意味もなさない
private :
    friend void f() ;
protected :
    friend void g() ;
public :
    friend void h() ;
} ;

Y::fはprivateメンバーなので、Xからはアクセスできない。Xのfriend宣言は、関数f, g, hを、Xのfriendとして宣言しているが、この宣言に、Xのアクセス指定は何の効果も与えない。

friend宣言は、実は関数を定義することができる。

class X
{
    friend void f() { } // 関数の定義
} ;

friend宣言で定義された関数は、クラスが定義されている名前空間スコープの関数になる。クラスのメンバー関数にはならない。ただし、friend宣言で定義された関数は、ADLを使わなければ、呼び出すことはできない。非修飾名前探索や、修飾名前探索で、関数名を参照する方法はない。

// グローバル名前空間のスコープ

class X
{
    // fはメンバー関数ではない
    // クラスXの定義されているグローバル名前空間のスコープ内の関数
    friend void f( X ) { }
    // gはメンバー関数ではない
    // gを呼び出す方法は存在しない
    friend void g() { }
} ;

int main()
{
    X x ;
    f(x) ; // OK、ADLによる名前探索

    (f)(x) ; // エラー、括弧がADLを阻害する。ADLが働かないので名前fが見つからない
    ::f(x) ; // エラー、名前fが見つからない
    g() ; // エラー、名前gが見つからない
}

このように、通常の名前探索では関数名が見つからないという問題があるため、friend宣言内での関数定義は、行うべきではない。

friendによって宣言された関数は、前方宣言されていない場合、外部リンケージを持つ。前方宣言されている場合、リンケージは前方宣言に従う。

inline void g() ; // 前方宣言、関数gは内部リンケージを持つ

class X
{
    friend void f() ; // 関数fは外部リンケージを持つ
    friend void g() ; // 関数gは内部リンケージを持つ
} ;

// 定義
void f() { } // 外部リンケージ
inline void g() { }

friend宣言は、派生されることはない。また、あるクラスのfriendのfriendは、あるクラスのfriendではない。つまり、友達の友達は、友達ではない。

class A
{
private :
    typedef int type ;
    friend class B ;
} ;

class B
{
    // OK、BはAのfriend
    typedef A::type type ;

    friend class C ;
} ;

class C
{
    // エラー、BはAのfriendである。CはBのfriendである。
    // Cは、Aからみて、friendのfriendにあたる。
    // しかし、CはAのfriendではない。
    typedef A::type type ;
} ;

class D : public B
{
    // エラー、DはBから派生している。BはAのfriendである。
    // しかし、DはAのfriendではない
    typedef A::type type ;
} ;

ローカルクラスの中でfriend宣言で、非修飾名を使った場合、名前探索において、ローカルクラスの定義されている関数外のスコープは考慮されない。friend関数を宣言する場合、対象の関数はfriend宣言に先立って宣言されていなければならない。friendクラスを宣言する場合、クラス名はローカルクラスの名前であると解釈される。

class A ; // ::A
void B() ; // ::B

void f()
{
    // 関数の前方宣言は関数内でも可能
    void C( void ) ; // 定義は別の場所

    class Y ; // ローカルクラスYの宣言

    // ローカルクラスXの定義
    class X
    {
        friend class A ; // OK、ただし、::Aではなく、ローカルクラスのA
        friend class ::A ; // OK、::A
        friend class Y ; // OK、ただしローカルクラスY

        friend void B() ; // エラー、Bは宣言されていない。::Bは考慮されない
        friend void C() ; // OK、関数内の前方宣言により名前を発見
    } ;
}

friend宣言とテンプレートの組み合わせについては、テンプレート宣言のfriendを参照。

protectedメンバーアクセス（Protected member access）

protectedメンバーは、friendか、メンバーの宣言されたクラスか、クラスから派生しているクラスからアクセスすることができる。

void g() ;

class Base
{
    friend void g() ;

protected :
    int member ;
} ;

void f()
{
    Base base ;
    base.member ; // エラー、protectedメンバー
}

void g()
{
    Base base ;
    base.member ; // OK、gはBaseのfriend
}

class Derived : protected Base
{
    void f()
    {
        member ; // OK、DerivedはBaseから派生している
    }
} ;

virtual関数へのアクセス（Access to virtual functions）

virtual関数へのアクセスは、virtual関数の宣言によって決定される。virtual関数のオーバーライドには影響されない。

class Base
{
public :
    virtual void f() { }
} ;

class Derived : public Base
{
private :
    void f() { } // Base::fをオーバーライド
} ;

int main()
{
    Derived d ;
    d.f() ; // エラー、Derived::fはprivateメンバー

    Base & ref = d ;
    ref.f() ; // OK、Derived::fを呼ぶ
}

Derived::fはprivateメンバーなので、関数mainから呼び出すことはできない。しかし、Base::fはpublicメンバーである。Base::fはvirtual関数なので、呼び出す関数は、実行時のオブジェクトの型によって決定される。この時、オーバーライドしたvirtual関数のアクセス指定は、考慮されない。Base::fのアクセス指定のみが考慮される。この例では、関数mainから、Derived::fを直接呼び出すことはできないが、Baseへのリファレンスやポインターを経由すれば、呼び出すことができる。

virtual関数呼び出しのアクセスチェックは、呼び出す際の式の型によって、静的に決定される。基本クラスでpublicメンバーとして宣言されているvirtual関数を、派生クラスでprotectedやprivateにしても、基本クラス経由で呼び出すことができる。

複数のアクセス（Multiple access）

多重派生によって、基本クラスのメンバーに対して、複数のアクセスパスが形成されている場合、アクセス可能なパスを経由してアクセスが許可される。

class Base
{
public :
    void f() { }
} ;

class D1 : private virtual Base { } ;
class D2 : public virtual Base { } ;

class Derived : public D1, public D2
{
    void f()
    {
        Base::f() ; // OK、D2を経由してアクセスする
    }
} ;

D1はBaseをprivate派生しているので、DerivedからD1経由では、Baseにアクセスできない。しかし、D2経由でアクセスできる。

ネストされたクラス（Nested classes）

ネストされたクラスも、クラスのメンバーであるので、他のメンバーとアクセス権限を持つ。

class Outer
{
private :
    typedef int type ; // privateメンバー

    class Inner
    {
        Outer::type data ; // OK、InnerはOuterのメンバー
    } ;
} ;

OuterにネストされたクラスInnerは、Outerのメンバーなので、Outerのprivateメンバーにアクセスすることができる。

ただし、ネストされたクラスをメンバーとして持つクラスは、ネストされたクラスに対して、特別なアクセス権限は持たない。

class Outer
{
    class Inner
    {
    private :
        typedef int type ; // privateメンバー
    } ;

    void f()
    {
        Inner::type x ; // エラー、Inner::typeはprivateメンバー
    }
} ;

この例では、Outerは、Innerのprivateメンバーにはアクセスできない。

コンストラクター（Constructors）

コンストラクターは名前を持たない。コンストラクターの宣言には、特別な文法が用いられる。

関数指定子もしくはconstexpr クラス名 仮引数リスト

struct X
{
    X() ; // コンストラクターの宣言
} ;

X::X() { } // コンストラクターの定義

コンストラクターは、クラス型のオブジェクトを初期化するのに用いられる。

コンストラクターのクラス名に、typedef名を用いることはできない。

コンストラクターに、virtual指定子、static指定子を指定することはできない。要約すれば、コンストラクターに使用可能な指定子は、inline、explicit、constexprである。コンストラクターをCV修飾することはできない。ただし、コンストラクターは、CV修飾されたオブジェクトの初期化に対しても、呼び出される。オブジェクトのCV修飾子は、構築中のオブジェクトには適用されないからである。コンストラクターをリファレンス修飾することはできない。

struct X {
    virtual X() ; // エラー、コンストラクターにvirtual指定子は使えない
    static X() ; // エラー、コンストラクターにstatic指定子は使えない
    X() const ; // エラー、コンストラクターはCV修飾できない
    X() & ; // エラー、コンストラクターはリファレンス修飾できない
} ;

デフォルトコンストラクター

実引数なしで呼べるコンストラクターを、デフォルトコンストラクター（default constructor）という。これには、仮引数を取らないコンストラクターの他に、仮引数にすべてデフォルト実引数が指定されているコンストラクターも含まれる。

以下はすべて、Xに対するデフォルトコンストラクターの宣言である。

X() ;
X( int = 0 ) ;
X( int = 0, int = 0 ) ;

もし、ユーザー定義のコンストラクターが存在しない場合、暗黙のデフォルトコンストラクターが、デフォルト化されて宣言される。

struct X
{
// デフォルトコンストラクターの定義なし
// 暗黙に、X() = default ; が宣言される
} ;

struct Y
{
    Y(int) ; // ユーザー定義のコンストラクター
// 暗黙のデフォルトコンストラクターはdefault化されない
} ;

ただし、以下のいずれかの条件をみたすクラスの場合、暗黙のデフォルトコンストラクターはdelete定義される。

unionのようなクラスで、共用メンバーが非トリビアルデフォルトコンストラクターを持つ場合

// 非トリビアルデフォルトコンストラクターを持つクラス
struct NonTrivial
{
    NonTrivial() { } // 非トリビアルデフォルトコンストラクター
} ;

// 非トリビアルデフォルトコンストラクターを持つメンバーのあるunion
union X
{
// 暗黙のデフォルトコンストラクターはdelete定義される
    NonTrivial nt ;
} ;

// そのような無名unionを直接のメンバーに持つクラス
struct Y
{
// 暗黙のデフォルトコンストラクターはdelete定義される
    union { NonTrivial nt ; } ;
} ;

初期化子のないリファレンス型の非staticデータメンバーを持つクラスの場合

int OBJECT ; // グローバル変数

struct X
{
// 初期化子のないリファレンス型の非staticデータメンバー
    int & ref ;
} ;

struct Y
{
// 初期化子がある
    int & ref = OBJECT ;
} ;

struct Z
{
    int & ref ;
// ユーザー定義のコンストラクターがある
    Z() : ref( OBJECT ) { }
} ;

int main()
{
    X x ; // エラー、デフォルトコンストラクターがdelete定義される
    Y y ; // OK
    Z z ; // OK
}

クラスXのデフォルトコンストラクターは暗黙にdelete定義される。Y::refには初期化子がある。Zにはユーザー定義のコンストラクターがある。

unionのメンバーではない、const修飾された型かあるいはその配列型の、非staticデータメンバーが、ユーザー定義デフォルトコンストラクターを持たず、初期化子もない場合。

// ユーザー定義デフォルトコンストラクターを持たないクラス
struct NoUserDefined { } ;

struct X
{
// 初期化子がない
    NoUserDefined const member ;
    NoUserDefined const array[1] ;
} ;

struct Y
{
// 初期化子がある
    NoUserDefined const member = NoUserDefined() ;
} ;


struct Z
{
    NoUserDefined const member ;
// memberに対する初期化子がないので不可
// Z() : member() { } なら可
    Z() { }    
} ;

int main()
{
    X x ; // エラー
    Y y ; // OK
    Z z ; // エラー
}

気をつける点としては、Zのユーザー定義デフォルトコンストラクターが、Z(){}という形の場合、Z::memberに対する初期化子がないので、エラーになる。Z() : member() { }という形の場合は、初期化子があるので、エラーにはならない。

unionのようなクラスで、共用メンバーがconst修飾されている場合。これには、const修飾されている型への配列型も含む。

union X
{ // すべてconst修飾されている
    int const a ;
    int const b ;
    int const c[1] ;
} ;

struct Y
{ // すべてconst修飾されている無名unionをメンバーに持つ
    X x ;
} ;

union Z
{
    int a ; // const修飾されていない
    int const b ;
    int const c[1] ;
} ;


int main()
{
    X x ; // エラー
    Y y ; // エラー
    Z z ; // OK、Y::aはconst修飾されていない。
}

unionのすべての非staticデータメンバーがconst修飾されている場合のみ、デフォルトコンストラクターが暗黙にdelete定義される。ひとつでもconst修飾されていない非staticデータメンバーがある場合、この条件には当てはまらない。

直接の基本クラス、仮想基本クラス、初期化子のない非staticデータメンバーの型が、デフォルトコンストラクターが使えない型である場合。これには、配列型も含まれる。

// デフォルトコンストラクターが使えないクラスの例
struct X
{
    X() = delete ;
} ;

// 直接の基本クラス
struct A : X { } ;
// 仮想基本クラス
struct B : virtual X { } ;
// 初期化子のない非staticデータメンバー
struct C
{
    X a ;
    X b[1] ;
} ;

クラスA、B、Cは、いずれもデフォルトコンストラクターが暗黙にdelete定義される。

ある型のデフォルトコンストラクターが使えない場合というのは、以下の通りである。

デフォルトコンストラクターがない場合。

// ユーザー定義コンストラクターがある場合、暗黙のデフォルトコンストラクターは定義されない。
struct NoDefaultConstructor { NoDefaultConstructor(int) ; } ;
struct X : NoDefaultConstructor { } ;

デフォルトコンストラクターのオーバーロード解決の結果が曖昧になる場合。

struct Ambiguous
{
    Ambiguous( int = 0 ) { }
    Ambiguous( double = 0.0 ) { }
} ;

struct X : Ambiguous { } ;

int main()
{
    Ambiguous a ; // エラー、デフォルトコンストラクターのオーバーロード解決が曖昧
    X b ; // エラー、デフォルトコンストラクターは暗黙にdelete定義されている
}

デフォルトコンストラクターがdelete定義されている場合

struct X
{
    X() = delete ; // デフォルトコンストラクターのdelete定義
} ;

クラスのデフォルト化されたデフォルトコンストラクターから、ある型のデフォルトコンストラクターにアクセス出来ない場合。

class B1
{
private :
    B1() = default ;
} ;

class B2
{
private :
    B2() { }
} ;

class D1 : public B1 { } ;
class D2 : public B2 { } ;

int main()
{
    D1 a ; // エラー、デフォルトコンストラクターは暗黙にdelete定義されている
    D2 b ; // エラー、デフォルトコンストラクターは暗黙にdelete定義されている
}

クラスB1、B2のデフォルトコンストラクターは、privateメンバーなので、friendではないクラスD1、D2からはアクセスできない。そのため、デフォルトコンストラクターは暗黙にdelete定義される。

これらの条件に当てはまらない場合、デフォルトコンストラクターは暗黙にdefault化される。

デフォルトコンストラクターがトリビアル（trivial）となるためには、以下の条件をすべて満たさなければならない。

デフォルトコンストラクターがユーザー定義もdelete定義もされていない。クラスはvirtual関数とvirtual基本クラスを持たない。クラスの非staticデータメンバーは、初期化子を持たない。クラスの直接の基本クラスは、トリビアルデフォルトコンストラクターを持つ。クラスの非staticデータメンバーは、トリビアルデフォルトコンストラクターを持つ。

デフォルトコンストラクターは、使われたときに、暗黙にdefault化される。デフォルトコンストラクターがdelete定義されずに、default化された場合、暗黙に定義される。この暗黙のデフォルトコンストラクターは、コンストラクター初期化子を書かずコンストラクターの本体を空にした、ユーザー定義のデフォルトコンストラクターと同等である。

struct X
{
    // 暗黙のデフォルトコンストラクターは、以下のコードと同じ
    // X(){}
} ;

struct Y { } ;

int main()
{
    X x ; // 暗黙のデフォルトコンストラクターを使う
}

クラスXはデフォルトコンストラクターが使われているので、暗黙にdefault化される。クラスYのデフォルトコンストラクターは使われていないので、定義されない。

もし、暗黙のデフォルトコンストラクターが定義されていて、同等のユーザー定義のデフォルトコンストラクターを書いた場合にエラーとなる場合は、プログラムもエラーとなる。

struct X { int & ref ; } ;
struct Y { int & ref ; } ;

int main()
{
    X x ; // エラー
    int obj = 0 ;
    Y y = { obj } ; // OK
}

クラスXはデフォルトコンストラクターを使っているので、暗黙のデフォルトコンストラクターがdefault化される。しかし、リファレンスの非staticデータメンバーを持つことにより、同等のユーザー定義のデフォルトコンストラクターがエラーになるので、エラーとなる。一方、クラスYでは、デフォルトコンストラクターが使われていない。

同等のユーザー定義のデフォルトコンストラクターがconstexprコンストラクターの要求を満たす場合、暗黙のデフォルトコンストラクターも、constexprコンストラクターになる。

デフォルトコンストラクターは、初期化子なしで定義されたオブジェクトや、関数形式の明示的なキャストに対して呼ばれる。

struct X { X() { } } ;

X x ; // デフォルトコンストラクターが呼ばれる

int main()
{
    X x ; // デフォルトコンストラクターが呼ばれる
    new X ; // デフォルトコンストラクターが呼ばれる
    X() ; // デフォルトコンストラクターが呼ばれる
}

クラスのオブジェクトをコピー、ムーブする際には、コピー、ムーブコンストラクターがそれぞれ使われる。詳しくは、クラスオブジェクトのコピーとムーブを参照。

基本クラスと非staticデータメンバーのコンストラクターが呼ばれる順番や、実引数の渡し方については、基本クラスとデータメンバーの初期化を参照。

その他のコンストラクターについては、型変換コンストラクターを参照。

コンストラクターに戻り値の型を指定することはできない。コンストラクターの本体の中でreturn文を使う場合は、値を指定してはならない。コンストラクターのアドレスを取得することはできない。

constなオブジェクトの構築中に、コンストラクターのthisを、直接、間接的に経由しないglvalueによってオブジェクト、またはそのサブオブジェクトにアクセスした場合、値は未規定である。この制限には、通常、まず遭遇することはない。例えば、以下のようなコードが問題になる。

struct C ;

void f( C * ) ;

struct C
{
    int value ;
    C() : c(123)
    { // オブジェクトは、まだ構築中
        f( this ) ; // オブジェクトの構築中に呼び出す
    }
} ;

const C cobj ; // staticストレージ上のconstなオブジェクト

void f( C* cptr )
{
    cptr->value ; // OK、値は123。cptrはコンストラクターのthis由来
    cobj.value ; // 値は未規定
}

オブジェクトは、コンストラクターを実行し終わった時点で、構築済みとなる。コンストラクターを実行中ということは、まだオブジェクトは構築中ということである。cobjは、デフォルトコンストラクターを呼び出す。したがって、関数fは、cobjの構築中に呼び出されるということになる。cptrの値は、コンストラクターのthisによって得られたアドレスである。したがって、cptrの値である、Cのオブジェクトへのアドレスを参照して、cobjにアクセスすることはできる。関数fは、クラスCのコンストラクターから呼び出されている。関数fの中からcobjを直接参照するということは、cobjの構築中に、コンストラクターのthisによらずにアクセスするということである。この場合、値は未規定となる。この例では、123であるとは保証されない。

この条件に当てはまるようなコードは、現実には極めて珍しい。

一時オブジェクト（Temporary objects）

一時オブジェクト（temporary object）は、様々な場面で、自動的に生成、破棄される。例えば、prvalueをリファレンスに束縛する、prvalueを返す、prvalueを生成する型変換、例外のthrow、ハンドラーでキャッチ、初期化などである。例外における一時オブジェクトの寿命は、例外を参照。

struct X { } ;

X f()
{
    return X() ; // prvalueを生成する型変換
}

int main()
{
    int && ref = 0 ; // prvalueをリファレンスに束縛する
    f() ; // prvalueを返す
}

実装は一時オブジェクトの生成を省略できる。例えば、以下のコードについて考える。

struct X
{
    X( int ) ; // コンストラクター
    X( X const & ) ; // コピーコンストラクター
    X & operator = ( X const & ) ; // コピー代入演算子
    ~X() ; // デストラクター
} ;

struct Y
{
    Y( int ) ; // コンストラクター
    Y( Y && ) ; // ムーブコンストラクター
    ~Y() ; // デストラクター
};

X f( X ) ;
Y g( Y ) ;

int main()
{

    X a = f( X(2) ) ; // #1
    Y b = g( Y(3) ) ; // #2
    X c(1) ;
    c = f(c) ; // #3
}

#1について考える。ある実装では、X(2)という式で一時オブジェクトがひとつ作られ、関数の実引数として渡す際に、別の一時オブジェクトがひとつ作られてコピーされるかもしれない。関数の戻り値も、別の一時オブジェクトがひとつ作られて、変数aにコピーされるかもしれない。別の実装では、X(2)という式による一時オブジェクトは、関数の実引数の一時オブジェクト上に直接構築されるので、一時オブジェクトを省略できるかもしれない。関数の戻り値も、変数aのオブジェクト上に直接構築されるので、一時オブジェクトを省略できるかもしれない。

#2も、コピーがムーブに、変数aがbに変わっただけで、同じことが言える。

#3では、変数cは、すでに構築されたオブジェクトなので、関数の戻り値の一時オブジェクトを、変数cのオブジェクトの上に、直接構築することはできない。ここでは一時オブジェクトが構築され、変数cにコピーされる。

一時オブジェクトの構築が省略されたとしても、もし一時オブジェクトを作成していればエラーになるようなコードは、エラーになる。たとえば、コンストラクターやデストラクターにアクセスできない場合だ。

一般に、ある式において一時オブジェクトがいくつ構築されるかということは、規格では定義されていない。実装次第である。一時オブジェクトが構築されなければ、コンストラクターやデストラクターも呼ばれない。

逆に、一時オブジェクトが構築される場合、非トリビアルなコンストラクターは必ず呼び出されるし、破棄するときには、非トリビアルなデストラクターは必ず呼び出される。

一時オブジェクトの破棄は原則として、その一時オブジェクトを構築することになった式を含む完全式の評価の最後の段階として、実行される。言いかえれば、一時オブジェクトの寿命は、完全式が評価され終わるまでということもできる。

struct X
{
    X operator + ( X const & ){ return X() ; }
} ;

int main()
{
    X a = 0 ;
    X b = a + a + a ;
}

この例で、bの初期化子の中の式において構築された一時オブジェクトがもしあれば、その寿命は、ソースコード上で言えば、セミコロンまでとなる。

ただし、この原則に従わない場合が、ふたつ存在する。

ひとつは、配列の要素を初期化する際に、デフォルトコンストラクターがデフォルト実引数を持っていた場合、ある要素のデフォルトコンストラクター実行における一時オブジェクトの破棄は、次の要素の初期化の前に行われる。破棄に伴うあらゆるサイドエフェクトは、次の要素の初期化の以前にシーケンス（sequenced before）される。

struct Fat { char [1000] ; } ;

struct X
{
    X( Fat f = Fat() ) { } // デフォルトコンストラクター
} ;

int main()
{
    X a[1000] ;
}

この例では、a[0]からa[999]までの1000個のX型の配列の要素に対し、デフォルトコンストラクターが呼び出される。もし、a[0]がa[1]の前に初期化された場合、a[0]のデフォルトコンストラクター呼び出しによって構築されたFat型の一時オブジェクトは、a[1]を初期化するときには、すでに破棄されている。配列のすべての要素を初期化し終わるまで、1000個のFat型の一時オブジェクトが保持されることはない。

もうひとつは、一時オブジェクトをリファレンスに束縛した場合、一時オブジェクトの寿命は、リファレンスの寿命まで延長される。一時オブジェクトは、rvalueリファレンスか、constなlvalueリファレンスで束縛できる。

struct X { } ;

int main()
{
    {
        X const & lvalue_reference = X() ;
        X && rvalue_reference = X() ;
    // 一時オブジェクトの寿命はここまで
    }
}

ただし、このリファレンス束縛の寿命の延長には、いくつかの例外が存在する。

コンストラクター初期化子によってリファレンスのメンバーに束縛された一時オブジェクトの寿命は、コンストラクター呼び出しが終了するまでである。

struct Member { } ;

struct X
{
    Member const & ref ;
    X( Member const & ref ) : ref(ref)
    {
        // refは妥当なオブジェクトを参照している
    }
} ;

int main()
{
    X x = Member()  ;
    // 一時オブジェクトが破棄される
    // x.refは無効なオブジェクトを参照している
}

もし、クラスXのコンストラクターの実引数が、一時オブジェクトへのリファレンスだった場合、一時オブジェクトの寿命は、コンストラクター呼び出しが終了するまでである。そのため、初期化の終わった変数xのメンバーrefは、無効なオブジェクトを参照していることになる。

仮引数のリファレンスに束縛された一時オブジェクトの寿命は、関数呼び出しを含む式の完全式の評価が終了するまでである。

struct X { } ;

void f( X const & ref )
{
    // refは妥当なオブジェクトを参照している
}

int main()
{
    f( X() ) ;
    // 一時オブジェクトが破棄される
}

この例で、X()を含む完全式というのは、関数fに対する関数呼び出し式のオペランドである。したがって、完全式はX()となる。しかし、この解釈に従うと、関数の本体では、refは無効なオブジェクトを参照することになってしまう。そのため、仮引数のリファレンス束縛に対しては、関数呼び出しを含む完全式になる。この場合、f( X() )である。そのため、X()によって構築された一時オブジェクトは、関数fの本体の中でも妥当である。

関数のreturn文によって構築された、関数の戻り値のリファレンスに束縛された一時オブジェクトの寿命は、延長されない。一時オブジェクトは、return文を含む完全式の終了をもって、破棄される。

struct X { } ;

X const & f( X const & ref )
{
    return X() ;
}

int main()
{
    X const & ref = f( X() ) ;
    // 一時オブジェクトは破棄される
    // refは無効なオブジェクトを参照している
}

このように、関数の戻り値としてのリファレンスに束縛されても、一時オブジェクトの寿命は延長されない。これには注意が必要である。

new初期化子の中でリファレンス束縛された一時オブジェクトの寿命は、new初期化子を含む完全式の終わりまでである。

struct X { int const & ref ; } ;

int main()
{
    X * ptr = new X{ 0 } ;
    // 一時オブジェクトが破棄される
    // ptr->refは無効なオブジェクトを参照している
}

リファレンス束縛により、寿命の延長を受けていない一時オブジェクトの破棄の順番は、構築の逆順に行われる。後に構築された一時オブジェクトの方が、先に構築された一時オブジェクトより、先に破棄される。

もし、リファレンス束縛を受けた、複数の一時オブジェクトが、同じ場所で破棄される場合、破棄の順番は、構築の逆順に行われる。

struct X { X( int ) { } } ;
void f( X const &, X const & ) { }

int main()
{
    f( X(1), X(2) ) ; // #1
}

今、#1のX(1)、X(2)という式に対して、それぞれ一時オブジェクトが構築されたとする。関数の実引数の評価順序は規定されていないので、どちらが先に構築されるかは、規格の定めるところではない。しかし、仮にX(1)の一時オブジェクトが、X(2)に先んじて構築された場合、オブジェクトの破棄は、X(2)が先になる。

型変換（Conversions）

クラスの型変換を実現するには、方法がふたつある。コンストラクターと変換関数（conversion function）だ。このふたつを合わせて、ユーザー定義型変換（user-defined conversions）という。ユーザー定義型変換は、暗黙の型変換、初期化、明示的な型変換に用いられる。

ひとつの値に対して、ユーザー定義型変換は1回しか適用されない。

struct X { } ;
struct Y
{
    Y( int ){ } // int型からY型へ
    operator X() { return X() ; } // Y型からX型へ
} ;

int main()
{
    Y a = 0 ; // OK、int型からY型への型変換
    X b = Y(0) ; // OK、Y型からX型への型変換
    X c = 0 ; // エラー
}

ユーザー定義型変換によって、int型からY型に変換することはできる。また、Y型からX型に変換することはできる。ただし、int型から、暗黙にX型に変換することはできない。なぜならば、それにはユーザー定義型変換を、2回適用しなければならないからだ。

ユーザー定義型変換は、曖昧にならない場合のみ、暗黙に使われる。派生クラスの型変換関数は、基本クラスの型変換関数を隠さない。ただし、同じ型に対する型変換関数の場合を除く。複数の型変換関数がある場合、関数のオーバーロード解決と同じ方法で、最適な関数が解決される。

struct Base
{
    operator int() { return 0 ; }
} ;
struct Derived : Base
{
    // Base::operator intを隠さない
    operator char() { return char(0) ; }
} ;

int main()
{
    Derived obj ;
    int a = obj ; // OK
    char b = obj ; // OK
    bool c = obj ; // エラー、曖昧
}

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 ) ;
}

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
}

struct X
{
    X() { }
    explicit X( X const & ) {} // explicitコピーコンストラクター
} ;

int main()
{
    X a ;
    X b = a ; // エラー、コピー初期化（代入式とは違うことに注意）
    X c( a ) ; // OK、直接初期化
}

struct X
{
    X() { }
} ;

struct Y
{
    explicit Y() { }
} ;


int main( )
{
    X x( { } ) ; // OK、非explicitデフォルトコンストラクター
    Y y( { } ) ; // エラー、explicitデフォルトコンストラクター
}

explicitopt operator 型識別子 ( )

struct X
{
    operator int() { return 0 ; } 
} ;

int main()
{
    X x ;
    int i = x ; // 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)() ; // 呼び出す
}

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 ; // 標準型変換が使われる。型変換関数は使われない
}

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を呼び出す
}

struct Base
{
    // ピュアvirtual関数
    virtual operator int() = 0 ;
} ;

struct Derived : Base
{
    // オーバーライド
    virtual operator int() { return 0 ; }
} ;

struct X
{
    static operator int() ; // エラー
} ;

デストラクター（Destructors）

以下のような文法の宣言を、デストラクター（destructor）という。

関数指定子opt ~ クラス名 ( )

デストラクターの宣言は、~（チルダ）に続いて、クラス名、空の引数リストを指定する。関数指定子には、inlineとvirtualを指定できる。クラス名の代わりに、typedef名を使用することはできない。

struct X
{
    ~X() ; // デストラクターの宣言
} ;

デストラクターはクラス型のオブジェクトを破棄する際に使われる。デストラクターには、仮引数や戻り値の型を指定することはできない。デストラクターのアドレスを得ることはできない。デストラクターはstaticメンバーにはなれない。デストラクターは、CV修飾、リファレンス修飾できない。ただし、デストラクターは、CV修飾されたクラス型のオブジェクトに対しても呼び出される。

struct X
{
    ~X() { }
} ;

int main()
{
    {
        X x ;
    // オブジェクト破棄、デストラクターが呼ばれる
    }

    X * ptr = new X ;
    delete ptr ; // オブジェクト破棄、デストラクターが呼ばれる
}

デストラクターの宣言に例外指定がない場合は、暗黙のデストラクターと同等の例外指定が、暗黙に指定される。詳しくは、例外指定を参照。

クラスにユーザー宣言されたデストラクターがない場合、デストラクターは暗黙にdefault化されて宣言される。暗黙に宣言されたデストラクターは、クラスのinline publicメンバーである。

暗黙のデストラクターは、以下のいずれかの条件を満たしたとき、delete定義される。

struct Trivial { } ;
struct NonTrivial { ~NonTrivial() { } } ;

// デストラクターは暗黙にdefault化される
union A1 { Trivial member ; } ;
struct A2 { union { Trivial member ; } ; } ;

// デストラクターは暗黙にdelete定義される
union B1 { NonTrivial member ; } ;
struct B2 { union { NonTrivial member ; } ; } ;

int main()
{
// OK、暗黙のデストラクターを使う
    A1 a1 ; A2 a2 ;
// エラー、暗黙のデストラクターはdelete定義されている
    B1 b1 ; B2 b2 ;
}

struct deleted_destructor
{
    ~deleted_destructor() = delete ;
} ;

struct inaccessible_destructor
{
private :
    ~inaccessible_destructor() ;
    friend struct Y ; 
} ;

// クラスのデストラクターは暗黙にdelete定義される
struct X
{
    deleted_destructor m1 ; // デストラクターがdelete定義されている
    inaccessible_destructor m2 ; // デストラクターにアクセス出来ない
} ;

struct Y
{
    inaccessible_destructor m ; // friendなので、デストラクターにアクセス可能
} ;

struct Base
{ 
    ~Base() = delete ;
} ;

struct D1 : Base
{
// D1のデストラクターはdelete定義される
} ;

struct Base
{ 
private :
    ~Base() { }
    friend struct D1 ;
} ;

struct D1 : Base
{
// friend宣言により、Baseのデストラクターにアクセスできる
} ;

struct D2 : D1
{
// D1のデストラクターにアクセスできる
} ;


int main()
{
    D1 d1 ; // OK
    D2 d2 ; // OK
}

struct Base
{ 
private :
    ~Base() { }
    friend struct D1 ;
} ;

struct D1 : virtual Base
{
// friend宣言により、Baseのデストラクターにアクセスできる
} ;

struct D2 : D1
{
// virtual基本クラスのBaseのデストラクターにアクセスできない
// デストラクターは暗黙にdelete定義される
} ;


int main()
{
    D1 d1 ; // OK、暗黙のデストラクターを使う
    D2 d2 ; // エラー、デストラクターはdelete定義されている
}

デストラクターがトリビアルとなるためには、ユーザー提供もdelete定義もされておらず、以下の条件をすべて満たす必要がある。

• デストラクターはvirtualではない。
• 直接の基本クラスのデストラクターは、すべてトリビアルである。
• 非staticデータメンバーのデストラクターは、すべてトリビアルである。

注意すべきこととしては、直接の基本クラスのデストラクターがトリビアルとなるためには、直接の基本クラスの直接の基本クラスのデストラクターもトリビアルでなければならない。つまり、最終的には、間接の基本クラスのデストラクターも、すべてトリビアルでなければならない。

delete定義されていない暗黙のデストラクターは、使われたときに、定義される。もしくは、明示的にdefault化されたときにも定義される。

デストラクターの呼び出しは、コンストラクター呼び出しの逆順に行われる。コンストラクター呼び出しの順番については、基本クラスとデータメンバーの初期化を参照。

クラスのデストラクターの本体の実行を終え、本体内の自動変数を破棄する。共用メンバーを除くクラスの直接のメンバーに対して、デストラクターを呼び出す。クラスの直接の基本クラスのデストラクターを呼び出す。クラスが、最上位の派生クラスならば、virtual基本クラスのデストラクターを呼び出す。

配列の要素に対するデストラクターも、コンストラクターの逆順に呼ばれる。

デストラクターは、virtual関数やピュアvirtual関数にすることができる。基本クラスのデストラクターがvirtual関数である場合、派生クラスのデストラクターもvirtualになる。基本クラスのデストラクターがピュアvirtual関数の場合、派生クラスのオブジェクトを構築するためには、デストラクターを定義しなければならない。これらは、通常のvirtual関数と変わらない。

struct Base
{
    virtual ~Base() { } // デストラクターはvirtual関数
} ;

struct Derived : Base
{
    ~Derived() { } // デストラクターはvirtual関数
} ;

struct Abstract_base
{
    virtual ~Abstract_base() = 0 ; // デストラクターはピュアvirtual関数
} ;

デストラクターをvirtual関数にする目的は、オブジェクトに動的に構築、破棄する際に、型情報を管理しなくてもいいという点にある。

#include <iostream>

struct B1
{
    virtual ~B1() { } // virtual関数
} ;

struct D1 : B1
{
    ~D1() { std::cout << "D1 destructor" << std::endl ; }
} ;

struct B2
{
    ~B2() {} // 非virtual関数
} ;

struct D2 : B2
{
    ~D2() { std::cout << "D2 destructor" << std::endl ; } 
} ;

int main()
{
    B1 * b1_ptr = new D1 ;
    delete b1_ptr ; // 派生クラスのデストラクターが呼ばれる

    B2 * b2_ptr = new D2 ;
    delete b2_ptr ; // 派生クラスのデストラクターが呼ばれない
}

delete式に渡しているのは、基本クラスへのポインターである。そのため、非virtualなデストラクターでは、派生クラスのデストラクターが呼び出されない。デストラクターをvirtual関数にしておけば、このような場合にも、派生クラスのデストラクターが正しく呼び出される。

デストラクターが暗黙に呼ばれる条件は、以下の通りである。

• staticストレージ上のオブジェクトに対しては、プログラムの終了時に呼ばれる。
• threadストレージ上のオブジェクトに対しては、スレッドの終了時に呼ばれる。
• 自動ストレージ上のオブジェクトに対しては、オブジェクトを構築したブロックを抜けたときに呼ばれる。
• 一時オブジェクトに対しては、寿命が尽きたときに呼ばれる。
• new式で構築されたオブジェクトに対しては、delete式で破棄されるときに呼ばれる
• その他、例外として投げられたオブジェクトのキャッチに関連して呼ばれることがある

クラス型、もしくはクラスの配列型のオブジェクトが宣言された箇所で、クラスのデストラクタにアクセス出来ない場合は、エラーとなる。

class X
{
private :
    ~X() { } // privateメンバー
} ;


int main()
{
    X x ; // エラー、デストラクターにアクセスできない。
}

クラスがvirtualデストラクターを持つ場合、クラスには対応する解放関数が使える状態でなければならない。解放関数は、まずクラスのスコープ内で探され、見つからない場合は、グローバルスコープで探される。解放関数が見つからないか、曖昧か、delete定義されている場合、エラーとなる。これは、たとえプログラム中でdelete式を使わなくてもエラーとなる。

struct X
{
    virtual ~X() { } // OK、グローバルスコープのoperator deleteが発見される
} ;

struct Y
{
    virtual ~Y() { } // エラー、operator deleteはdelete定義されている。
    void operator delete( void * ptr ) = delete ;
} ;

struct B1
{
    void operator delete( void * ptr ) ;
    virtual ~B1() { }
} ;

struct B2
{
    void operator delete( void * ptr ) ;
} ;

struct Derived : B1, B2
{
// エラー、曖昧
// 暗黙のデストラクターはvirtual関数
} ;

この規格の意図は、動的な型のオブジェクトは、常にdelete式が適用できることを保証するためである。

デストラクターは、明示的に呼び出すことができる。デストラクターを明示的に呼び出すには、メンバーアクセス演算子を使い、~に続いて、クラス型に対応する型名か、decltype指定子を使う。

// このコードは、あくまで明示的なデストラクター呼び出しを説明するための例である
// 関数fを呼び出すと、Xのデストラクターは4回呼び出されることになり、挙動は未定義である
struct X { } ;

void f()
{
    X x ;
    x.~X() ; // デストラクターの明示的な呼び出し（型名）
    x.~decltype(x)() ; // デストラクタの明示的な呼び出し（decltype指定子）
    x.X::~X() ; // 修飾名付き

    // ブロックを抜ける際に、デストラクターが暗黙に呼び出される
}

たとえ、自動ストレージ上のオブジェクトに対してデストラクターを明示的に呼び出したとしても、ブロックを抜けた際に、デストラクターは暗黙的に呼び出される。デストラクターを呼び出した後のオブジェクトに対して、再びデストラクターを呼び出した場合、挙動は未定義なので、上記のコードの挙動も、未定義である。

一般に、自動ストレージ上のオブジェクトに対して明示的にデストラクターを呼び出した後、そのオブジェクトに対して、通常ならば暗黙にデストラクターが呼び出される状況になっている場合、挙動は未定義である。

デストラクターの明示的な呼び出しは、まず使う必要はない。デストラクターが暗黙に呼び出されることがない場合としては、placement newによる、ユーザー指定のストレージ上へのオブジェクトの構築が挙げられる。

#include <new>

struct X
{
    ~X() { /*実装*/ }
} ;

int main()
{
    void * ptr = ::operator new( sizeof(X) ) ; // ストレージを確保
    X * x_ptr = new(ptr) X ; // ptrの指すストレージ上にX型のオブジェクトを構築
    x_ptr->~X() ; // デストラクターの明示的な呼び出し
    ::operator delete( ptr ) ; // ストレージの解放
}

スカラー型に対しても、デストラクターを明示的に呼び出すことができる。これによって、テンプレートのコードにおいて、型が組み込み型であるかどうかを気にしなくてすむ。

int main()
{
    typedef int I ;
    I i ;
    i.~I() ; // OK、なにもしない
}

デストラクターを呼び出した後のオブジェクトに対して、再びデストラクターを呼び出した場合の挙動は未定義である。

フリーストア（Free store）

クラスに対する確保関数（operator new）と解放関数（operator delete）は、メンバー関数としてオーバーロードすることができる。確保関数と解放関数の具体的な実装方法については、動的メモリー管理を参照。

クラスのメンバー関数としての確保関数、解放関数は、staticメンバー関数である。たとえstatic指定子が明示的に使われていなくても、staticメンバー関数となる。

#include <cstddef>

struct X
{
    // 確保関数
    void * operator new ( std::size_t size )
    { return ::operator new( size ) ; }
    // 配列
    void * operator new[] ( std::size_t size )
    { return ::operator new( size ) ; }
    // placement form
    void * operator new ( std::size_t size, int, int, int )
    { return ::operator new( size ) ; }

    // 解放関数
    void operator delete( void * ptr )
    { ::operator delete ( ptr ) ; }
    // 配列
    void operator delete[] ( void * ptr )
    { ::operator delete ( ptr ) ; }

    // placement form
    void operator delete( void * ptr, int, int, int )
    { ::operator delete ( ptr ) ; }

} ;

解放関数に例外指定がない場合、noexcept(true)が指定されたものとみなされる。

初期化（Initialization）

この項目では、クラスのオブジェクトの初期化について取り扱う。特に、明示的に初期化子が指定されているオブジェクトと、クラスの基本クラスとメンバーのサブオブジェクトの初期化方法を解説する。

クラスのオブジェクトに初期化子が指定されていない場合の初期化方法は、初期化子を参照。

クラスオブジェクトの配列の要素を初期化する際には、コンストラクターは、添字の順番に呼ばれる。デストラクターはコンストラクターの逆順に呼ばれる。

#include <iostream>

class X
{
private :
    int value ; 
public :
    X( int value ) : value(value) { std::cout << value ; }
    ~X() { std::cout << value ; }
} ;

int main()
{
    X a[3] = { 1, 2, 3 } ;
}

X型の配列の要素は、a[0], a[1], a[2]の順番に構築され、a[2], a[1], a[0]の順番に破棄される。したがって、出力は、123321となる。

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 } ;
}

コンストラクター初期化子:
: メンバー初期化子, メンバー初期化子 ...opt

メンバー初期化子:
メンバー初期化識別子 ( 式リスト ) 
メンバー初期化識別子 初期化リスト

メンバー初期化識別子:
クラス名
decltype
識別子

struct Base
{ 
    Base( int ) { }
} ;

struct Derived : Base
{
    int member1 ;
    int member2 ;

    Derived()-
    // コンストラクター初期化子
        : Base( 0 ), // 基本クラス
        member1( 0 ), // メンバー
        member2{ 0 } // メンバー（初期化リスト）
    { }
} ;

struct Base { } ;

struct Derived : Base
{
    int Base ;
    Derived() :
        Base(), // Derivedの非staticデータメンバー
        Derived::Base() // 基本クラス
    { }
} ;

struct A { } ;
struct B { } ;
struct C : B, virtual A { } ;
struct D : C
{
    D() :
        C(), // OK
        A()  // OK
        // BはDの直接の基本クラスではないので使えない
    { }
} ;

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) // エラー、複数の指定
    { }

} ;

struct Base { } ;
struct Derived : Base
{
    int member ;
    Derived()
    : member(), member(), // エラー、同じメンバー名
      Base(), Base() // エラー、同じ基本クラス名
    { }          
} ;

struct S
{
    int member = 123 ;
    S() /*メンバー初期化子によるmemberの指定なし*/ { }
} ;

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() { }
} ;

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の共用メンバー
} ;

struct X
{
    int member ;
    X() { }
} ;

X x1 ; // staticストレージ上に構築されたオブジェクトは、ゼロ初期化されるので、x1.memberの値は0

int main()
{
    X x2 ; // x2.memberの値は不定
}

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
}

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が初期化される。
}

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定義されている。
}

struct V1 { } ; struct V2 { } ; struct V3 { } ;

struct B : virtual V1, virtual V2 { } ;
struct C : B, virtual V3 { } ;

C c ; // V1, V2, V3の順番で初期化される

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)で初期化される
}

struct X
{
    int m1 ;
    int m2 ;
    X() : m2(0), m1(0) { }
} ;

X x ; // m1, m2の順番で初期化される

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) { }
} ;

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 ) ) // 未定義
    { }
} ;

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() { } // エラー、間接的な自分自身へのデリゲート
} ;

生成と破棄（Construction and destruction）

クラスのオブジェクトが構築される前、破棄された後、あるいは構築や破棄の最中には、いくつか気を付けなければならないことがある。

非トリビアルコンストラクターを持つクラスのオブジェクトのコンストラクターの実行が始まる前に、非staticメンバーや基本クラスにアクセスした場合、挙動は未定義である。

struct X
{
    X() { } // 非トリビアルコンストラクター
    int member ;
} ;


int main()
{
    X * ptr = static_cast<X *>( operator new( sizeof(X) ) )  ; // 初期化されていないストレージ
    ptr->member ; // 未定義
    &ptr->member ; // 未定義、ポインターを得ることもできない
    new(ptr) X ; // 初期化
    ptr->member ; // OK
    &ptr->member ; // OK
    operator delete( ptr ) ;
}

非トリビアルデストラクターを持つクラスのオブジェクトのデストラクターの実行が終わった後に、非staticメンバーや基本クラスにアクセスした場合、挙動は未定義である。

struct X
{
    ~X() { } // 非トリビアルデストラクター
    int member ;
} ;


int main()
{
    X * ptr = static_cast<X *>( operator new( sizeof(X) ) )  ; // 初期化されていないストレージ
    new(ptr) X ; // 初期化
    ptr->~X() ; // デストラクターの実行

    ptr->member ; // 未定義
    operator delete( ptr ) ;
}

クラスへのポインターを、基本クラスへのポインターに型変換する際には、クラスとそのすべての基本クラスのコンストラクターの実行が始まっていなければならない。また、デストラクターの実行が完了していてはならない。そうでない場合の挙動は未定義である。これは、トリビアルクラスにも当てはまる。

struct X { } ;
struct Y : X { } ;

int main()
{
    Y * y_ptr = static_cast<Y *>( operator new( sizeof(Y) ) )  ; // 初期化されていないストレージ

    X * x_ptr = y_ptr ; // 未定義
    new (y_ptr) Y ; // 初期化
    x_ptr = y_ptr ; // OK
    y_ptr->~Y() ; // デストラクターの実行
    x_ptr = y_ptr ; // 未定義

    operator delete( y_ptr ) ;
}

オブジェクトの構築や破棄の途中で、メンバー関数を呼び出すことはできる。ただし、virtual関数をコンストラクターやデストラクターの中で呼び出す際には、注意が必要である。virtual関数をコンストラクターやデストラクターの中、あるいはその中から呼び出された関数内で呼び出すと、そのコンストラクターあるいはデストラクターのクラスの型にとってのファイナルオーバーライダーが用いられ、派生クラスは考慮されない。これは、基本クラスのコンストラクターの実行中には、派生クラスはまだ完全に初期化されていないからである。

struct A
{
    virtual void f() { }
    virtual void g() { }
    // A::f、A::gを呼び出す
    A() { f() ; g() ;  }
    virtual ~A() { f() ; g() ; }
} ;

struct B : A
{
    virtual void f() { }
    // B::f, A::gを呼び出す
    B() { f() ; g() ; }
    virtual ~B() { f() ; g() ; }
} ;

struct C : B
{
    virtual void g() { }
    // B::f, C::gを呼び出す
    C() { f() ; g() ; }
    virtual ~C() { f() ; g() ; }
} ;

この例で、たとえクラスCのオブジェクトを構築したとしても、基本クラスAのコンストラクターの中ではA::f, A::gが呼ばれることになる。

オブジェクトの構築や破棄の途中で、typeid演算子を使うことはできる。typeid演算子がコンストラクターやデストラクターの中、あるいはその中から呼び出された関数内で使われていて、typeid演算子のオペランドが、そのクラスの構築中のオブジェクトである場合、typeidはコンストラクターやデストラクターのクラス型情報を表すstd::type_infoオブジェクトを返す。これは、基本クラスの構築中は、まだ派生クラスは構築し終わっていないからである。

struct A
{
    A()
    {
        typeid( *this ) == typeid( A ) ; // true
    }
    virtual ~A()
    {
        typeid( *this ) == typeid( A ) ; // true
    } 
} ;

struct B : A { } ;

この例では、たとえBのオブジェクトが構築されたとしても、typeidはA型を表すstd::type_infoオブジェクトを返す。

オブジェクトの構築や破棄の途中で、dynamic_castを使うことはできる。dynamic_castがコンストラクターやデストラクターの中、あるいはその中から呼び出された関数内で使われていて、オペランドがそのクラスの構築中のオブジェクトである場合、コンストラクターやデストラクターの属するクラスが、最終的に派生された型であるとみなされる。これは、基本クラスの構築中は、まだ派生クラスは構築し終わっていないからである。

struct A
{
    A() ;
    virtual ~A() ;
} ;

struct B : A { } ;

A::A()
{
    B * ptr = dynamic_cast<B *>( this ) ; // 常にnullポインター
}

A::~A()
{
    B * ptr = dynamic_cast<B *>( this ) ; // 常にnullポインター
}

たとえ、Aから派生されたB型のオブジェクトであっても、Aのコンストラクター、デストラクターの中では、A型が最終的な派生クラスであるとみなされる。

クラスのコピーとムーブ

クラスのオブジェクトは、初期化と代入によって、コピーもしくはムーブされる。コピーやムーブを行うためのコンストラクターと代入演算子を、それぞれ特別に、コピーコンストラクター、ムーブコンストラクター、コピー代入演算子、ムーブ代入演算子と呼ぶ。

コピーコンストラクター（copy constructor）とは、あるクラスXにおいて、非テンプレートなコンストラクターで、一つ目の仮引数の型が、X &、const X &、volatile X &、const volatile X &のいずれかであり、二つ目以降の仮引数は存在しないか、すべてデフォルト実引数があるものをいう。

struct X
{
    // コピーコンストラクター
    X( X & ) ;
    X( X const & ) ;
    X( X volatile & ) ;
    X( X const volatile & ) ; 
    X( X const &, int x = 0, int y = 0 ) ; // 二つ目以降の仮引数にデフォルト実引数がある

    // コピーコンストラクターではない
    X( ) ;
    X( int ) ;
    template < typename T >
    X( T ) ; // テンプレートコンストラクターはコピーコンストラクターではない
    X( X const &, short ) ; // 二つ目以降の仮引数にデフォルト実引数がない
} ;

ムーブコンストラクター（move constructor）とは、あるクラスXにおいて、非テンプレートなコンストラクターで、一つ目の仮引数の型が、X &&、const X &&、volatile X &&、const volatile X &&のいずれかであり、二つ目以降の仮引数は存在しないか、すべてデフォルト実引数があるものをいう。

struct X
{
    X( X && ) ;
    X( X const && ) ;
    X( X volatile && ) ;
    X( X const volatile && ) ;
    X( X const &&, int x = 0 ) ;
} ;

クラスXのコンストラクターの一つ目の仮引数の型がXで、二つ目以降の仮引数が存在しないか、すべてデフォルト実引数が指定されている場合は、エラーとなる。

struct X
{
    X( X ) ; // エラー
} ;

また、テンプレートコンストラクターのインスタンス化の結果が、このようなシグネチャになる場合、そのテンプレートはインスタンス化されない。

struct X
{
    template < typename T >
    X( T ) { } // X<X>というインスタンス化は起こらない。
} ;

int main()
{
    X a( 0 ) ; // テンプレートコンストラクターが使われる。
    X b( a ) ; // 暗黙のコピーコンストラクターが使われる
}

あるクラスにおいて、コピーコンストラクターが明示的に宣言されていない場合、コピーコンストラクターは暗黙的に宣言される。もし、クラスにユーザー定義のムーブコンストラクター、ムーブ代入演算子、コピー代入演算子、デストラクターが存在する場合、コピーコンストラクターは暗黙的にdelete定義される。そうでない場合は、default定義される。

struct A
{
    // コピーコンストラクターは暗黙的にdefault定義される
    // A( A const & ) = default ;
} ;

struct B
{
    B( B && ) ; // ユーザー定義ムーブコンストラクター
    B & operator = ( B && ) ; // ユーザー定義ムーブ代入演算子
    B & operator = ( B & ) ; // ユーザー定義コピー代入演算子
    ~B() ; // ユーザー定義デストラクター

    // コピーコンストラクターは暗黙的にdelete定義される
    // B( B const & ) = delete ;
} ;

C++98/03では、暗黙のコピーコンストラクターはユーザー定義のコピー代入演算子、ユーザー定義のムーブ代入演算子、ユーザー定義デストラクターがある場合でも、暗黙的に宣言された。C++11では、この挙動は非推奨になった。将来的に取り除かれる予定だ。

struct S
{
    ~S() { }
} ;

int main()
{
    S s1 ;
    // OK: C++98, C++03まで
    // 非推奨: C++11以降
    S s2( s1 ) ;

}

理由は、そのようなユーザー定義の特別なメンバー関数がある場合は、大抵、暗黙のデフォルトのコピーコンストラクターの挙動は、容易にプログラミング上の誤りを引き起こすためである。

ユーザー定義のコピー代入演算子、ユーザー定義のムーブ代入演算子、ユーザー定義デストラクターがある場合の暗黙のコピーコンストラクターの宣言は、非推奨であり、将来の規格では取り除かれる。そのため、このような非推奨に依存したコードを書いてはならない。

クラスXの暗黙のコピーコンストラクターのシグネチャは、通常、

X::X( const X & )

となる。ただし、直接の基本クラスやvirtual基本クラス、非staticデータメンバーがconst修飾されていない仮引数のコンストラクターを持つ場合、

X::X( X & )

となる。

struct A
{
    A() = default ;
    A( A const & ) { }
} ;

struct B : A
{
// 暗黙のコピーコンストラクターのシグネチャ
// B( B const & ) = default ;
} ;

struct C
{
    C() = default ;
    C( C & ) { }
} ;

struct D : C
{
// 暗黙のコピーコンストラクターのシグネチャ
// D( D & ) = default ;
} ;

あるクラスにおいて、ムーブコンストラクターが明示的に宣言されていない場合、ムーブコンストラクターは暗黙的に宣言される。もし、あるクラスがユーザー定義の、コピーコンストラクター、コピー代入演算子、ムーブ代入演算子、デストラクターを持たず、またムーブコンストラクターがdelete定義されていない場合、ムーブコンストラクターはdefault定義される。

ユーザー定義のムーブ代入演算子が存在する場合、ムーブコンストラクターは暗黙的にdefault定義されない。これは、デフォルトのムーブコンストラクターの挙動と、ユーザー定義のムーブ代入演算子の挙動が異なる可能性があるため、安全のためにdefault定義されないのである。

struct X
{
    // ムーブコンストラクターはdefault定義されない

    // ユーザー定義のムーブ代入演算子
    X & operator = ( X && obj )
    {
        // ユーザー定義のムーブを実装
    }
} ;

そのため、自前実装のムーブ構築とムーブ代入を行いたい場合、ムーブコンストラクターとムーブ代入演算子を両方ユーザー定義する必要がある。

ムーブコンストラクターが、暗黙にも明示的にも宣言されていない場合、ムーブコンストラクターを呼び出す式は、代わりにコピーコンストラクターを呼び出す。

struct X
{
    X() = default ;
    // ユーザー定義のコピーコンストラクター
    X( X const & ) { }
    // ムーブコンストラクターは宣言されない
} ;


int main()
{
    X a ;
    // コピーコンストラクターを呼び出す
    X b( static_cast< X && >( a ) ) ;
}

クラスXの暗黙のムーブコンストラクターのシグネチャは、以下の通りである。

X::X( X && )

あるクラスが以下の条件を満たした時、対応するコピー/ムーブコンストラクターはdelete定義される。つまり、以下の条件でコピーができない場合はコピーコンストラクターが、ムーブができないときはムーブコンストラクターが、それぞれ個別にdelete定義される。

• クラスがunionのようなクラスで、共用メンバーがそれぞれ非トリビアルなコピー/ムーブ・コンストラクターを持つ場合

  struct NonTrivial
  {
      NonTrivial( NonTrivial const & ) { }
      NonTrivial( NonTrivial && ) { }
  } ;
  
  struct X
  { 
      X() { }
      union { NonTrivial n ; } ;
      // コピーコンストラクターは、nが非トリビアルなコピーコンストラクターを持つためにdelete定義される
      // ムーブコンストラクターは、nが非トリビアルなムーブコンストラクターを持つためにdelete定義される。
  } ;
  

• 非staticデータメンバーが、オーバーロード解決の結果、コピー/ムーブできない場合

  オーバーロード解決の結果というのは、複数の候補があって曖昧である場合、選ばれた最適関数がdeleted定義されている場合、アクセス指定によりクラスのデフォルトコンストラクターからは利用できない場合だ。

  // コピーできない
  struct uncopyable
  {
      uncopyable( uncopyable const & ) = delete ;
  } ;
  
  // コピーコンストラクターがdelete定義される
  struct S
  {
      uncopyable member ;
  } ;
  

  アクセス指定によりクラスのデフォルトコンストラクターからは利用できない場合の例

  struct private_copy
  {
  private :
      private_copy( private_copy const & ) = delete ;
  } ;
  
  // コピーコンストラクターがdelete定義される
  struct S
  {
      // memberのコピーコンストラクターは
      // クラスSのデフォルトコンストラクターからアクセスできない
      private_copy member ;
  } ;
  

• 直接、あるいはvirtualな基本クラスが、オーバーロード解決の結果、コピー/ムーブできない場合

• 直接、あるいはvirtualな基本クラス、もしくは非staticデータメンバーの、デストラクターが、delete定義であるか、あるいはアクセス指定により、デフォルトコンストラクターからアクセスできない場合

  // デストラクターがprivateメンバーのクラス
  struct M
  {
  private :
      ~M() { }
  } ;
  
  // コピーとムーブコンストラクターがdelete定義される
  struct S
  {
      M m ;
  } ;
  

• 非staticデータメンバーがrvalueリファレンス型である場合、コピーコンストラクターがdelete定義される。

  // コピーコンストラクターがdelete定義される
  struct S
  {
      static int data ;
  
      // rvalueリファレンス型の非staticデータメンバー
      int && rref ;
      S() : rref( static_cast< int && >(data) ) { }
  } ;
  
  int S::data ;
  
  int main()
  {
      S s1 ;
      S s2 = s1 ; // エラー、コピーコンストラクターがdelete定義されている
  }
  

デフォルト定義されたムーブコンストラクターがdeleted定義されている場合、オーバーロード解決では無視される。

コピー/ムーブコンストラクターがトリビアル(trivial)となるには、ユーザー定義されず、仮引数リストが暗黙に宣言された場合の仮引数リストと同じで、以下の条件をすべて満たす必要がある。

• クラスはvirtual関数とvirtual基本クラスを持たないこと
• volatile修飾された非staticデータメンバーを持たないこと
• 直接の基本クラスのサブオブジェクトをコピー/ムーブするのに使われるコンストラクターがトリビアルであること
• クラス型か、クラスの配列型の非staticデータメンバーをコピー/ムーブするのに使われるコンストラクターがトリビアルであること

これらの条件をすべて満たさない限り、コピー/ムーブコンストラクターは、非トリビアル(non-trivial)である。

コピー/ムーブコンストラクターが、default化されていて、定義もdeleted定義もされていない場合、ODRの文脈で使われるか、最初の宣言で明示的にdefault化された場合、暗黙に定義される(implicitly defined)。もし、暗黙に定義されたコンストラクターがconstexprコンストラクターの制約を満たすのならば、暗黙に定義されたコンストラクターは、constexprコンストラクターになる。

コピー/ムーブコンストラクターが暗黙に定義されるためには、直接の基本クラス、virtual基本クラス、非staticデータメンバーの、ユーザー提供されていないコピー/ムーブコンストラクターは、すべて暗黙に定義されていなければならない。ユーザー提供されている場合は、暗黙に定義されていなくてもよい。

struct Base
{
    // コピーコンストラクターは暗黙に定義されていない
    Base( const Base & ) = delete ;
} ;

struct Derived : Base
{
// コピーコンストラクターは暗黙にdefault化される
} ;

void f()
{
    Derived d1 ;
    Derived d2 = d1 ; // エラー、コピーコンストラクターは暗黙に定義されていない

}

unionではないクラスの暗黙に定義されたコピー/ムーブコンストラクターは、、基本クラスとメンバーに対し、メンバーごとのコピー/ムーブを行う。初期化の順番は、ユーザー定義されるコンストラクターの場合と同じである。

union型の暗黙に定義されたコピー/ムーブコンストラクターは、union型のオブジェクトの内部表現をコピーする。

ユーザー宣言されたクラスXのコピー/ムーブ代入演算子、X::operator =は、クラスXの非static、非テンプレートのメンバー関数で、仮引数を一つだけ取り、その型はX, X &, const X &, volatile X & const volatile X &でなければならない。

struct X
{
    X & operator = ( X & ) ;
    X & operator = ( X const & ) ;
    X & operator = ( X volatile & ) ;
    X & operator = ( X const volatile & ) ;
} ;

ユーザー宣言されるコピー/ムーブ代入演算子の戻り値の型は制限されていない。

struct X
{
    // OK
    void operator = ( X const & ) { }
} ;

void f()
{
    X x1 ;
    X x2 ;
    x1 = x2 ; // OK、結果の型はvoid
}

コンストラクターと同じく、代入演算子でも、代入演算子のテンプレートは、コピー/ムーブ代入演算子ではない。ただし、コンストラクターと同じように、テンプレートの特殊化がコピー/ムーブ代入演算子と同じ仮引数になった場合は、オーバーロード解決の候補となり、非テンプレートのコピー/ムーブ代入演算子より優先して選択されることもある。このため、代入演算子のテンプレートは、コピー風/ムーブ風の代入演算子と非公式に呼ばれている。

struct X
{
    X() { }

    X & operator = ( X const & ) ; // #1
    template < typename T >
    X & operator = ( T & ) ; // #2
} ;

void f()
{
    X x1 ;
    X x2 ;
    x1 = x2 ; // #2が呼ばれる
}

もし、クラス定義の中でコピー代入演算子が明示的に宣言されていない場合、コピー代入演算子は暗黙的に宣言される。

struct X
{
// コピー代入演算子が暗黙的に宣言される
} ;

もし、クラス定義で、ムーブコンストラクター、ムーブ代入演算子、コピーコンストラクター、デストラクターがユーザー宣言されていた場合、暗黙に宣言されたコピー代入演算子は、delete定義される。

struct A
{
// コピー代入演算子はdelete定義される
    A( A && ) ; 
} ;

struct B
{
// コピー代入演算子はdelete定義される
    B & operator = ( B && ) ;
} ;

C++11では、コピーコンストラクター、デストラクターがユーザー宣言されていた場合、コピー代入演算子はdefault化される。この挙動は非推奨であり、将来的には取り除かれる。このような非推奨の機能に頼ったコードを書いてはならない。

// このようなコードを書いてはならない

struct X
{
// C++11では、コピー代入演算子は暗黙にdefault化される
// この機能は非推奨であり、使ってはならない

    X( X const & ) ;
    ~X() ;
} ;

暗黙に宣言される、クラスXのコピー代入演算子は、以下の条件、

• クラスXの直接の基本クラスBが、仮引数の型としてconst B &, const volatile B &, Bのいずれかであるコピー代入演算子を持つ

  struct B1 { B1 & operator = ( const B & ) ; } ;
  struct B2 { B2 & operator = ( const volatile B & ) ; } ;
  struct B3 { B3 & operator = ( B ) ; } ;
  
  struct X : B1, B2, B3 { } ;
  

• Xの非staticデータメンバー、もしくは配列がすべて、型をMとおくと、仮引数の型がconst M &, const volatile M &, Mであるコピー代入演算子を持つ

をすべて満たす場合、

X & X::operator = ( const X & )

の形を取る。

上の条件を満たさない場合、暗黙に宣言されるクラスXのコピー代入演算子の形は、

X & X::operator = ( X & )

となる。

クラスXのユーザー宣言されるムーブ代入演算子、X::operator =は、非static、非テンプレートのメンバー関数で、仮引数を一つだけ取り、その型は、X &&, const X &&, volatile X &&, const volatile X &&でなければならない。

あるクラスXの定義でムーブ代入演算子が明示的に宣言されていない場合は、以下の条件をすべて満たした時、暗黙的にムーブ代入演算子が宣言される。

• クラスXはユーザー宣言されたコピーコンストラクターを持たない
• クラスXはユーザー宣言されたムーブコンストラクターを持たない
• クラスXはユーザー宣言されたコピー代入演算子を持たない
• クラスXはユーザー宣言されたデストラクターを持たない
• ムーブ代入演算子は暗黙にdelete定義されていない

暗黙に宣言されたクラスXのムーブ代入演算子は、以下の形を取る。

X & X::operator = ( X && )

暗黙に宣言されたクラスXのコピー/ムーブ代入演算子は、X &型の戻り値を返す。戻り値として返されるのは代入演算子が呼ばれたクラスのオブジェクトへのリファレンスである。暗黙に宣言されたコピー/ムーブ代入演算子は、クラスのinline publicメンバーとなる。

デフォルト化されたクラスXのコピー/ムーブ代入演算子は、クラスXが以下のいずれかのメンバーを持つ時、それぞれ対応するコピー/ムーブ代入演算子が、delete定義される。

• クラスXがunion風クラスで、その共用メンバーに、非トリビアルなコピー/ムーブ代入演算子があるとき

  union風クラスとは、unionか無名unionを含むクラスである。

  // 非トリビアルなコピー代入演算子を持つ型
  struct S
  {
      S & operator = ( S const & ) { }
  } ;
  
  union U1 { S s ; } ;
  struct U2
  {
      union { S s ; } ;
  } ;
  
  int main()
  {
      U1 a ;
      U1 b ;
      a = b ; // エラー、コピー代入演算子がdelete定義されている
  
      U2 c ;
      U2 d ;
      c = d ; // エラー、コピー代入演算子がdelete定義されている
  }
  

• const修飾された非クラスの、型か配列型を、非staticデータメンバーとして持つ場合

  struct S
  {
      const int member ;
      const int array[10] ;
  } ;
  

• リファレンス型の非staticデータメンバーを持つ場合

• オーバーロード解決の結果、コピー/ムーブ代入できないクラス型を非staticデータメンバーとして持つ場合。

  コピー/ムーブ代入できないというのは、オーバーロード解決の結果が曖昧であるか、最適候補がdeleted定義であるか、アクセス指定により、クラスXのデフォルト代入演算子からアクセスできない場合をいう。以下同じ

• 直接、あるいはvirtualな基本クラスが、オーバーロード解決の結果、コピー/ムーブ代入できない場合。

デフォルト化されたムーブ代入演算子がdelete定義された場合、オーバーロード解決では無視される。

コピー/ムーブ代入演算子は、明示的に宣言されなかった場合、必ず暗黙的に宣言される。宣言の方法は様々で、delete定義になることもあるが、宣言されることはされる。これは、クラスの基本クラスの代入演算子は、必ず隠されるということだ。using宣言を使って基本クラスの代入演算子をクラススコープに導入しても、そのクラスで宣言された代入演算子が優先されるため、やはり隠される。

あるクラスXのコピー/ムーブ代入演算子がトリビアルであるためには、ユーザー提供されず、仮引数リストが、暗黙に宣言された場合の仮引数リストと同じで、さらに以下の条件をすべて満たさなければならない。

• クラスXはvirtual関数を持たず、virtual基本クラスも持たない
• クラスXはvolatile修飾された型の非staticデータメンバーを持たない
• 直接の基本クラスのサブオブジェクトで使われるコピー/ムーブの代入演算子がトリビアル
• クラスXのクラス型とクラスの配列型の非staticデータメンバーの、コピー/ムーブに使われる代入演算子がトリビアル

この条件を満たさない場合、コピー/ムーブ代入演算子は非トリビアルとなる。

あるクラスXの、default化されているが、delete定義されていないコピー/ムーブコンストラクターは、ODRの文脈で使われた場合、もしくは、最初の宣言で明示的にdefault化された場合、暗黙に定義される。

暗黙に定義されたコピー/ムーブ代入演算子は、以下の条件をすべて満たした場合、constexpr関数になる。

• クラスXはリテラル型
• 直接の基本クラスのサブオブジェクトで、コピー/ムーブのために使われる代入演算子が、constexpr関数
• クラスXの、クラス型、もしくはクラスの配列型の非staticデータメンバーの、コピー/ムーブのために使われる代入演算子が、constexpr関数

あるクラスのデフォルト化されたコピー/ムーブ代入演算子が暗黙に定義されるには、クラスの直接の基本クラスと、非staticデータメンバーのコピー/ムーブ代入演算子のうち、ユーザー提供されていないものは、すべて暗黙に定義されていなければならない。

union以外のクラスで、暗黙に定義されたコピー/ムーブ代入演算子は、クラスのサブオブジェクトに対してメンバーごとのコピー/ムーブを行う。クラスの直接の基本クラスがまず代入される。代入の順序は、基本クラス指定のリストで宣言された順番である。

struct A { } ;
struct B { } ;

// 代入されるときは、A, Bの順番
struct C : A, B { } ;

// 代入されるときは、B, Aの順番
struct D : B, A { } ;

その次に、クラスの非staticデータメンバーが、クラス定義で宣言された順番で代入される。サブオブジェクトがクラス型の場合はoperator =を呼び出し、基本型の場合は組み込みの代入演算子を使い。配列型の場合は、要素ごとに代入される。

暗黙に定義されたコピー代入演算子が、複数回派生されているvirtual基本クラスのサブオブジェクトのコピー代入演算子を、派生された回数だけ呼び出すかどうかは、未規定である。

struct V
{
    V & operator = ( V const & ) ; // #1
} ;
struct A : virtual V { } ;
struct B : virtual V { } ;
struct C : A, B { } ; // 暗黙のコピー代入演算子がdefault定義される

int main()
{
    C c1 ;
    C c2 ;
    c2 = c1 ; // #1が一度呼ばれるか、二度呼ばれるかは、未規定
}

クラスCには、VはA,B二つのクラスのvirtual基本クラスになっているため、クラスCには、Vのサブオブジェクトはひとつしかない。この場合、Vのコピー代入演算子が、一回呼ばれるとは限らない。ただし二回呼ばれるとも限らない。規格上、この場合に、暗黙に定義されたコピー代入演算子は、Vのコピー代入演算子を呼び出す回数は、一回でも二回でも良い。

なお、ムーブ代入演算子は、virtual基本クラスがある場合、暗黙にdelete定義されるので、この未規定はない。

もちろん、暗黙の定義ではなく、明示的に定義した場合は、明示的に書いただけの回数呼び出す。

unionの暗黙に定義されたコピー代入演算子は、オブジェクトの内部表現をコピーする。

コピー/ムーブのコンストラクターか代入演算子がODRの文脈で使われていて、アクセス指定のためにアクセスできない場合、エラーとなる。

条件次第で、C++の実装はオブジェクトのコピー/ムーブ構築を省略することができる。たとえ、そのオブジェクトのコンストラクターやデストラクターが、副作用を持っていたとしても、遠慮なく省略される。これをコピー省略(copy elision)という。規格上の用語は「コピー省略」だが、コピーだけではなく、ムーブも省略される可能性がある。

コピー省略は、以下の場合に許されている。

• クラスを返す関数のreturn文のオペランドの式が、関数とcatch句の仮引数を除く非volatileの自動オブジェクトの名前であり、関数の戻り値の型と自動オブジェクトの型が、ともにCV非修飾の型である場合、関数内の自動オブジェクトのコピー/ムーブが省略され、関数の戻り値のオブジェクトとして直接に構築することが許されている

  struct S
  {
      S() { }
      S( S const & ) { }
      ~S() { }
  } ;
  
  S f()
  {
      S s ;
      return s ; // コピー省略が許されている
  }
  

• throw式のオペランドが、関数とcatch句の仮引数を除く非volatileの自動オブジェクトの名前であり、その自動オブジェクトのスコープが、最も内側のブロックの外に出ない場合、例外オブジェクトに対するコピー/ムーブが省略され、例外オブジェクト上に直接構築することが許されている。

  struct S
  {
      S() { }
      S( S const & ) { } 
      ~S() { }
  } ;
  
  
  int main()
  {
      try
      {
          S s ; // 最も内側のブロックスコープの外に出ない
          throw s ; // コピー省略が許されている
      } catch ( S & s ) { }
  }
  

• リファレンスで束縛されていないクラスの一時オブジェクトが、同じCV非修飾の型に、コピー/ムーブされた場合、コピー/ムーブは省略され、コピー/ムーブ先のオブジェクトに、一時オブジェクトを直接構築することが許されている。

  struct S
  {
      S() { }
      S( S const & ) { }
      ~S() { }
  } ;
  
  S f()
  {
      return S() ; // コピー省略が許されている
  }
  
  int main()
  {
      S s = f() ; // コピー省略が許されている
  }
  

• 例外ハンドラーの例外宣言が、CV修飾子以外は同じ型のオブジェクトを、例外オブジェクトとして宣言している場合、コンストラクターとデストラクター呼び出し以外にプログラムの意味が変わらなければ、コピー/ムーブは省略され、例外宣言の仮引数は、例外オブジェクトを参照することが許されている。

  struct S
  {
      S() { }
      S( S const & ) { }
      ~S() { }
  } ;
  
  int main()
  {
      try
      {
          throw S() ;
      }
      // コピー省略が許されている
      catch( S s ) { }
  }
  

  「コンストラクターとデストラクター呼び出し以外にプログラムの意味が変わらない」というのは、たとえば例外オブジェクトを変更するような場合だ。

  catch( S s )
  {
      s = S() ; // 例外オブジェクトを変更
  }
  

  例外宣言のリファレンスではない仮引数の指し示すオブジェクトに変更を加えても、元の例外オブジェクトを変更しないと規定されているので、この場合は、コピー省略はできない。

コピー省略の条件は、組み合わさった場合でも、コピー省略されることが許されている。

コピー省略できる条件がそろい、コピーされるオブジェクトがlvalueの場合、オーバーロード解決が二回行われることがある。一回目のオーバーロード解決は、オブジェクトをrvalueとして、コピーするコンストラクターを探す。一回目のオーバーロード解決が失敗するか、選択されたコンストラクターの第一引数がrvalueリファレンスではない場合、オブジェクトをlvalueとして、二回目のオーバーロード解決が行われる。

一回目のオーバーロード解決で、選択されたコンストラクターの第一引数がrvalueリファレンスではない場合というのは、たとえばconst修飾されたlvalueリファレンスが該当する。

この二回のオーバーロード解決は、たとえコピー省略をしないとしても、必ず行われる。この規定の目的は、コピー省略が行われなかったならば呼び出されるコンストラクターの、アクセス指定を調べるためである。

コンストラクター継承（Inheriting constructors）

using宣言を使って派生クラスから基本クラスのコンストラクターを指定することで、基本クラスのコンストラクターを明示的に継承できる。これにより、機械的な手書きのコードを省くことができる。

class Base
{
private :
    int member ;
public :
    Base( int value ) : member(value) { }
} ;

class Derived : Base
{
public :
    // Base::Base(int)を継承
    using Base::Base ;
} ;

int main()
{
    Derived d(0) ; // 継承コンストラクターを使う
}

using宣言は通常通り、アクセス指定の影響を受けることに注意すること。派生クラスによって継承された基本クラスのコンストラクターは、同じ仮引数をとり、引数をそのままメンバー初期化子で基本クラスに渡し、関数本体は空であるコードを手書きした場合と同じように動く。

struct Base { Base(int, double) { } } ;
struct Derived : Base
{
    // Baseクラスのコンストラクターの継承
    using Base::Base ;
    // 以下のコードを手書きした場合と同等
    // Derived( int p1, double p2 )
    // : Base( p1, p2 )
    // { }
} ;

このような手書きのコンストラクターを、実際に使うとエラーとなる場合、継承コンストラクターの使用もエラーとなる。

派生クラスで同じシグネチャーのコンストラクターをユーザー定義した場合、そのコンストラクターの継承は起こらない。

struct Base
{
    Base( int ) { }
    Base( double ) { }
} ;
struct Derived : Base
{
    using Base::Base ;

    Derived( int value ) : Base(value)
    {
        // 処理
    }
}

この場合、Base::Base(double)は継承されるが、Base::Base(int)は継承されない。クラスDerivedでユーザー定義されたコンストラクターが使用される。

継承コンストラクターの詳細はすこし難しい。まず、継承される基本クラスのコンストラクターが、継承コンストラクターの候補(candidate set of inherited constructors)として列挙される。この際、コンストラクターにデフォルト実引数がある場合は、デフォルト実引数を省略したシグネチャーの関数も追加される。たとえば、以下のようなクラスの場合、

struct A
{
    A( int i ) { }
} ;

struct B
{
    B( int p1 = 1, int p2 = 2 ) { }
} ;

クラスAの継承コンストラクターの候補は、以下の通り。

A( int )
A( A const & )
A( A && )

クラスBの継承コンストラクターの候補は、以下の通り。

B( ) // デフォルト実引数の省略形
B( int = 1 ) // デフォルト実引数の省略形
B( int = 1, int = 2 )
B( B const & )
B( B && )

さて、この継承コンストラクターの候補から、引数を取らないコンストラクター（デフォルトコンストラクター）、引数をひとつだけ取るコピー/ムーブコンストラクターを除くコンストラクターが継承コンストラクターとなる。これらのコンストラクターは、派生クラス側で暗黙に宣言されるものだからだ。ただし、派生クラスで同じシグネチャーのコンストラクターがユーザー定義されている場合は、継承されない。

いくつか例を示す。

struct Base
{
    Base( int ) { }
} ;

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

この場合、クラスDerivedのコンストラクターは、以下のようになる。

Derived( ) // 継承コンストラクターではない。使うとエラーになる
Derived( int ) // クラスBから継承されたコンストラクター
Derived( Derived const & ) // 継承コンストラクターではない
Derived( Derived && ) // 継承コンストラクターではない

デフォルトコンストラクターやコピー/ムーブコンストラクターは継承されないので、通常通りの挙動になる。この場合、クラスBaseのデフォルトコンストラクターは暗黙に宣言されていないし、ユーザー定義もされていないため、使うとエラーになる。

struct A
{
    A( int ) { }
} ;

struct B
{
    B( int ) { }
} ;

struct C : A, B
{
    using A::A ;
    using B::B ;
// エラー、宣言の重複
} ;

struct D : A, B
{
    using A::A ;
    using B::B ;
    D( int x ) : A(x), B(x) { } // OK、ユーザー定義を優先
}

クラスCでは、C(int)を重複して宣言してしまうので、エラーとなる。クラスDでは、ユーザー定義があるために、コンストラクターの継承は起こらない。もっとも、この場合、using宣言を使ってコンストラクターを継承する意味がない。