Correspondência de argumento
As funções sobrecarregadas são selecionadas para corresponder melhor declarações de função no escopo atual aos argumentos fornecidos na chamada de função. Se uma função apropriada for localizada, essa função é chamada. “Apropriada” neste contexto significa uma das seguintes opções:
Uma correspondência exata foi encontrada.
Uma conversão trivial foi executada.
Uma promoção integral foi executada.
Uma conversão padrão para o tipo de argumento desejado existe.
Uma conversão definida pelo usuário (operador ou construtor de conversão) para o tipo de argumento desejado existe.
Argumentos representados por reticências foram encontrados.
O compilador cria um conjunto de funções candidatas para cada argumento. As funções candidatas são funções em que o argumento real nessa posição pode ser convertido no tipo do argumento formal.
Um conjunto de “melhores funções correspondentes” é 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ígua e gera um erro. A função que é selecionada sempre é uma correspondência melhor de que todas as outras funções no grupo para no mínimo um argumento. Se isso não acontecer (se não houver nenhum vencedor claro), a chamada de função gera um erro.
Observe as seguintes declarações (as funções são marcadas Variant 1, Variant 2 e Variant 3, para 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 o seguinte instrução:
F1 = Add( F2, 23 );
A instrução anterior compila dois conjuntos:
Conjunto 1: Funções candidatas que têm o primeiro argumento do tipo fração |
Conjunto 2: Funções candidatas cujo segundo argumento pode ser convertido no tipo int |
|---|---|
Variant 1 |
Variant 1 (int pode ser convertida em long usando uma conversão padrão) |
Variant 3 |
|
As funções no Conjunto 2 são funções para as quais há conversões implícitas a partir do tipo de parâmetro real para o tipo de parâmetro formal, e dentre as quais exista uma função para qual o "custo" de conversão do tipo de parâmetro real para seu tipo de parâmetro formal seja o menor.
A interseção desses dois conjuntos é a Variant 1. Um exemplo de uma chamada de função ambígua é:
F1 = Add( 3, 6 );
A chamada de função anterior compila os seguintes conjuntos:
Conjunto 1: Funções candidatas que têm o primeiro argumento do tipo int |
Conjunto 2: Funções candidatas que têm o segundo argumento do tipo int |
|---|---|
Variant 2 (int pode ser convertida em long usando uma conversão padrão) |
Variant 1 (int pode ser convertida em long usando uma conversão padrão) |
Observe que a interseção entre esses dois conjuntos está vazia. Em virtude disso, o compilador gera uma mensagem de erro.
Para a correspondência do argumento, uma função com nargumentos padrão é tratada como funções n+1 separadas, cada uma com um número diferente de argumentos.
As reticências (...) atuam como um curinga; elas correspondem a qualquer argumento real. Isso pode resultar em muitos conjuntos ambíguos, se você não criar seus conjuntos de função sobrecarregada com extremo cuidado.
Dica
A ambiguidade das funções sobrecarregadas não pode ser determinada até que uma chamada de função seja encontrada.Nesse ponto, os conjuntos são compilados para cada argumento na chamada de função, e você pode determinar se há uma sobrecarga inequívoca.Isso significa que as ambiguidades podem permanecer em seu código até que sejam evocadas por uma chamada de função específica.