Разрешение перегрузки

Чтобы скомпилировать вызов функции, компилятор сначала должен выполнить поиск имени, который для функций может включать поиск с учетом аргументов, а для шаблонов функций может сопровождаться выведением аргументов шаблона.

Если имя относится более чем к одной сущности, оно считается перегруженным, и компилятор должен определить, какую перегрузку вызвать. Проще говоря, вызывается перегрузка, параметры которой наиболее точно соответствуют аргументам.

Подробно процесс разрешения перегрузки состоит из следующих шагов:

1. Формирование набора функций-кандидатов.
2. Сокращение набора до подходящих функций.
3. Анализ набора для определения единственной наилучшей подходящей функции (это может включать ранжирование последовательностей неявного преобразования).

void f(long);
void f(float);

f(0L); // calls f(long)
f(0);  // error: ambiguous overload

Помимо вызовов функций, перегруженные имена функций могут встречаться в нескольких дополнительных контекстах, где действуют другие правила: см. Адрес перегруженной функции.

Если функцию невозможно выбрать с помощью разрешения перегрузки, ее нельзя использовать (например, если это шаблонная сущность с неудовлетворенным ограничением).

Функции-кандидаты

До начала разрешения перегрузки функции, выбранные поиском имени и выведением аргументов шаблона, объединяются в набор функций-кандидатов. Точные детали зависят от контекста, в котором выполняется разрешение перегрузки.

Вызов функции по имени

Если E в выражении вызова функции E(args) обозначает набор перегруженных функций и/или шаблонов функций (но не вызываемых объектов), применяются следующие правила:

• Если выражение E имеет вид PA->B или A.B (где A имеет тип класса cv T), то

• для B выполняется поиск как для функции-члена T. Функции-кандидаты — это объявления функций, найденные при таком поиске.

Список аргументов для целей разрешения перегрузки содержит подразумеваемый аргумент объекта типа cv T.

• Если выражение E является первичным выражением, то

• имя ищется согласно обычным правилам для вызовов функций (что может включать поиск с учетом аргументов). В силу особенностей поиска найденные объявления функций представляют собой либо:
• только функции, не являющиеся членами (в этом случае список аргументов для целей разрешения перегрузки в точности совпадает со списком аргументов в выражении вызова функции), либо
• только функции-члены некоторого класса T. В этом случае, если this находится в области видимости и является указателем на T или на производный от T класс, *this используется как подразумеваемый аргумент объекта. В противном случае (если this не находится в области видимости или не указывает на T) в качестве подразумеваемого аргумента объекта используется фиктивный объект типа T, и если впоследствии разрешение перегрузки выберет нестатическую функцию-член, программа будет некорректной.

Вызов объекта класса

Если E в выражении вызова функции E(args) имеет тип класса cv T, то

• операторы вызова функции для T находятся обычным поиском имени operator() в контексте выражения (E).operator(), и каждое найденное объявление добавляется в набор функций-кандидатов.
• Для каждой не-explicit пользовательской функции преобразования в T или в базовом классе T (если она не скрыта), квалификаторы cv которой совпадают с квалификаторами cv T или являются более строгими, и которая преобразует в:

• указатель на функцию
• ссылку на указатель на функцию
• ссылку на функцию

в набор функций-кандидатов добавляется функция суррогатного вызова с уникальным именем. Ее первый параметр — результат преобразования, остальные параметры — список параметров, принимаемых результатом преобразования, а тип возвращаемого значения — тип возвращаемого значения результата преобразования. Если при последующем разрешении перегрузки выбирается эта суррогатная функция, сначала вызывается пользовательская функция преобразования, а затем вызывается результат преобразования.

В любом случае список аргументов для целей разрешения перегрузки — это список аргументов выражения вызова функции, перед которым стоит подразумеваемый аргумент объекта E (при сопоставлении с суррогатной функцией пользовательское преобразование автоматически преобразует подразумеваемый аргумент объекта в первый аргумент суррогатной функции).

int f1(int);
int f2(float);

struct A
{
    using fp1 = int(*)(int);
    operator fp1() { return f1; } // conversion function to pointer to function
    using fp2 = int(*)(float);
    operator fp2() { return f2; } // conversion function to pointer to function
} a;

int i = a(1); // calls f1 via pointer returned from conversion function

Вызов перегруженного оператора

Если хотя бы один из аргументов оператора в выражении имеет тип класса или перечисления, в разрешении перегрузки участвуют как встроенные операторы, так и пользовательские перегрузки операторов. Набор функций-кандидатов выбирается следующим образом:

Для унарного оператора @, аргумент которого имеет тип T1 (после удаления квалификаторов cv), или бинарного оператора @, левый операнд которого имеет тип T1, а правый — тип T2 (после удаления квалификаторов cv), формируются следующие наборы функций-кандидатов:

Набор функций-кандидатов, передаваемый на разрешение перегрузки, является объединением перечисленных выше наборов. Список аргументов для целей разрешения перегрузки состоит из операндов оператора, за исключением operator->, где второй операнд не является аргументом вызова функции (см. оператор доступа к членам).

struct A
{
    operator int();              // user-defined conversion
};
A operator+(const A&, const A&); // non-member user-defined operator

void m()
{
    A a, b;
    a + b; // member-candidates: none
           // non-member candidates: operator+(a, b)
           // built-in candidates: int(a) + int(b)
           // overload resolution chooses operator+(a, b)
}

Если разрешение перегрузки выбирает встроенного кандидата, пользовательская последовательность преобразования операнда типа класса не может содержать вторую стандартную последовательность преобразования: пользовательская функция преобразования должна непосредственно возвращать ожидаемый тип операнда:

struct Y { operator int*(); }; // Y is convertible to int*
int *a = Y() + 100.0;          // error: no operator+ between pointer and double

Для operator,, унарного operator& и operator->, если в наборе функций-кандидатов нет подходящих функций (см. ниже), оператор интерпретируется как встроенный.

Инициализация конструктором

Когда объект типа класса подвергается прямой инициализации или инициализации по умолчанию (включая инициализацию по умолчанию в контексте копирующей инициализации списком)(начиная с C++11), функциями-кандидатами являются все конструкторы инициализируемого класса. Список аргументов — это список выражений инициализатора.

В противном случае функциями-кандидатами являются все конвертирующие конструкторы инициализируемого класса. Список аргументов — это выражение инициализатора.

Копирующая инициализация преобразованием

Если для копирующей инициализации объекта типа класса требуется пользовательское преобразование выражения-инициализатора типа cv S в тип cv T инициализируемого объекта, функциями-кандидатами являются:

• все конвертирующие конструкторы T
• не-explicit функции преобразования из S и его базовых классов (если они не скрыты) в T, класс, производный от T, или ссылку на такой тип. Если эта копирующая инициализация является частью последовательности прямой инициализации cv T (инициализация ссылки, которая будет привязана к первому параметру конструктора, принимающего ссылку на cv T), рассматриваются также явные функции преобразования.

В любом случае список аргументов для целей разрешения перегрузки состоит из одного аргумента — выражения-инициализатора, которое будет сопоставлено с первым аргументом конструктора или с неявным аргументом объекта функции преобразования.

Инициализация типа, не являющегося классом, преобразованием

Когда для инициализации объекта типа, не являющегося классом, cv1 T требуется пользовательская функция преобразования из выражения-инициализатора типа класса cv S, кандидатами являются следующие функции:

• неявные пользовательские функции преобразования S и его базовых классов (если они не скрыты), возвращающие тип T или тип, преобразуемый в T с помощью стандартной последовательности преобразования, либо ссылку на такой тип. Квалификаторы cv возвращаемого типа игнорируются при выборе функций-кандидатов.
• если это прямая инициализация, также рассматриваются явные пользовательские функции преобразования S и его базовых классов (если они не скрыты), возвращающие тип T или тип, преобразуемый в T с помощью квалификационного преобразования, либо ссылку на такой тип.

В любом случае список аргументов для целей разрешения перегрузки состоит из одного аргумента — выражения-инициализатора, которое будет сопоставлено с неявным аргументом объекта функции преобразования.

Инициализация ссылки преобразованием

При инициализации ссылки, когда ссылка на cv1 T привязывается к результату преобразования — lvalue или rvalue, полученному из выражения-инициализатора типа класса cv2 S, в набор кандидатов включаются следующие функции:

• Неявные пользовательские функции преобразования S и его базовых классов (если они не скрыты) в тип

• (при преобразовании в lvalue) ссылку lvalue на cv2 T2
• (при преобразовании в rvalue или lvalue функционального типа) cv2 T2 или ссылку rvalue на cv2 T2

где cv2 T2 является совместимым по ссылке с cv1 T.

• При прямой инициализации также рассматриваются явные пользовательские функции преобразования, если T2 имеет тот же тип, что и T, или может быть преобразован в тип T с помощью квалификационного преобразования.

В любом случае список аргументов для целей разрешения перегрузки состоит из одного аргумента — выражения-инициализатора, которое будет сопоставлено с неявным аргументом объекта функции преобразования.

Инициализация списком

Когда объект класса T, не являющегося агрегатом, инициализируется списком, разрешение перегрузки выполняется в два этапа.

• на этапе 1 функциями-кандидатами являются все конструкторы со списком инициализаторов класса T, а список аргументов для целей разрешения перегрузки состоит из одного аргумента — списка инициализаторов;
• если на этапе 1 разрешение перегрузки завершается неудачей, начинается этап 2. Функциями-кандидатами на этом этапе являются все конструкторы T, а список аргументов для целей разрешения перегрузки состоит из отдельных элементов списка инициализаторов.

Если список инициализаторов пуст и у T есть конструктор по умолчанию, этап 1 пропускается.

При копирующей инициализации списком, если на этапе 2 выбран явный конструктор, инициализация некорректна (в отличие от всех остальных случаев копирующей инициализации, где явные конструкторы даже не рассматриваются).

Дополнительные правила для кандидатов — шаблонов функций

Если поиск имени нашел шаблон функции, выполняются выведение аргументов шаблона и проверка любых явно заданных аргументов шаблона, чтобы определить значения аргументов шаблона (если таковые имеются), которые можно использовать в данном случае:

• Если оба действия завершаются успешно, аргументы шаблона используются для формирования объявлений соответствующих специализаций шаблона функции, которые добавляются в набор кандидатов. Такие специализации рассматриваются так же, как обычные функции, за исключением случаев, отдельно указанных в приведенных ниже правилах выбора при равенстве.
• Если выведение аргументов завершается неудачей или сформированная специализация шаблона функции некорректна, такая функция не добавляется в набор кандидатов (см. SFINAE).

Если имя относится к одному или нескольким шаблонам функций, а также к набору перегруженных обычных функций, кандидатами становятся все эти функции и специализации, созданные на основе шаблонов.

Подробнее см. перегрузку шаблонов функций.

Дополнительные правила для кандидатов-конструкторов

Дополнительные правила для кандидатов — функций-членов

Если какая-либо функция-кандидат является функцией-членом (статической или нестатической), не имеющей явного параметра объекта(начиная с C++23), но не является конструктором, она рассматривается так, как если бы у нее был дополнительный параметр (неявный параметр объекта), представляющий объект, для которого она вызывается, и стоящий перед первым фактическим параметром.

Аналогичным образом объект, для которого вызывается функция-член, добавляется в начало списка аргументов как подразумеваемый аргумент объекта.

Для функций-членов класса X на тип неявного параметра объекта влияют cv-квалификаторы и ref-квалификаторы функции-члена, как описано в разделе функции-члены.

Для определения типа неявного параметра объекта пользовательские функции преобразования считаются членами подразумеваемого аргумента объекта.

Функции-члены, введенные в производный класс с помощью объявления using, считаются членами производного класса при определении типа неявного параметра объекта.

В остальной части разрешения перегрузки подразумеваемый аргумент объекта не отличается от других аргументов, однако к неявному параметру объекта применяются следующие особые правила:

struct B { void f(int); };
struct A { operator B&(); };

A a;
a.B::f(1); // Error: user-defined conversions cannot be applied
           // to the implicit object parameter
static_cast<B&>(a).f(1); // OK

Подходящие функции

Для набора функций-кандидатов, сформированного, как описано выше, следующим шагом разрешения перегрузки является анализ аргументов и параметров, чтобы сократить набор до подходящих функций.

Чтобы попасть в набор подходящих функций, функция-кандидат должна удовлетворять следующим условиям:

Пользовательским преобразованиям (как конвертирующим конструкторам, так и пользовательским функциям преобразования) запрещено участвовать в последовательности неявного преобразования, если это позволило бы применить более одного пользовательского преобразования. В частности, они не рассматриваются, если целью преобразования является первый параметр конструктора или неявный параметр объекта пользовательской функции преобразования, а этот конструктор/пользовательская функция преобразования является кандидатом для

• копирующей инициализации класса пользовательским преобразованием,
• инициализации типа, не являющегося классом, функцией преобразования,
• инициализации функцией преобразования при прямой привязке ссылки,
• инициализации конструктором на втором шаге (прямой инициализации) копирующей инициализации класса,

struct A { A(int); };
struct B { B(A); };

B b{{0}}; // list-initialization of B

// candidates: B(const B&), B(B&&), B(A)
// {0} -> B&& not viable: would have to call B(A)
// {0} -> const B&: not viable: would have to bind to rvalue, would have to call B(A)
// {0} -> A viable. Calls A(int): user-defined conversion to A is not banned

Наилучшая допустимая функция

Для каждой пары допустимых функций 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

Эти попарные сравнения применяются ко всем допустимым функциям. Если ровно одна допустимая функция лучше всех остальных, разрешение перегрузки завершается успешно и вызывается эта функция. В противном случае компиляция завершается с ошибкой.

void Fcn(const int*, short); // overload #1
void Fcn(int*, int);         // overload #2

int i;
short s = 0;

void f() 
{
    Fcn(&i, 1L);  // 1st argument: &i -> int* is better than &i -> const int*
                  // 2nd argument: 1L -> short and 1L -> int are equivalent
                  // calls Fcn(int*, int)
    
    Fcn(&i, 'c'); // 1st argument: &i -> int* is better than &i -> const int*
                  // 2nd argument: 'c' -> int is better than 'c' -> short
                  // calls Fcn(int*, int)
    
    Fcn(&i, s);   // 1st argument: &i -> int* is better than &i -> const int*
                  // 2nd argument: s -> short is better than s -> int
                  // no winner, compilation error
}

Если наилучшая допустимая функция разрешается в функцию, для которой найдено несколько объявлений, и любые два из этих объявлений находятся в разных областях видимости и задают аргумент по умолчанию, благодаря которому функция стала допустимой, программа некорректна.

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, default argument was not used for viability
    f();  // error: found default argument twice
}

Ранжирование последовательностей неявных преобразований

Рассматриваемые при разрешении перегрузки последовательности неявных преобразований аргумент-параметр соответствуют неявным преобразованиям, используемым при копирующей инициализации (для параметров, не являющихся ссылками), за исключением того, что при преобразовании к неявному параметру объекта или к левой части оператора присваивания преобразования, создающие временные объекты, не рассматриваются. Если параметр является неявным параметром объекта статической функции-члена, последовательность неявных преобразований является стандартной последовательностью преобразований, которая не лучше и не хуже любой другой стандартной последовательности преобразований.(начиная с C++23)

Каждому типу стандартной последовательности преобразований присваивается один из трех рангов:

Ранг стандартной последовательности преобразований равен наихудшему из рангов входящих в нее стандартных преобразований (их может быть до трех)

Прямая привязка параметра-ссылки к выражению-аргументу является либо тождественным преобразованием, либо преобразованием производного класса в базовый:

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

int f(Base&);    // overload #1
int f(Derived&); // overload #2

int i = f(d); // d -> Derived& has rank Exact Match
              // d -> Base& has rank Conversion
              // calls f(Derived&)

Поскольку ранжирование последовательностей преобразований оперирует только типами и категориями значений, битовое поле может быть привязано к аргументу-ссылке для целей ранжирования, но если эта функция будет выбрана, программа окажется некорректной.

int i;
int f1();

int g(const int&);  // overload #1
int g(const int&&); // overload #2

int j = g(i);    // lvalue int -> const int& is the only valid conversion
int k = g(f1()); // rvalue int -> const int&& better than rvalue 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* is better than &i -> const int*, calls f(int*)

int f(const int &); // overload #1
int f(int &);       // overload #2 (both references)

int g(const int &); // overload #1
int g(int);         // overload #2

int i;
int j = f(i); // lvalue i -> int& is better than lvalue int -> const int&
              // calls f(int&)
int k = g(i); // lvalue i -> const int& ranks Exact Match
              // lvalue i -> rvalue int ranks Exact Match
              // ambiguous overload: compilation error

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    (&&)[] ); // overload #1
void f(double (&&)[] ); // overload #2
void f(int    (&&)[2]); // overload #3

f({1});        // #1: Better than #2 due to conversion, better than #3 due to bounds
f({1.0});      // #2: double -> double is better than double -> int
f({1.0, 2.0}); // #2: double -> double is better than double -> int
f({1, 2});     // #3: -> int[2] is better than -> int[], 
               //     and int -> int is better than int -> double

Если две последовательности преобразований неразличимы, поскольку имеют одинаковый ранг, применяются следующие дополнительные правила:

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); // calls f(std::float32_t) on implementations where
              // float and std::float32_t have equal conversion ranks
int j = f(y); // error: ambiguous, no equal conversion rank

Неоднозначные последовательности преобразований ранжируются как пользовательские последовательности преобразований, поскольку несколько последовательностей преобразований для аргумента могут существовать только в том случае, если они включают разные пользовательские преобразования:

class B;

class A { A (B&);};         // converting constructor
class B { operator A (); }; // user-defined conversion function
class C { C (B&); };        // converting constructor

void f(A) {} // overload #1
void f(C) {} // overload #2

B b;
f(b); // B -> A via ctor or B -> A via function (ambiguous conversion)
      // b -> C via ctor (user-defined conversion)
      // the conversions for overload #1 and for overload #2
      // are indistinguishable; compilation fails

Последовательность неявных преобразований при инициализации списком

При инициализации списком аргументом является список-инициализатор в фигурных скобках, который не является выражением, поэтому последовательность неявных преобразований к типу параметра для целей разрешения перегрузки определяется следующими специальными правилами:

• Если тип параметра является некоторым агрегатом X, а список инициализаторов состоит ровно из одного элемента того же или производного класса (возможно, cv-квалифицированного), последовательность неявных преобразований — это последовательность, необходимая для преобразования элемента к типу параметра.
• В противном случае, если тип параметра является ссылкой на массив символов, а список инициализаторов содержит один элемент — строковый литерал подходящего типа, последовательность неявных преобразований является тождественным преобразованием.
• В противном случае, если тип параметра — 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};     // selects #1 (rvalue double -> double: identity conv)

void g(A);
g({"foo", "bar"}); // selects #3 (lvalue const char[4] -> std::string: user-def conv)

• В противном случае, если тип параметра — «массив из N элементов типа T» (это возможно только для ссылок на массивы), список инициализаторов должен содержать не более N элементов; используется наихудшее из неявных преобразований, необходимых для преобразования каждого элемента списка (или пустой пары фигурных скобок {}, если список короче N) в T.

typedef int IA[3];

void h(const IA&);
void g(int (&&)[]);

h({1, 2, 3}); // int->int identity conversion
g({1, 2, 3}); // same as above since C++20

• В противном случае, если тип параметра — неагрегатный тип класса X, разрешение перегрузки выбирает конструктор C класса X для инициализации из списка инициализаторов аргумента
• Если C не является конструктором списка инициализаторов, а список инициализаторов содержит один элемент типа X (возможно, cv-квалифицированного), последовательность неявных преобразований имеет ранг точного совпадения. Если список инициализаторов содержит один элемент типа, производного от X (возможно, cv-квалифицированного), последовательность неявных преобразований имеет ранг преобразования. (Обратите внимание на отличие от агрегатов: агрегаты напрямую инициализируются из одноэлементных списков инициализаторов до рассмотрения агрегатной инициализации, а неагрегаты рассматривают конструкторы initializer_list раньше любых других конструкторов.)
• В противном случае последовательность неявных преобразований является пользовательской последовательностью преобразований, вторая стандартная последовательность преобразований которой является тождественным преобразованием.

Если допустимы несколько конструкторов, но ни один из них не лучше остальных, последовательность неявных преобразований является неоднозначной последовательностью преобразований.

struct A { A(std::initializer_list<int>); };
void f(A);

struct B { B(int, double); };
void g(B);

g({'a', 'b'});    // calls g(B(int, double)), user-defined conversion
// g({1.0, 1,0}); // error: double->int is narrowing, not allowed in list-init

void f(B);
// f({'a', 'b'}); // f(A) and f(B) both user-defined conversions

• В противном случае, если параметр имеет агрегатный тип, который можно инициализировать из списка инициализаторов согласно правилам агрегатной инициализации, последовательность неявных преобразований является пользовательской последовательностью преобразований, вторая стандартная последовательность преобразований которой является тождественным преобразованием.

struct A { int m1; double m2; };

void f(A);
f({'a', 'b'}); // calls f(A(int, double)), user-defined conversion

• В противном случае, если параметр является ссылкой, применяются правила инициализации ссылок

struct A { int m1; double m2; };

void f(const A&);
f({'a', 'b'}); // temporary created, f(A(int, double)) called. User-defined conversion

• В противном случае, если тип параметра не является классом, а список инициализаторов содержит один элемент, последовательность неявных преобразований — это последовательность, необходимая для преобразования элемента к типу параметра
• В противном случае, если тип параметра не является типом класса и список инициализаторов пуст, последовательность неявных преобразований является тождественным преобразованием.

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++.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2024):
• 12.2 Разрешение перегрузки [over.match]
• Стандарт C++20 (ISO/IEC 14882:2020):
• 12.4 Разрешение перегрузки [over.match]
• Стандарт C++17 (ISO/IEC 14882:2017):
• 16.3 Разрешение перегрузки [over.match]
• Стандарт C++14 (ISO/IEC 14882:2014):
• 13.3 Разрешение перегрузки [over.match]
• Стандарт C++11 (ISO/IEC 14882:2011):
• 13.3 Разрешение перегрузки [over.match]
• Стандарт C++03 (ISO/IEC 14882:2003):
• 13.3 Разрешение перегрузки [over.match]

См. также

• Поиск имён
• Поиск с учётом аргументов
• Вывод аргументов шаблона
• SFINAE