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

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

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

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

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 является основным выражением, имя ищется по обычным правилам для вызова функций (что может включать ADL). Объявления функций, найденные при этом поиске, по причине работы поиска, являются либо:

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

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

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

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

• Операторы вызова функций типа T получаются обычным поиском имени operator() в контексте выражения (E).operator(), и каждое найденное объявление добавляется в набор кандидатных функций.
• Для каждой неявной пользовательской функции преобразования в 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

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

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

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

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

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

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

• все конвертирующие конструкторы T
• функции неявного преобразования из 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 ссылки или rvalue ссылки на функцию) lvalue ссылка на cv2 T2
• (при инициализации rvalue ссылки или lvalue ссылки на функцию) cv2 T2 или rvalue ссылка на cv2 T2

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

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

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

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

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

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

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

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

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

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

• Если оба шага успешны, аргументы шаблона используются для синтеза объявлений соответствующих специализаций шаблона функции, которые добавляются в набор кандидатов, и такие специализации обрабатываются так же, как и нешаблонные функции, за исключением случаев, указанных в правилах решающего фактора ниже.
• Если вывод аргументов терпит неудачу или синтезированная специализация шаблона функции будет некорректной, такая функция не добавляется в набор кандидатов (см. 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 и

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

int f(const int*);
int f(int*);
 
int i;
int j = f(&i); // &i -> int* is better than &i -> const int*, calls f(int*)

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, неявная последовательность преобразований имеет ранг "Точное соответствие". (Обратите внимание на разницу с агрегатами: агрегаты инициализируются непосредственно из списков инициализации с одним элементом до рассмотрения инициализации агрегатов, неагрегаты рассматривают конструкторы для 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++.

1. Тип первого параметра встроенного оператора присваивания — это «ссылка на значение lvalue, возможно, с квалификатором volatile T». Ссылки такого типа не могут быть привязаны к временной переменной.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2023):
• 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