Error del compilador C2668

"function": llamada ambigua a una función sobrecargada

No se ha podido resolver la llamada de función sobrecargada especificada. Es posible que quiera convertir explícitamente uno o varios de los parámetros reales.

También puede obtener este error mediante el uso de la plantilla. Si, en la misma clase, tiene una función miembro normal y una función miembro con plantilla con la misma firma, la plantilla debe aparecer primero. Esta limitación permanece en la implementación actual de Visual C++.

Ejemplos

En el ejemplo siguiente se genera 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 )
}

Otra manera de resolver este error es con una declaración using:

// 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");
   }
};

Convertir en una conversión mediante la constante 0 es ambigua, ya que int requiere una conversión tanto a long como a void*. Para resolver este error, convierta 0 en el tipo exacto del parámetro de función para el que se usa. Después, no será necesario realizar ninguna conversión.

// 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 error puede producirse porque CRT ahora tiene formatos float y double de todas las funciones matemáticas.

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

Este error puede producirse porque pow(int, int) se quitó de math.h en CRT.

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

Este código se ejecuta correctamente en Visual Studio 2015, pero produce un error en Visual Studio 2017 y versiones posteriores con C2668. En Visual Studio 2015, el compilador trataba erróneamente la inicialización de lista de copia como si fuera inicialización de copia regular. Solo consideraba la conversión de constructores para la resolución de sobrecarga.

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
}