Erro do compilador C2668

'função' : chamada ambígua para função sobrecarregada

Observações

A chamada de função sobrecarregada especificada não pôde ser resolvida. Você pode querer converter explicitamente um ou mais dos parâmetros reais.

Você também pode obter esse erro por meio do uso de um modelo de template. Se, na mesma classe, tiver uma função de membro regular e uma função de membro modelo com a mesma assinatura, a função de membro modelo deve vir primeiro. Essa limitação permanece na implementação atual do Visual C++.

Examples

O exemplo a seguir gera C2668:

// C2668.cpp
struct A {};
struct B : A {};
struct X {};
struct D : B, X {};

void func( X, X ){}
void func( A, B ){}
D d;
int main() {
   func( d, d );   // C2668 D has an A, B, and X
   func( (X)d, (X)d );   // OK, uses func( X, X )
}

Outra maneira de resolver esse erro é com uma using declaração:

// C2668b.cpp
// compile with: /EHsc /c
// C2668 expected
#include <iostream>
class TypeA {
public:
   TypeA(int value) {}
};

class TypeB {
   TypeB(int intValue);
   TypeB(double dbValue);
};

class TestCase {
public:
   void AssertEqual(long expected, long actual, std::string
                    conditionExpression = "");
};

class AppTestCase : public TestCase {
public:
   // Uncomment the following line to resolve.
   // using TestCase::AssertEqual;
   void AssertEqual(const TypeA expected, const TypeA actual,
                    std::string conditionExpression = "");
   void AssertEqual(const TypeB expected, const TypeB actual,
                    std::string conditionExpression = "");
};

class MyTestCase : public AppTestCase {
   void TestSomething() {
      int actual = 0;
      AssertEqual(0, actual, "Value");
   }
};

A conversão de tipo usando a constante 0 é ambígua, pois int requer uma conversão tanto para long quanto para void*. Para resolver esse erro, converta 0 para o tipo exato do parâmetro de função para o qual está sendo usado. Então, nenhuma conversão precisa ocorrer.

// C2668c.cpp
#include "stdio.h"
void f(long) {
   printf_s("in f(long)\n");
}
void f(void*) {
   printf_s("in f(void*)\n");
}
int main() {
   f((int)0);   // C2668

   // OK
   f((long)0);
   f((void*)0);
}

Este erro pode ocorrer porque o CRT agora possui formas float e double de todas as funções matemáticas.

// C2668d.cpp
#include <math.h>
int main() {
   int i = 0;
   float f;
   f = cos(i);   // C2668
   f = cos((float)i);   // OK
}

Este erro pode ocorrer porque o pow(int, int) foi removido do math.h CRT.

// C2668e.cpp
#include <math.h>
int main() {
   pow(9,9);   // C2668
   pow((double)9,9);   // OK
}

Esse código é bem-sucedido no Visual Studio 2015, mas falha no Visual Studio 2017 e posterior com C2668. No Visual Studio 2015, o compilador tratou erroneamente a inicialização da lista de cópia da mesma maneira que a inicialização de cópia regular. Considerou apenas conversões de construtores para resolução de sobrecargas.

struct A {
    explicit A(int) {}
};

struct B {
    B(int) {}
};

void f(const A&) {}
void f(const B&) {}

int main()
{
    f({ 1 }); // error C2668: 'f': ambiguous call to overloaded function
}