Overload resolution

関数呼び出しをコンパイルするためには、コンパイラはまず name lookup を実行する必要があります。関数の場合、これは argument-dependent lookup を含む場合があり、関数テンプレートの場合には template argument deduction が続くことがあります。

名前が複数のエンティティを参照する場合、それは オーバーロード されていると言われ、コンパイラはどのオーバーロードを呼び出すかを決定しなければなりません。簡単に言えば、パラメータが引数に最も一致するオーバーロードが呼び出されます。

詳細には、オーバーロード解決は以下の手順で進行します：

1. 候補関数 の集合を構築する。
2. 集合を 実現可能関数 のみに絞り込む。
3. 単一の 最良の実現可能関数 を決定するために集合を分析する（これには 暗黙の変換シーケンスのランキング が含まれる場合がある）。

void f(long);
void f(float);
f(0L); // f(long)を呼び出す
f(0);  // エラー: オーバーロードの曖昧性

関数呼び出し以外にも、オーバーロードされた関数名はいくつかの追加の文脈で現れる可能性があり、異なる規則が適用されます。詳細は オーバーロードされた関数のアドレス を参照してください。

関数がオーバーロード解決によって選択できない場合、その関数は使用できません（例えば、失敗した templated entity を持つ constraint の場合など）。

候補関数

オーバーロード解決が開始される前に、名前探索とテンプレート引数推論によって選択された関数は、 候補関数 の集合を形成するために結合されます。詳細は、オーバーロード解決が行われるコンテキストによって異なります。

名前付き関数の呼び出し

E が 関数呼び出し式 E ( args ) において、オーバーロードされた関数および/または関数テンプレートの集合（ただし呼び出し可能オブジェクトを除く）を指す場合、以下の規則が適用されます：

• 式 E が PA - > B または A. B の形式を持つ場合（ここで A はクラス型 cv T を持つ）、 B は T のメンバ関数として ルックアップ されます。このルックアップで見つかった関数宣言が候補関数となります。オーバーロード解決のための引数リストは、型 cv T の暗黙のオブジェクト引数を持ちます。
• 式 E が 基本式 である場合、名前は関数呼び出しの通常のルール（ ADL を含む可能性あり）に従って ルックアップ されます。このルックアップで見つかった関数宣言は（ルックアップの仕組みにより）以下のいずれかとなります：

• すべての非メンバ関数（この場合、オーバーロード解決のための引数リストは関数呼び出し式で使用される引数リストと完全に一致する）
• あるクラス T のすべてのメンバ関数。この場合、 this がスコープ内にあり、 T または T の派生クラスへのポインタである場合、 * this が暗黙のオブジェクト引数として使用される。それ以外の場合（ this がスコープ内にないか、 T を指していない場合）、型 T の仮想オブジェクトが暗黙のオブジェクト引数として使用され、オーバーロード解決の結果非静的メンバ関数が選択された場合、プログラムは不適格となる。

クラスオブジェクトへの呼び出し

E が 関数呼び出し式 E ( args ) においてクラス型 cv T を持つ場合、

• T の関数呼び出し演算子は、式 ( E ) . operator ( ) のコンテキストにおける名前 operator ( ) の通常の ルックアップ によって取得され、見つかったすべての宣言が候補関数のセットに追加されます。
• T または T の基底クラス内の（隠されていない）非 explicit ユーザー定義変換関数 のうち、CV修飾子が T のCV修飾子と同じかそれ以上であり、かつ変換関数が以下に変換するものについて：

• ポインタから関数への変換
• 参照からポインタから関数への変換
• 参照から関数への変換

その後、一意の名前を持つ 代理呼び出し関数 が候補関数の集合に追加されます。この関数の最初のパラメータは変換の結果であり、残りのパラメータは変換結果が受け入れるパラメータリスト、戻り値の型は変換結果の戻り値の型となります。この代理関数が後続のオーバーロード解決によって選択された場合、ユーザー定義変換関数が呼び出され、その後変換結果が呼び出されます。

いずれの場合でも、オーバーロード解決のための引数リストは、関数呼び出し式の引数リストの前に暗黙のオブジェクト引数 E が付加されたものとなります（サロゲート関数とのマッチング時には、ユーザー定義変換によって暗黙のオブジェクト引数が自動的にサロゲート関数の最初の引数に変換されます）。

int f1(int);
int f2(float);
struct A
{
    using fp1 = int(*)(int);
    operator fp1() { return f1; } // 関数ポインタへの変換関数
    using fp2 = int(*)(float);
    operator fp2() { return f2; } // 関数ポインタへの変換関数
} a;
int i = a(1); // 変換関数から返されたポインタ経由でf1を呼び出す

オーバーロードされた演算子の呼び出し

式内の演算子の引数の少なくとも1つがクラス型または列挙型を持つ場合、 組み込み演算子 と ユーザー定義演算子オーバーロード の両方がオーバーロード解決に参加し、候補関数のセットは以下のように選択されます：

単項演算子 @ で引数の型が T1 （CV修飾子を除去後）、または二項演算子 @ で左オペランドの型が T1 、右オペランドの型が T2 （CV修飾子を除去後）の場合、以下の候補関数群が準備されます：

オーバーロード解決のために提出される候補関数の集合は、上記の集合の和集合です。オーバーロード解決のための引数リストは、演算子のオペランドで構成されます。ただし operator-> の場合、第2オペランドは関数呼び出しの引数ではありません（ メンバーアクセス演算子 を参照）。

struct A
{
    operator int();              // ユーザー定義変換
};
A operator+(const A&, const A&); // 非メンバーのユーザー定義演算子
void m()
{
    A a, b;
    a + b; // メンバー候補: なし
           // 非メンバー候補: operator+(a, b)
           // 組み込み候補: int(a) + int(b)
           // オーバーロード解決は operator+(a, b) を選択
}

オーバーロード解決が組み込み候補を選択した場合、クラス型のオペランドからの ユーザー定義変換シーケンス は第二の標準変換シーケンスを持つことが許可されません：ユーザー定義変換関数は直接期待されるオペランド型を提供しなければなりません：

struct Y { operator int*(); }; // Y は int* に変換可能
int *a = Y() + 100.0;          // エラー: ポインタと double の間には operator+ が存在しない

operator, 演算子、 operator & 演算子、および operator - > 演算子について、候補関数のセットに有効な関数（下記参照）が存在しない場合、その演算子は組み込み演算子として再解釈されます。

コンストラクタによる初期化

クラス型のオブジェクトが direct-initialized または default-initialized （ copy-list-initialization におけるdefault-initializationを含む） (C++11以降) される場合、候補関数は初期化されるクラスの全てのコンストラクタです。引数リストは初期化子の式リストとなります。

それ以外の場合、候補関数はすべて初期化されるクラスの converting constructors です。引数リストは初期化子の式となります。

変換によるコピー初期化

クラス型のオブジェクトの copy-initialization において、型 cv S の初期化子式を初期化対象オブジェクトの型 cv T に変換するためにユーザー定義変換の呼び出しが必要な場合、以下の関数が候補関数となります：

• T のすべての 変換コンストラクタ
• S とその基底クラスから T 、または T から派生したクラス、あるいはそれらへの参照への explicit でない変換関数（隠蔽されていないもの）。このコピー初期化が cv T の直接初期化シーケンスの一部である場合（ cv T への参照を取るコンストラクタの最初の引数にバインドされる参照を初期化する場合）、明示的変換関数も考慮されます。

いずれにせよ、オーバーロード解決のための引数リストは、初期化式である単一の引数で構成され、これはコンストラクタの第一引数、または変換関数の暗黙のオブジェクト引数と比較されます。

変換による非クラス初期化

非クラス型 cv1 T のオブジェクトの初期化が、クラス型 cv S の初期化子式からの変換のために ユーザー定義変換関数 を必要とする場合、以下の関数が候補となります：

• S とその基底クラスの非明示的ユーザー定義変換関数（隠蔽されていないもの）で、型 T または 標準変換シーケンス によって T に変換可能な型（またはそのような型への参照）を生成するもの。候補関数の選択においては、返される型のcv修飾子は無視されます。
• これが 直接初期化 の場合、 S とその基底クラスの明示的ユーザー定義変換関数（隠蔽されていないもの）で、型 T または 修飾変換 によって T に変換可能な型（またはそのような型への参照）を生成するものも考慮されます。

いずれにせよ、オーバーロード解決のための引数リストは、初期化式である単一の引数で構成され、これは変換関数の暗黙のオブジェクト引数と比較されます。

変換による参照初期化

参照初期化 において、 cv1 T への参照がクラス型 cv2 S からの初期化子式の変換結果である左辺値または右辺値に束縛される場合、以下の関数が候補集合として選択されます：

• S とその基底クラス（隠されていない限り）の非明示的なユーザー定義変換関数が、型への変換を行う場合

• (左辺値に変換する場合) cv2 T2 への左辺値参照
• (右辺値または関数型の左辺値に変換する場合) cv2 T2 または cv2 T2 への右辺値参照

ここで cv2 T2 は 参照互換 である cv1 T と。

• 直接初期化の場合、明示的なユーザー定義変換関数も考慮されます。ただし、 T2 が T と同じ型であるか、あるいは修飾変換によって型 T に変換可能な場合に限ります。

いずれにせよ、オーバーロード解決のための引数リストは、初期化式である単一の引数で構成され、これは変換関数の暗黙のオブジェクト引数と比較されます。

リスト初期化

非集成クラス型 T のオブジェクトが list-initialized される場合、2段階のオーバーロード解決が行われます。

• フェーズ1では、候補関数は T の全ての初期化子リストコンストラクタであり、オーバーロード解決のための引数リストは単一の初期化子リスト引数で構成されます
• フェーズ1でオーバーロード解決が失敗した場合、フェーズ2に移行します。このフェーズでは候補関数は T の全てのコンストラクタであり、オーバーロード解決のための引数リストは初期化子リストの個々の要素で構成されます

初期化子リストが空であり、かつ T がデフォルトコンストラクタを持つ場合、フェーズ1はスキップされます。

コピーリスト初期化では、フェーズ2が明示的コンストラクタを選択した場合、初期化は不適格となる（他のすべてのコピー初期化では明示的コンストラクタは考慮すらされないのとは対照的である）。

関数テンプレート候補に関する追加規則

名前探索が関数テンプレートを見つけた場合、 template argument deduction および明示的なテンプレート引数のチェックが実行され、このケースで使用可能なテンプレート引数値（存在する場合）が決定されます：

• 両方が成功した場合、テンプレート引数は対応する関数テンプレート特殊化の宣言を合成するために使用され、それらは候補セットに追加されます。このような特殊化は、以下のタイブレイカー規則で特に指定されている場合を除き、非テンプレート関数と同様に扱われます。
• 引数推定が失敗した場合、または合成された関数テンプレート特殊化が不適格となる場合、そのような関数は候補セットに追加されません（ SFINAE を参照）。

名前が1つ以上の関数テンプレートを参照し、かつ一連のオーバーロードされた非テンプレート関数も参照する場合、それらの関数とテンプレートから生成された特殊化はすべて候補となります。

詳細については、 function template overloading を参照してください。

コンストラクタ候補に関する追加規則

メンバー関数候補に関する追加規則

候補関数のいずれかが メンバ関数 （静的または非静的）であり、 明示的なオブジェクトパラメータ を持たない場合 （C++23以降） 、ただしコンストラクタではない場合、その関数は呼び出し対象のオブジェクトを表す追加のパラメータ（ 暗黙のオブジェクトパラメータ ）を持っているかのように扱われ、このパラメータは実際のパラメータの最初の前に現れます。

同様に、メンバー関数が呼び出されているオブジェクトは、 implied object argument として引数リストの先頭に追加されます。

クラス X のメンバ関数について、暗黙のオブジェクトパラメータの型は、 member functions で説明されているように、メンバ関数のCV修飾と参照修飾の影響を受けます。

ユーザー定義変換関数は、 implicit object parameter の型を決定する目的において、 implied object argument のメンバーと見なされます。

using宣言によって派生クラスに導入されたメンバ関数は、 暗黙の オブジェクトパラメータの型を定義する目的において、派生クラスのメンバと見なされます 。

残りのオーバーロード解決において、 implied object argument は他の引数と区別できませんが、以下の特別な規則が implicit object parameter に適用されます：

struct B { void f(int); };
struct A { operator B&(); };
A a;
a.B::f(1); // エラー: ユーザー定義変換は暗黙オブジェクトパラメータに適用できない
           // to the implicit object parameter
static_cast<B&>(a).f(1); // OK

有効な関数

候補関数の集合が上記のように構築された後、オーバーロード解決の次のステップは、引数とパラメータを調べて、それを 実行可能関数 の集合に絞り込むことです。

有効な関数のセットに含まれるためには、候補関数は以下を満たさなければなりません：

ユーザー定義変換（変換コンストラクタとユーザー定義変換関数の両方）は、複数のユーザー定義変換を適用可能にする暗黙変換シーケンスに参加することが禁止されています。具体的には、変換の対象がコンストラクタの第一引数、またはユーザー定義変換関数の暗黙オブジェクトパラメータである場合、そのコンストラクタ/ユーザー定義変換が候補となる場合には考慮されません。

• ユーザー定義変換によるクラスのコピー初期化 ,
• 変換関数による非クラス型の初期化 ,
• 直接参照バインドのための変換関数による初期化 ,
• クラスの コピー初期化 の第二段階（直接初期化）におけるコンストラクタによる初期化 ,

struct A { A(int); };
struct B { B(A); };
B b{{0}}; // Bのリスト初期化
// 候補: B(const B&), B(B&&), B(A)
// {0} -> B&& 不適格: B(A)の呼び出しが必要となる
// {0} -> const B&: 不適格: 右辺値へのバインドが必要、B(A)の呼び出しが必要
// {0} -> A 適格。A(int)を呼び出す: Aへのユーザー定義変換は禁止されていない

最適な実行可能関数

有効な関数の各ペア F1 と F2 について、 i ^番目の 引数から i ^番目の パラメータへの暗黙変換シーケンスは、どちらが優れているかを判断するためにランク付けされます（ただし、最初の引数である静的メンバ関数の 暗黙オブジェクト引数 はランキングに影響しません）

F1 は、以下の条件を満たす場合に F2 よりも優れた関数であると判定されます： F1 のすべての引数に対する暗黙変換が F2 のすべての引数に対する暗黙変換よりも 劣っていない こと、かつ

template<typename T = int>
struct S
{
    constexpr void f(); // #1
    constexpr void f(this S&) requires true; // #2
};
void test()
{
    S<> s;
    s.f(); // calls #2
}

struct A
{
    A(int = 0);
};
struct B: A
{
    using A::A;
    B();
};
B b; // OK, B::B()

template<class T>
struct A
{
    using value_type = T;
    A(value_type);  // #1
    A(const A&);    // #2
    A(T, T, int);   // #3
    template<class U>
    A(int, T, U);   // #4
};                  // #5 is A(A), the copy deduction candidate
A x(1, 2, 3); // uses #3, generated from a non-template constructor
template<class T>
A(T) -> A<T>;       // #6, less specialized than #5
A a (42); // uses #6 to deduce A<int> and #1 to initialize
A b = a;  // uses #5 to deduce A<int> and #2 to initialize
template<class T>
A(A<T>) -> A<A<T>>; // #7, as specialized as #5
A b2 = a; // uses #7 to deduce A<A<int>> and #1 to initialize

これらの一対比較は、すべての有効な関数に対して適用されます。正確に1つの有効な関数が他のすべての関数より優れている場合、オーバーロード解決は成功し、この関数が呼び出されます。それ以外の場合、コンパイルは失敗します。

void Fcn(const int*, short); // オーバーロード #1
void Fcn(int*, int);         // オーバーロード #2
int i;
short s = 0;
void f() 
{
    Fcn(&i, 1L);  // 第1引数: &i → int* は &i → const int* より優れている
                  // 第2引数: 1L → short と 1L → int は同等
                  // Fcn(int*, int) を呼び出す
    Fcn(&i, 'c'); // 第1引数: &i → int* は &i → const int* より優れている
                  // 第2引数: 'c' → int は 'c' → short より優れている
                  // Fcn(int*, int) を呼び出す
    Fcn(&i, s);   // 第1引数: &i → int* は &i → const int* より優れている
                  // 第2引数: s → short は s → int より優れている
                  // 勝者が決まらないため、コンパイルエラー
}

最適な実行可能関数が複数の宣言が見つかった関数に解決され、かつこれらの宣言のいずれか2つが異なるスコープに存在し、その関数を実行可能にしたデフォルト引数を指定している場合、プログラムは不適格です。

namespace A
{
    extern "C" void f(int = 5);
}
namespace B
{
    extern "C" void f(int = 5);
}
using A::f;
using B::f;
void use()
{
    f(3); // OK、デフォルト引数は有効性の判定には使用されなかった
    f();  // エラー: デフォルト引数が2回見つかりました
}

暗黙の変換シーケンスのランキング

オーバーロード解決で考慮される引数-パラメータの暗黙変換シーケンスは、 暗黙変換 が コピー初期化 （非参照パラメータの場合）で使用されるものに対応します。ただし、暗黙オブジェクトパラメータまたは代入演算子の左辺への変換を考慮する際には、一時オブジェクトを作成する変換は考慮されません。 パラメータが静的メンバ関数の暗黙オブジェクトパラメータである場合、暗黙変換シーケンスは他の標準変換シーケンスよりも優劣のない標準変換シーケンスです。 （C++23以降）

各 標準変換シーケンスの型 には、次の3つのランクのいずれかが割り当てられます：

標準変換シーケンスのランクは、それが保持する標準変換のランクの中で最も低いものとなる（最大で 3つの変換 が含まれる可能性がある）

参照パラメータの引数式への直接バインディングは、同一性または派生から基底への変換のいずれかです：

struct Base {};
struct Derived : Base {} d;
int f(Base&);    // オーバーロード #1
int f(Derived&); // オーバーロード #2
int i = f(d); // d -> Derived& は Exact Match ランク
              // d -> Base& は Conversion ランク
              // f(Derived&) を呼び出す

変換シーケンスのランキングは型と値カテゴリのみを対象として動作するため、 ビットフィールド はランキングの目的で参照引数に束縛されることがありますが、その関数が選択された場合、プログラムは不適格となります。

int i;
int f1();
int g(const int&);  // オーバーロード #1
int g(const int&&); // オーバーロード #2
int j = g(i);    // 左辺値 int -> const int& が唯一有効な変換
int k = g(f1()); // 右辺値 int -> const int&& は右辺値 int -> const int& より優先される

int f(void(&)());  // overload #1
int f(void(&&)()); // overload #2
void g();
int i1 = f(g); // calls #1

int f(const int*);
int f(int*);
int i;
int j = f(&i); // &i -> int* は &i -> const int* より優先され、f(int*) を呼び出す

int f(const int &); // オーバーロード #1
int f(int &);       // オーバーロード #2 (両方とも参照)
int g(const int &); // オーバーロード #1
int g(int);         // オーバーロード #2
int i;
int j = f(i); // 左辺値 i -> int& は左辺値 int -> const int& よりも優先される
              // f(int&) を呼び出す
int k = g(i); // 左辺値 i -> const int& は完全一致に分類される
              // 左辺値 i -> 右辺値 int は完全一致に分類される
              // オーバーロードの解決が曖昧: コンパイルエラー

struct Z {};
struct A
{
    operator Z&();
    operator const Z&();  // overload #1
};
struct B
{
    operator Z();
    operator const Z&&(); // overload #2
};
const Z& r1 = A();        // OK, uses #1
const Z&& r2 = B();       // OK, uses #2

struct A
{
    operator short(); // user-defined conversion function
} a;
int f(int);   // overload #1
int f(float); // overload #2
int i = f(a); // A -> short, followed by short -> int (rank Promotion)
              // A -> short, followed by short -> float (rank Conversion)
              // calls f(int)

void f1(int);                                 // #1
void f1(std::initializer_list<long>);         // #2
void g1() { f1({42}); }                       // chooses #2
void f2(std::pair<const char*, const char*>); // #3
void f2(std::initializer_list<std::string>);  // #4
void g2() { f2({"foo", "bar"}); }             // chooses #4

void f(int    (&&)[] ); // オーバーロード #1
void f(double (&&)[] ); // オーバーロード #2
void f(int    (&&)[2]); // オーバーロード #3
f({1});        // #1: 変換により#2より優れ、境界により#3より優れる
f({1.0});      // #2: double -> double は double -> int より優れる
f({1.0, 2.0}); // #2: double -> double は double -> int より優れる
f({1, 2});     // #3: -> int[2] は -> int[] より優れ、
               //     かつ int -> int は int -> double より優れる

2つの変換シーケンスが同じランクを持つために区別できない場合、以下の追加ルールが適用されます：

enum num : char { one = '0' };
std::cout << num::one; // '0', not 48

int f(std::float32_t);
int f(std::float64_t);
int f(long long);
float x;
std::float16_t y;
int i = f(x); // float と std::float32_t の変換ランクが等しい実装では
              // f(std::float32_t) を呼び出す
int j = f(y); // エラー: 曖昧、等しい変換ランクがない

曖昧な変換シーケンスはユーザー定義変換シーケンスとしてランク付けされます。なぜなら、引数に対する複数の変換シーケンスが存在し得るのは、それらが異なるユーザー定義変換を含む場合のみだからです：

class B;
class A { A (B&);};         // 変換コンストラクタ
class B { operator A (); }; // ユーザー定義変換関数
class C { C (B&); };        // 変換コンストラクタ
void f(A) {} // オーバーロード #1
void f(C) {} // オーバーロード #2
B b;
f(b); // B -> A 変換（コンストラクタ経由）または B -> A 変換（関数経由）（曖昧な変換）
      // b -> C 変換（コンストラクタ経由）（ユーザー定義変換）
      // オーバーロード #1 とオーバーロード #2 の変換は区別できないため、コンパイルは失敗する

リスト初期化における暗黙変換シーケンス

list initialization において、引数は braced-init-list であり、これは式ではないため、オーバーロード解決の目的でパラメータ型への暗黙変換シーケンスは以下の特別な規則によって決定されます：

• パラメータの型が何らかの集約型 X であり、初期化子リストが同じクラスまたは派生クラス（CV修飾されている可能性あり）のちょうど1つの要素で構成されている場合、暗黙変換シーケンスは要素をパラメータ型に変換するために必要なものです。
• それ以外の場合、パラメータの型が文字配列への参照であり、初期化子リストが適切な型の文字列リテラルである単一の要素を持つ場合、暗黙変換シーケンスは恒等変換です。
• それ以外の場合、パラメータの型が std:: initializer_list < X > であり、初期化子リストのすべての要素から X への非縮小暗黙変換が存在する場合、オーバーロード解決のための暗黙変換シーケンスは必要な最悪の変換です。波括弧初期化リストが空の場合、変換シーケンスは恒等変換です。

struct A
{
    A(std::initializer_list<double>);          // #1
    A(std::initializer_list<complex<double>>); // #2
    A(std::initializer_list<std::string>);     // #3
};
A a{1.0, 2.0};     // #1を選択 (rvalue double → double: identity conversion)
void g(A);
g({"foo", "bar"}); // #3を選択 (lvalue const char[4] → std::string: user-defined conversion)

• それ以外の場合、パラメータ型が「N個のTの配列」（これは配列への参照でのみ発生する）の場合、初期化子リストはN個以下の要素を持たなければならず、リストの各要素（またはリストがNより短い場合は空の中括弧のペア {} ）を T に変換するために必要な最悪の暗黙変換が使用されます。

typedef int IA[3];
void h(const IA&);
void g(int (&&)[]);
h({1, 2, 3}); // int→int 同一性変換
g({1, 2, 3}); // C++20以降は上記と同じ

• それ以外の場合、パラメータ型が非集約クラス型 X である場合、オーバーロード解決は引数初期化子リストから初期化するためにXのコンストラクタCを選択します

• Cが初期化子リストコンストラクタでなく、初期化子リストが単一の要素（修飾の有無を問わずX型）を持つ場合、暗黙変換シーケンスはExact Matchランクを持つ。初期化子リストが単一の要素（修飾の有無を問わずXから派生した型）を持つ場合、暗黙変換シーケンスはConversionランクを持つ。（アグリゲートとの違いに注意：アグリゲートは アグリゲート初期化 を考慮する前に単一要素の初期化子リストから直接初期化するが、非アグリゲートは他のコンストラクタよりも前にinitializer_listコンストラクタを考慮する）
• それ以外の場合、暗黙変換シーケンスはユーザー定義変換シーケンスであり、第二標準変換シーケンスは恒等変換である。

複数のコンストラクタが利用可能だが、いずれも他より優れていない場合、暗黙の変換シーケンスはあいまいな変換シーケンスとなります。

struct A { A(std::initializer_list<int>); };
void f(A);
struct B { B(int, double); };
void g(B);
g({'a', 'b'});    // g(B(int, double))を呼び出す、ユーザー定義変換
// g({1.0, 1,0}); // エラー: double→intは縮小変換、リスト初期化では許可されない
void f(B);
// f({'a', 'b'}); // f(A)とf(B)の両方がユーザー定義変換

• それ以外の場合、パラメータの型が初期化子リストから aggregate initialization によって初期化可能な集成体である場合、暗黙変換シーケンスはユーザー定義変換シーケンスであり、第二標準変換シーケンスは恒等変換となります。

struct A { int m1; double m2; };
void f(A);
f({'a', 'b'}); // f(A(int, double))を呼び出す、ユーザー定義変換

• それ以外の場合、パラメータが参照である場合は、参照初期化ルールが適用されます

struct A { int m1; double m2; };
void f(const A&);
f({'a', 'b'}); // 一時オブジェクトが作成され、f(A(int, double))が呼び出される。ユーザー定義変換

• それ以外の場合、パラメータ型がクラスでなく初期化子リストが1つの要素を持つ場合、暗黙変換シーケンスは要素をパラメータ型に変換するために必要なものとなります
• それ以外の場合、パラメータ型がクラス型でなく、初期化子リストに要素がない場合、暗黙変換シーケンスは恒等変換となります

struct A { int x, y; };
struct B { int y, x; };
void f(A a, int); // #1
void f(B b, ...); // #2
void g(A a);      // #3
void g(B b);      // #4
void h() 
{
    f({.x = 1, .y = 2}, 0); // OK; calls #1
    f({.y = 2, .x = 1}, 0); // error: selects #1, initialization of a fails
                            // due to non-matching member order
    g({.x = 1, .y = 2});    // error: ambiguous between #3 and #4
}

不具合報告

以下の動作変更の欠陥報告書は、以前に公開されたC++規格に対して遡及的に適用されました。

1. ↑ 組み込み代入演算子の最初のパラメータの型は「volatile修飾された可能性のある T への左辺値参照」です。この型の参照は一時オブジェクトに束縛できません。

参考文献

関連項目

• 名前検索
• 実引数依存の名前検索
• テンプレート実引数推論
• SFINAE