16 Overloading [over]

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