Блог

 #include <iostream>
void g(int*);  //#1
void g(int (amp;arr)[2]);  //#2

void f(int*);  //#3
void f(int const*);  //#4
int main(){
  int arr[2] ={0};
  f(arr);    // choose #3
  g(arr);  //ambiguous
}
 

Рассмотрим приведенный выше код, для которого выбран #3 f(ptr) , однако g(arr) он дает ambiguous диагностику.

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

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

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

Итак, взгляните на over.ics.scs # 3

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

Согласно моему пониманию приведенного выше правила, я могу понять, почему #3 это лучшая перегрузка для f(ptr) , то есть:

Задается S1 как (arr => int *):

 Array-to-pointer conversion -> (identity conversion)  
^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^                   
     int[2] => int*             int* => int* 
 

при заданном значении S2 как (ptr => int const *)

 Array-to-pointer conversion -> Qualification conversions ->  identity conversion   
^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^ 
     int[2] => int*               int* => int const*           int const* => int const* 
 

Поскольку identity conversion является правильной подпоследовательностью Qualification conversions , следовательно, S1 лучше, чем S2. Итак, #3 выбирается по разрешению перегрузки для f(ptr) .

Когда я использую аналогичный процесс для определения того, что лучше g(arr) , я сталкиваюсь с проблемой.

Опять же, учитывая S1 как (arr => int *)

 Array-to-pointer conversion -> identity conversion  
^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^ 
      int[2] => int*              int* => int*
 

при заданном S2 как(arr => int (amp;arr)[2])

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

 identity conversion
^^^^^^^^^^^^^^^^^^^
  bind to reference   
 

Здесь identity conversion of S2 является правильной подпоследовательностью Array-to-pointer conversion of S1 , следовательно, это должно быть лучше, чем S1 , почему компилятор жаловался g(arr) на неоднозначный вызов?

Есть ли у меня какие-либо неправильные представления о том, как ранжировать стандартные последовательности преобразования? Как сравнить два стандартных ICS (ранг содержащегося преобразования)?

Ключевой момент заключается вот в чем:

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

Это означает, что для вызова функции g(arr) все преобразования массива в указатель не используются для определения ранга. Другими словами, от типа int[2] к типу int* существует только преобразование идентификаторов, которое использовалось для определения ранга. Следовательно, S1 of void g(int*); и S2 of void g(int (amp;arr)[2]); являются неразличимыми микросхемами, поэтому компилятор выдает неоднозначную ошибку.

В отличие от этого, преобразования для void f(int*); и void f(int const*); , используемые для сравнения ранга, являются identity conversion и qualification conversion , соответственно.

В соответствии с правилом:

последовательность преобразования идентификаторов считается подпоследовательностью любой последовательности преобразования, не являющейся идентичной

Следовательно, Qualification conversion считается, что имеет худший ранг, чем у identity conversion . Итак, void f(int*) выиграл соревнование.

Вы пытаетесь применить over.ics.rank-3.2.1 к этим наборам перегрузок, но это правило не применяется ни f к одному, ни g к другому.

Учитывая вызов f(arr); , при выполнении разрешения перегрузки для f обеих перегрузок требуется стандартная последовательность преобразования, состоящая из преобразования массива в указатель, и оба имеют одинаковый ранг, что является точным совпадением. Тай-брейк, используемый в этом случае, — over.match.best#over.ics.rank-3.2.5:

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

…

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

После этого правила приведен пример, демонстрирующий, как работает правило.

Для набора перегрузки f T1 есть int * и T2 есть int const * , и T1 может быть преобразован в T2 путем преобразования квалификации.

В случае вызова g(arr); при выполнении разрешения перегрузки g(int (amp;)[2]) перегрузка оценивается как точное совпадение, поскольку требуемая стандартная последовательность преобразования не требуется.

Однако перегрузка g(int*) также оценивается как точное совпадение, поскольку стандартная необходимая последовательность преобразования — это преобразование массива в указатель.

f Однако, в отличие от for , в [over.ics.rank] нет правила, которое устраняет неоднозначность между стандартными последовательностями преобразования for g , и вызов завершается с ошибкой.