Erreur du compilateur C2668

'function' : appel ambigu à la fonction surchargée

Impossible de résoudre l’appel de fonction surchargé spécifié. Vous pouvez effectuer un cast explicite d’un ou plusieurs des paramètres réels.

Vous pouvez également obtenir cette erreur via l’utilisation du modèle. Si, dans la même classe, vous disposez d’une fonction membre régulière et d’une fonction membre modèle avec la même signature, celle qui est modèleée doit commencer. Cette limitation reste dans l’implémentation actuelle de Visual C++.

Exemples

L’exemple suivant génère l’erreur 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 )
}

Une autre façon de résoudre cette erreur consiste à utiliser une using déclaration :

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

La conversion sur un cast à l’aide de la constante 0 est ambiguë, car int nécessite une conversion vers et vers long void*. Pour résoudre cette erreur, convertissez 0 en type exact du paramètre de fonction pour lequel il est utilisé. Ensuite, aucune conversion n’a besoin d’être effectuée.

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

Cette erreur peut se produire parce que le CRT a float maintenant et double des formes de toutes les fonctions mathématiques.

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

Cette erreur peut se produire, car elle pow(int, int) a été supprimée math.h dans le CRT.

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

Ce code réussit dans Visual Studio 2015, mais échoue dans Visual Studio 2017 et versions ultérieures avec C2668. Dans Visual Studio 2015, le compilateur a traité par erreur l’initialisation de la liste de copie de la même façon que l’initialisation de copie régulière. Il a considéré uniquement la conversion des constructeurs pour la résolution de surcharge.

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
}