16 Overloading [over]

В function call

postfix-expression ( expression-list${}_{opt}$ )

если postfix-expressionобозначает набор перегруженных функций и / или шаблонов функций, применяется разрешение перегрузки, как указано в [over.call.func]. Если postfix-expressionобозначает объект типа класса, применяется разрешение перегрузки, как указано в [over.call.object].

Если postfix-expressionобозначает адрес набора перегруженных функций и / или шаблонов функций, разрешение перегрузки применяется с использованием этого набора, как описано выше. Если функция, выбранная с помощью разрешения перегрузки, является нестатической функцией-членом, программа имеет неправильный формат. [  Note: Разрешение адреса перегрузки, установленного в других контекстах, описано в [over.over]. ]  — end note 

Если ни один из операндов оператора в выражении не имеет типа, который является классом или перечислением, предполагается, что оператор является встроенным оператором и интерпретируется в соответствии с Clause [expr]. [  Note: Поскольку ., .*и ​::​ не могут быть перегружены, эти операторы всегда являются встроенными операторами, интерпретируемыми в соответствии с пунктом [expr]. ?: не может быть перегружен, но правила в этом подпункте используются для определения преобразований, которые будут применяться ко второму и третьему операндам, если они имеют тип класса или перечисления ([expr.cond]). ] [ — end note  Example:

struct String {
  String (const String&);
  String (const char*);
  operator const char* ();
};
String operator + (const String&, const String&);

void f() {
 const char* p= "one" + "two";  // ill-formed because neither operand has class or enumeration type
 int I = 1 + 1;                 // always evaluates to 2 even if class or enumeration types exist
                                // that would perform the operation.
}

 — end example ]

Если какой-либо из операндов имеет тип, который является классом или перечислением, может быть объявлена ​​пользовательская операторная функция, реализующая этот оператор, или может потребоваться пользовательское преобразование для преобразования операнда в тип, подходящий для встроенного в операторе. В этом случае разрешение перегрузки используется, чтобы определить, какую операторную функцию или встроенный оператор следует вызывать для реализации оператора. Следовательно, обозначение оператора сначала преобразуется в эквивалентное обозначение вызова функции, как показано в таблице 12 (где @ обозначает один из операторов, описанных в указанном подпункте). Однако операнды располагаются в порядке, установленном для встроенного оператора (пункт [expr]).

Для унарного оператора @ с операндом типа, чья cv-неквалифицированная версия равна T1, и для бинарного оператора @ с левым операндом типа, чья cv-неквалифицированная версия есть, T1 и правым операндом типа, чья cv-неквалифицированная версия равна T2, три наборы кандидатов функций, обозначены member candidates, non-member candidates и built-in candidates, строятся следующим образом :

• (3.1)

  Если T1 это полный тип класса или класс, определяемый в настоящее время, набор кандидатов в члены является результатом квалифицированного поиска T1​::​operator@ ([over.call.func]); в противном случае набор кандидатов в члены пуст.

• (3.2)

  Набор кандидатов, не являющихся членами, является результатом неквалифицированного поиска operator@ в контексте выражения в соответствии с обычными правилами поиска имени в неквалифицированных вызовах функций ([basic.lookup.argdep]), за исключением того, что все функции-члены игнорируются. Однако, если ни один операнд не имеет типа класса, только те функции, не являющиеся членами в наборе подстановки, которые имеют первый параметр типа T1 или «ссылку на cv T1», когда T1 это тип перечисления или (если есть правый операнд) второй Параметр типа T2 или «ссылка на cv T2», когда T2 является типом перечисления, являются функциями-кандидатами.

• (3.3)

  Для оператора ,, унарного оператора &или оператора ->набор встроенных кандидатов пуст. Для всех других операторов встроенные кандидаты включают в себя все функции операторов-кандидатов, определенные в [over.built] этом, по сравнению с данным оператором,

  • (3.3.1)

    иметь то же имя оператора и

  • (3.3.2)

    принять такое же количество операндов и

  • (3.3.3)

    принимать типы операндов, в которые можно преобразовать данный операнд или операнды в соответствии с [over.best.ics], и

  • (3.3.4)

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

Для встроенных операторов присваивания преобразование левого операнда ограничено следующим образом:

• (4.1)

  не вводятся временные файлы для хранения левого операнда, и

• (4.2)

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

Для всех остальных операторов такие ограничения отсутствуют.

Набор функций-кандидатов для разрешения перегрузки - это объединение кандидатов в члены, кандидатов, не являющихся членами, и встроенных кандидатов. Список аргументов содержит все операнды оператора. Лучшая функция из набора функций-кандидатов выбирается в соответствии с [over.match.viable] и [over.match.best].128 [ Example:

struct A {
  operator int();
};
A operator+(const A&, const A&);
void m() {
  A a, b;
  a + b;                        // operator+(a, b) chosen over int(a) + int(b)
}

 — end example ]

Если встроенный кандидат выбран путем разрешения перегрузки, операнды типа класса преобразуются в типы соответствующих параметров выбранной функции операции, за исключением того, что вторая стандартная последовательность преобразования a user-defined conversion sequence не применяется. Затем оператор рассматривается как соответствующий встроенный оператор и интерпретируется в соответствии с пунктом [expr]. [ Example:

struct X {
  operator double();
};

struct Y {
  operator int*();
};

int *a = Y() + 100.0;           // error: pointer arithmetic requires integral operand
int *b = Y() + X();             // error: pointer arithmetic requires integral operand

 — end example ]

Второй операнд оператора -> игнорируется при выборе operator-> функции и не является аргументом при operator-> вызове функции. При operator-> возврате оператор -> применяется к возвращенному значению с исходным вторым операндом.129

Если оператор является оператором ,, унарным оператором &или оператором ->и нет жизнеспособных функций, то предполагается, что оператор является встроенным оператором и интерпретируется в соответствии с пунктом [expr].

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

struct A { };
void operator + (A, A);

struct B {
  void operator + (B);
  void f ();
};

A a;

void B::f() {
  operator+ (a,a);              // error: global operator hidden by member
  a + a;                        // OK: calls global operator+
}

 — end note ]

Когда объекты типа класса direct-initializedинициализируются копией из выражения того же или производного типа класса ([dcl.init]), либо при default-initializedразрешении перегрузки выбирается конструктор. Для прямой инициализации или инициализации по умолчанию, которые не находятся в контексте инициализации копирования, все функции-кандидаты являются конструкторами класса инициализируемого объекта. Для инициализации копирования все функции-кандидаты converting constructors принадлежат этому классу. Список аргументов - это expression-listили assignment-expression из initializer.

В условиях, указанных в [dcl.init], как часть инициализации копии объекта типа класса, может быть вызвано определяемое пользователем преобразование для преобразования выражения инициализатора в тип инициализируемого объекта. Разрешение перегрузки используется для выбора вызываемого пользователем преобразования. [  Note: Преобразование, выполняемое для косвенной привязки к ссылке на тип класса, возможно, квалифицированный cv, определяется в терминах соответствующей инициализации копии без ссылки. ] Предполагая, что « » является типом инициализируемого объекта, с типом класса, функции-кандидаты выбираются следующим образом:  — end note cv1 TT

• (1.1)

  converting constructors Из T являются функциями кандидатов.

• (1.2)

  Когда тип выражения инициализатора является типом класса «cv S», рассматриваются неявные функции преобразования S и его базовые классы. При инициализации временного объекта, который должен быть привязан к первому параметру конструктора, где параметр имеет тип «ссылка на возможно- cvквалифицированный T», а конструктор вызывается с одним аргументом в контексте прямой инициализации объекта типа «cv2 T» , также рассматриваются явные функции преобразования. Те, которые не скрыты внутри S и дают тип, чья cv-неквалифицированная версия является тем же типом, что T и его производный класс, являются функциями-кандидатами. Функции преобразования, которые возвращают «ссылку на X», возвращают lvalue или xvalue, в зависимости от типа ссылки, типа X и поэтому считаются X подходящими для этого процесса выбора функций-кандидатов.

В обоих случаях список аргументов имеет один аргумент, который является выражением инициализатора. [  Note: Этот аргумент будет сравниваться с первым параметром конструкторов и неявным параметром объекта функций преобразования. ] — end note 

В условиях, указанных в [dcl.init], как часть инициализации объекта неклассового типа, функция преобразования может быть вызвана для преобразования выражения инициализатора типа класса в тип инициализируемого объекта. Разрешение перегрузки используется для выбора вызываемой функции преобразования. Предполагая, что «cv1 T» - это тип инициализируемого объекта, а «cv S» - это тип выражения инициализатора, с S типом класса функции-кандидаты выбираются следующим образом:

• (1.1)

  Рассмотрены функции преобразования S и его базовые классы. Те неявные функции преобразования, которые не скрыты внутри S и дают тип T или тип, который может быть преобразован в тип с T помощью a, standard conversion sequence являются функциями-кандидатами. Для прямой инициализации те явные функции преобразования, которые не скрыты внутри S и дают тип T или тип, который может быть преобразован в тип T с помощью a qualification conversion , также являются функциями-кандидатами. Считается, что функции преобразования, возвращающие тип с квалификацией cv, дают неквалифицированную версию этого типа для этого процесса выбора функций-кандидатов. Функции преобразования, которые возвращают «ссылку на cv2 X», возвращают значения l или x, в зависимости от типа ссылки, типа «cv2 X» и, следовательно, считаются X подходящими для этого процесса выбора функций-кандидатов.

Список аргументов имеет один аргумент, который является выражением инициализатора. [  Note: Этот аргумент будет сравниваться с неявным параметром объекта функций преобразования. ] — end note 

В условиях, указанных в [dcl.init.ref], ссылка может быть связана непосредственно с glvalue или классом prvalue, который является результатом применения функции преобразования к выражению инициализатора. Разрешение перегрузки используется для выбора вызываемой функции преобразования. Предполагая, что «ссылка на cv1 T» - это тип инициализируемой ссылки, а «cv S» - это тип выражения инициализатора, с S типом класса функции-кандидаты выбираются следующим образом:

• (1.1)

  Рассмотрены функции преобразования S и его базовые классы. Те неявные функции преобразования, которые не скрыты внутри S и дают тип «ссылка lvalue на cv2 T2» (при инициализации ссылки lvalue или ссылки rvalue на функцию) или «cv2 T2» или «ссылка rvalue на cv2 T2» (при инициализации ссылки rvalue или lvalue ссылка на функцию), где «cv1 T» стоит reference-compatible с «cv2 T2», являются функциями-кандидатами. Для прямой инициализации те явные функции преобразования, которые не скрыты внутри S и дают тип «ссылка lvalue на cv2 T2» или «cv2 T2» или «ссылка rvalue на cv2 T2», соответственно, где T2 тот же тип T или может быть преобразован в тип T с a qualification conversion, являются также кандидатские функции.

Список аргументов имеет один аргумент, который является выражением инициализатора. [  Note: Этот аргумент будет сравниваться с неявным параметром объекта функций преобразования. ] — end note 

Когда объекты неагрегированного типа класса T инициализируются списком, что [dcl.init.list] указывает, что разрешение перегрузки выполняется в соответствии с правилами в этом разделе, разрешение перегрузки выбирает конструктор в два этапа:

• (1.1)

  Первоначально функции-кандидаты являются конструкторами списка инициализаторов ([dcl.init.list]) класса, T а список аргументов состоит из списка инициализаторов в виде единственного аргумента.

• (1.2)

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

Если список инициализаторов не имеет элементов и T имеет конструктор по умолчанию, первая фаза опускается. При инициализации списка копирования, если explicit выбран конструктор, инициализация имеет неправильный формат . [  Note: Это отличается от других ситуаций ([over.match.ctor], [over.match.copy]), где для инициализации копирования рассматриваются только конструкторы преобразования. Это ограничение применяется только в том случае, если эта инициализация является частью окончательного результата разрешения перегрузки. ]  — end note 

Формируется набор функций и шаблонов функций, включающий:

• (1.1)

  Для каждого конструктора шаблона первичного класса, обозначенного template-name, если шаблон определен, шаблон функции со следующими свойствами:

  • (1.1.1)

    Параметры шаблона - это параметры шаблона шаблона класса, за которыми следуют параметры шаблона (включая аргументы шаблона по умолчанию) конструктора, если таковые имеются.

  • (1.1.2)

    Типы параметров функции такие же, как у конструктора.

  • (1.1.3)

    Тип возвращаемого значения - это специализация шаблона класса, обозначенная template-name аргументами и шаблона, соответствующими параметрам шаблона, полученным из шаблона класса.

• (1.2)

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

• (1.3)

  Дополнительный шаблон функции, полученный, как указано выше, из гипотетического конструктора C(C), который называется copy deduction candidate.

• (1.4)

  Для каждого из них deduction-guide- шаблон функции или функции со следующими свойствами:

  • (1.4.1)

    Параметры шаблона, если таковые имеются, и параметры функции - это параметры файла deduction-guide.

  • (1.4.2)

    Возвращаемый тип - simple-template-id это deduction-guide.

Инициализация и разрешение перегрузки выполняются, как описано в [dcl.init] и [over.match.ctor],, [over.match.copy]или [over.match.list] (в зависимости от типа выполняемой инициализации) для объекта гипотетического типа класса, где выбранные функции и шаблоны функций считаются конструкторами этого типа класса для цель формирования набора перегрузки, а инициализатор предоставляется контекстом, в котором было выполнено вывод аргументов шаблона класса. Каждый такой условный конструктор считается явным, если функция или шаблон функции были сгенерированы из конструктора или deduction-guideбыли объявлены explicit. Все такие условные конструкторы считаются открытыми членами гипотетического типа класса.

[ Example:

template <class T> struct A {
  explicit A(const T&, ...) noexcept;  // #1
  A(T&&, ...);                         // #2
};

int i;
A a1 = { i, i };    // error: explicit constructor #1 selected in copy-list-initialization during deduction,
                    // cannot deduce from non-forwarding rvalue reference in #2

A a2{i, i};         // OK, #1 deduces to A<int> and also initializes
A a3{0, i};         // OK, #2 deduces to A<int> and also initializes
A a4 = {0, i};      // OK, #2 deduces to A<int> and also initializes

template <class T> A(const T&, const T&) -> A<T&>;  // #3
template <class T> explicit A(T&&, T&&) -> A<T>;    // #4

A a5 = {0, 1};      // error: explicit deduction guide #4 selected in copy-list-initialization during deduction
A a6{0,1};          // OK, #4 deduces to A<int> and #2 initializes
A a7 = {0, i};      // error: #3 deduces to A<int&>, #1 and #2 declare same constructor
A a8{0,i};          // error: #3 deduces to A<int&>, #1 and #2 declare same constructor

template <class T> struct B {
  template <class U> using TA = T;
  template <class U> B(U, TA<U>);
};

B b{(int*)0, (char*)0};         // OK, deduces B<char*>

 — end example ]

An - это последовательность преобразований, используемая для преобразования аргумента в вызове функции в тип соответствующего параметра вызываемой функции. Последовательность преобразований является неявным преобразованием, как определено в разделе , что означает, что она регулируется правилами инициализации объекта или ссылки одним выражением ( , ).implicit conversion sequence [conv][dcl.init] [dcl.init.ref]

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

Правильно сформированная последовательность неявного преобразования - это одна из следующих форм:

• (3.1)

  а standard conversion sequence,

• (3.2)

  а user-defined conversion sequence, или

• (3.3)

  ан ellipsis conversion sequence.

Однако если цель

• (4.1)

  первый параметр конструктора или

• (4.2)

  неявный объектный параметр определяемой пользователем функции преобразования

а конструктор или определяемая пользователем функция преобразования является кандидатом от

• (4.3)

  [over.match.ctor], когда аргумент является временным на втором этапе инициализации копии класса,

• (4.4)

  [over.match.copy],, [over.match.conv]или [over.match.ref] (во всех случаях), или

• (4.5)

  вторая фаза, [over.match.list] когда список инициализаторов имеет ровно один элемент, который сам является списком инициализаторов, а цель является первым параметром конструктора класса X, а преобразование - в X или ссылка на cv X,

определяемые пользователем последовательности преобразования не рассматриваются. [  Note: Эти правила предотвращают применение более одного определяемого пользователем преобразования во время разрешения перегрузки, тем самым избегая бесконечной рекурсии. ] [ — end note  Example:

  struct Y { Y(int); };
  struct A { operator int(); };
  Y y1 = A();       // error: A​::​operator int() is not a candidate

  struct X { };
  struct B { operator X(); };
  B b;
  X x({b});         // error: B​::​operator X() is not a candidate

 — end example ]

Для случая, когда тип параметра является ссылкой, см [over.ics.ref]..

Если тип параметра не является ссылкой, неявная последовательность преобразования моделирует копирование-инициализацию параметра из выражения аргумента. Неявная последовательность преобразования - это последовательность, необходимая для преобразования выражения аргумента в значение типа параметра. [  Note: Если параметр имеет тип класса, это концептуальное преобразование, определенное для целей пункта [over]; фактическая инициализация определяется в терминах конструкторов и не является преобразованием. ] Любое различие в CV-квалификации верхнего уровня относится к самой инициализации и не является преобразованием. [ Параметр типа может быть инициализирован из аргумента типа . Последовательность неявного преобразования для этого случая является последовательностью идентичности; он не содержит «преобразования» из в . ] Когда параметр имеет тип класса и выражение аргумента имеет тот же тип, неявная последовательность преобразования является преобразованием идентичности. Когда параметр имеет тип класса, а выражение аргумента имеет тип производного класса, неявная последовательность преобразования представляет собой преобразование производного в базовый класс из производного класса в базовый класс. [ Такого стандартного преобразования нет; это преобразование производного в базовое существует только в описании неявных последовательностей преобразования. ] Производное преобразование в базовое имеет ранг преобразования ( ). — end note  Example: Aconst Aconst AA — end example  Note:  — end note [over.ics.scs]

Во всех контекстах при преобразовании в параметр неявного объекта или при преобразовании в левый операнд операции присваивания разрешены только стандартные последовательности преобразования.

Если для сопоставления аргумента с типом параметра не требуется никаких преобразований, неявная последовательность преобразования - это стандартная последовательность преобразования, состоящая из преобразования идентичности ([over.ics.scs]).

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

Если существует несколько различных последовательностей преобразований, каждая из которых преобразует аргумент в тип параметра, неявная последовательность преобразования, связанная с параметром, определяется как уникальная последовательность преобразования, обозначенная как ambiguous conversion sequence. С целью ранжирования последовательностей неявных преобразований, как описано в [over.ics.rank]разделе, неоднозначная последовательность преобразования рассматривается как заданная пользователем последовательность преобразования, неотличимая от любой другой заданной пользователем последовательности преобразования. [  Note: Это правило предотвращает невозможность работы функции из-за неоднозначной последовательности преобразования одного из ее параметров. [ Example:

class B;
class A { A (B&);};
class B { operator A (); };
class C { C (B&); };
void f(A) { }
void f(C) { }
B b;
f(b);               // ill-formed: ambiguous because there is a conversion b → C (via constructor)
                    // and an (ambiguous) conversion b → A (via constructor or conversion function)
void f(B) { }
f(b);               // OK, unambiguous

 — end example ] ] Если функция, использующая неоднозначную последовательность преобразования, выбрана как наиболее жизнеспособная функция, вызов будет неправильно сформирован, поскольку преобразование одного из аргументов в вызове неоднозначно. — end note 

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

В этом подпункте определяется частичный порядок неявных последовательностей преобразования на основе отношений better conversion sequence и better conversion. Если неявная последовательность преобразования S1 определена этими правилами как лучшая последовательность преобразования, чем S2, то это также случай, когда S2 является a, worse conversion sequence чем S1. Если последовательность преобразования S1 не лучше и не хуже, чем последовательность преобразования S2, то говорят, что S1 и S2 indistinguishable conversion sequences.

При сравнении основных форм неявных последовательностей преобразования (как определено в [over.best.ics])

• (2.1)

  a standard conversion sequence - лучшая последовательность преобразования, чем определенная пользователем последовательность преобразования или последовательность преобразования с многоточием, и

• (2.2)

  a user-defined conversion sequence - лучшая последовательность преобразования, чем ellipsis conversion sequence.

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

• (3.1)

  Последовательность инициализации списка L1 является лучшей последовательностью преобразования, чем последовательность инициализации списка, L2 если

  • (3.1.1)

    L1 конвертируется в std​::​initializer_­list<X> для некоторых X и L2 не преобразуется , или, если не то,

  • (3.1.2)

    L1 преобразуется в тип «массив N1 T», L2 преобразуется в тип «массив из N2 T» и N1 меньше, чем N2,

  даже если в противном случае применимо одно из других правил этого параграфа. [ Example:

    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
  

   — end example ]

• (3.2)

  Стандартная последовательность преобразования S1 является лучшей последовательностью преобразования, чем стандартная последовательность преобразования, S2 если

  • (3.2.1)

    S1 является надлежащей подпоследовательностью S2 (сравнение последовательностей преобразования в канонической форме, определенной с помощью [over.ics.scs], исключая любое преобразование Lvalue; последовательность преобразования идентичности считается подпоследовательностью любой последовательности преобразования, отличной от идентичности) или, если это не так,

  • (3.2.2)

    ранг S1 лучше, чем ранг S2, или S1 и S2 имеют такой же ранг и различимы по правилам, изложенным в нижеследующем абзаце, или, если это не так,

  • (3.2.3)

    S1 и S2 являются привязками ссылок ([dcl.init.ref]), и ни одна из них не относится к неявному объектному параметру нестатической функции-члена, объявленной без a ref-qualifier, и S1 связывает ссылку rvalue с rvalue и S2 связывает ссылку lvalue [ Example:

    int i;
    int f1();
    int&& f2();
    int g(const int&);
    int g(const int&&);
    int j = g(i);                   // calls g(const int&)
    int k = g(f1());                // calls g(const int&&)
    int l = g(f2());                // calls g(const int&&)
    
    struct A {
      A& operator<<(int);
      void p() &;
      void p() &&;
    };
    A& operator<<(A&&, char);
    A() << 1;                       // calls A​::​operator<<(int)
    A() << 'c';                     // calls operator<<(A&&, char)
    A a;
    a << 1;                         // calls A​::​operator<<(int)
    a << 'c';                       // calls A​::​operator<<(int)
    A().p();                        // calls A​::​p()&&
    a.p();                          // calls A​::​p()&
    

     — end example ] или, если не это,

  • (3.2.4)

    S1 и S2 являются привязками ссылок ([dcl.init.ref]) и S1 связывает ссылку lvalue с функцией lvalue и S2 связывает ссылку rvalue с функцией lvalue [ Example:

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

     — end example ] или, если не это,

  • (3.2.5)

    S1 и S2 отличаются только их квалификационным преобразованием и дают аналогичные типы T1 и T2 ([conv.qual]), соответственно, а сигнатура cv-qualification типа T1 является надлежащим подмножеством сигнатуры cv-qualification типа T2 [ Example:

    int f(const volatile int *);
    int f(const int *);
    int i;
    int j = f(&i);                  // calls f(const int*)
    

     — end example ] или, если не это,

  • (3.2.6)

    S1 и S2 являются ссылочными привязками ([dcl.init.ref]), а типы, на которые ссылаются ссылки, относятся к одному и тому же типу, за исключением cv-квалификаторов верхнего уровня, а тип, на который ссылается ссылка, инициализированная с помощью, S2 более квалифицирован cv, чем тип, на который ссылка инициализируется S1 ссылками. [ Example:

    int f(const int &);
    int f(int &);
    int g(const int &);
    int g(int);
    
    int i;
    int j = f(i);                   // calls f(int &)
    int k = g(i);                   // ambiguous
    
    struct X {
      void f() const;
      void f();
    };
    void g(const X& a, X b) {
      a.f();                        // calls X​::​f() const
      b.f();                        // calls X​::​f()
    }

     — end example ]

• (3.3)

  Определяемая пользователем последовательность преобразования U1 является лучшей последовательностью преобразования, чем другая определяемая пользователем последовательность преобразования, U2 если они содержат ту же определенную пользователем функцию преобразования или конструктор или инициализируют один и тот же класс в совокупной инициализации, и в любом случае вторая стандартная последовательность преобразования U1 равна лучше, чем вторая стандартная последовательность преобразования U2. [ Example:

  struct A {
    operator short();
  } a;
  int f(int);
  int f(float);
  int i = f(a);                   // calls f(int), because short → int is
                                  // better than short → float.
  

   — end example ]

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

• (4.1)

  Преобразование, которое не преобразует указатель, указатель на член или std​::​nullptr_­t на bool , лучше, чем такое преобразование .

• (4.2)

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

• (4.3)

  Если класс B является производным прямо или косвенно от класса A, преобразование B* в A* лучше, чем преобразование B* в void*, а преобразование A* в void* лучше, чем преобразование B* в void*.

• (4.4)

  Если класс B является производным прямо или косвенно от класса, A а класс C является производным прямо или косвенно от B,

  • (4.4.1)

    преобразование C* в B* лучше, чем преобразование C* в A*, [ Example:

    struct A {};
    struct B : public A {};
    struct C : public B {};
    C* pc;
    int f(A*);
    int f(B*);
    int i = f(pc);                  // calls f(B*)
    

     — end example ]

  • (4.4.2)

    привязка выражения типа C к ссылке на тип B лучше, чем привязка выражения типа C к ссылке на тип A,

  • (4.4.3)

    преобразование A​::​* в B​::​* лучше, чем преобразование A​::​* в C​::​*,

  • (4.4.4)

    преобразование C в B лучше, чем преобразование C в A,

  • (4.4.5)

    преобразование B* в A* лучше, чем преобразование C* в A*,

  • (4.4.6)

    привязка выражения типа B к ссылке на тип A лучше, чем привязка выражения типа C к ссылке на тип A,

  • (4.4.7)

    преобразование B​::​* в C​::​* лучше, чем преобразование A​::​* в C​::​*, и

  • (4.4.8)

    преобразование B в A лучше, чем преобразование C в A.

  [  Note: Сравниваемые последовательности преобразования будут иметь разные типы источников только в контексте сравнения второй стандартной последовательности преобразования инициализации посредством пользовательского преобразования (см. [over.match.best]); во всех других контекстах исходные типы будут такими же, а целевые типы будут разными. ]  — end note