Compartilhar via


Argumento de correspondência

Funções sobrecarregadas são selecionadas para a melhor correspondência das declarações de função no escopo atual para os argumentos fornecidos na chamada da função.Se uma função adequada for encontrada, essa função é chamada. "Adequado"neste contexto significa um destes procedimentos:

  • Foi encontrada uma correspondência exata.

  • Uma conversão trivial foi executada.

  • Uma promoção integral foi executada.

  • Uma conversão padrão para o tipo de argumento desejado existe.

  • Definido pelo usuário exista uma conversão (operador de conversão ou construtor) para o tipo de argumento desejado.

  • Foram encontrados argumentos representados por uma elipse.

O compilador cria um conjunto de candidato funções para cada argumento.Candidatos são funções em que o argumento real nessa posição pode ser convertido para o tipo do argumento formal.

Um conjunto de "melhor correspondência de funções" é criado para cada argumento, e a função selecionada é a interseção de todos os conjuntos.Se a interseção contiver mais de uma função, a sobrecarga é ambíguo e gera um erro.A função selecionada, eventualmente, é sempre melhor correspondência que todas as outras funções no grupo pelo menos um argumento.Se não for esse o caso (se houver um vencedor claro), a chamada de função gera um erro.

Considere as seguintes declarações (as funções são marcadas Variant 1, Variant 2, e Variant 3, para a identificação na discussão a seguir):

Fraction &Add( Fraction &f, long l );       // Variant 1
Fraction &Add( long l, Fraction &f );       // Variant 2
Fraction &Add( Fraction &f, Fraction &f );  // Variant 3

Fraction F1, F2;

Considere a seguinte instrução:

F1 = Add( F2, 23 );

A instrução anterior cria dois conjuntos:

Conjunto 1: Funções de candidatos que têm o primeiro argumento de tipo de fração

Conjunto 2: Candidato funções cujo segundo argumento pode ser convertido no tipo int

Variant 1

Variant 1 (int pode ser convertido em long usando uma conversão padrão)

Variant 3

 

Funções em Set 2 são as funções para as quais há são conversões implícitas de tipo de parâmetro real para o tipo de parâmetro formal e entre funções, há uma função para o qual o "custo" de converter o tipo de parâmetro real para seu tipo de parâmetro formal é menor.

A interseção entre esses dois conjuntos é 1 Variant.Um exemplo de uma chamada de função ambíguo é:

F1 = Add( 3, 6 );

A chamada de função anterior cria os seguintes conjuntos:

Conjunto 1: Candidato funções que têm primeiro argumento do tipo int

Conjunto 2: Candidato funções que têm segundo argumento do tipo int

Variant 2 (int pode ser convertido em long usando uma conversão padrão)

Variant 1 (int pode ser convertido em long usando uma conversão padrão)

Observe que a interseção entre esses dois conjuntos está vazia.Portanto, o compilador gera uma mensagem de erro.

Para o argumento correspondente, uma função com n argumentos padrão é tratado como n+ 1 separado funciona, cada um com um número diferente de argumentos.

Os atos de reticências (...) como caractere curinga; corresponde a qualquer argumento real.Isso pode levar a muitos conjuntos ambíguos, se você não criar conjuntos de função sobrecarregada com muito cuidado.

ObservaçãoObservação

Não é possível determinar a ambigüidade de funções sobrecarregadas até encontrar uma chamada de função.Nesse ponto, os conjuntos são criados para cada argumento na chamada da função e você pode determinar se uma sobrecarga inequívoca existe.Isso significa que a ambigüidades podem permanecer em seu código, até que eles são evoked por uma chamada de função específica.

Consulte também

Referência

Sobrecarga