Compilerfehler C2668

'function' : mehrdeutiger Aufruf der überladenen Funktion

Der angegebene überladene Funktionsaufruf konnte nicht aufgelöst werden. Möglicherweise möchten Sie einen oder mehrere der tatsächlichen Parameter explizit umwandeln.

Sie können diesen Fehler auch über die Verwendung der Vorlage erhalten. Wenn Sie in derselben Klasse über eine reguläre Memberfunktion und eine vorlagebasierte Memberfunktion mit derselben Signatur verfügen, muss die Vorlage zuerst vorliegen. Diese Einschränkung bleibt in der aktuellen Implementierung von Visual C++ bestehen.

Beispiele

Im folgenden Beispiel wird C2668 generiert:

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

Eine weitere Möglichkeit zum Beheben dieses Fehlers ist eine using Deklaration:

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

Die Konvertierung für eine Umwandlung mit Konstante 0 ist mehrdeutig, da int eine Konvertierung sowohl in long als auch in .void* Um diesen Fehler zu beheben, wandeln Sie "0" in den genauen Typ des Funktionsparameters um, für den er verwendet wird. Dann müssen keine Konvertierungen stattfinden.

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

Dieser Fehler kann auftreten, da der CRT jetzt float über alle mathematischen Funktionen verfügt und double Formen aufweist.

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

Dieser Fehler kann auftreten, weil der pow(int, int) Fehler aus dem CRT entfernt math.h wurde.

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

Dieser Code ist in Visual Studio 2015 erfolgreich, schlägt jedoch in Visual Studio 2017 und höher mit C2668 fehl. In Visual Studio 2015 behandelte der Compiler die Copy-List-Initialisierung auf die gleiche Weise wie die reguläre Copy-Initialisierung. Er gilt nur für die Konvertierung von Konstruktoren für die Überladungsauflösung.

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
}