Błąd kompilatora C2668Compiler Error C2668

"Function": niejednoznaczne wywołanie przeciążonej funkcji'function' : ambiguous call to overloaded function

Nie można rozpoznać określonego przeciążonego wywołania funkcji.The specified overloaded function call could not be resolved. Możesz chcieć jawnie rzutować co najmniej jeden z rzeczywistych parametrów.You may want to explicitly cast one or more of the actual parameters.

Ten błąd można także uzyskać za pomocą szablonu.You can also get this error through template use. Jeśli w tej samej klasie istnieje zwykła funkcja członkowska i wbudowana funkcja członkowska o tym samym podpisie, szablon, który musi być wcześniej.If, in the same class, you have a regular member function and a templated member function with the same signature, the templated one must come first. Jest to ograniczenie bieżącej implementacji Visual C++.This is a limitation of the current implementation of Visual C++.

PrzykładyExamples

Poniższy przykład generuje C2668:The following sample generates 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 )
}

Innym sposobem na rozwiązanie tego błędu jest użycie deklaracji using:Another way to resolve this error is with a using declaration:

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

Ten błąd może być również wygenerowany jako wynik zgodności kompilatora, który został wykonany dla programu Visual Studio .NET 2003: niejednoznaczna konwersja na rzutowanie stałej 0.This error can also be generated as a result of compiler conformance work that was done for Visual Studio .NET 2003: ambiguous conversion on cast of constant 0.

Konwersja na rzutowanie przy użyciu stałej 0 jest niejednoznaczna, ponieważ int wymaga konwersji zarówno na wartość Long, jak i na wartość pustą *.Conversion on a cast using constant 0 is ambiguous since int requires a conversion both to long and to void*. Aby rozwiązać ten problem, należy rzutować 0 do dokładnego typu parametru funkcji, który jest używany przez, aby nie trzeba było przeprowadzać konwersji (kod ten będzie prawidłowy w wersjach programu Visual Studio .NET 2003 i Visual Studio .NET Visual C++).To resolve this error, cast 0 to the exact type of the function parameter it is being used for so that no conversions need to take place (this code will be valid in the Visual Studio .NET 2003 and Visual Studio .NET versions of Visual C++).

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

Ten błąd może wystąpić, ponieważ CRT ma teraz zmiennoprzecinkowe i podwójne formy wszystkich funkcji matematycznych.This error can occur because the CRT now has float and double forms of all math functions.

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

Ten błąd może wystąpić, ponieważ pow (int, int) została usunięta z Math. h w CRT.This error can occur because the pow(int, int) was removed from math.h in the CRT.

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

Ten kod działa prawidłowo w programie Visual Studio 2015, ale kończy się niepowodzeniem w programie Visual Studio 2017 lub nowszym z C2668.This code succeeds in Visual Studio 2015 but fails in Visual Studio 2017 and later with C2668. W programie Visual Studio 2015 kompilator błędnie traktował inicjalizację listy kopiowania w taki sam sposób jak regularne inicjowanie kopiowania; jest on uważany tylko za konwersję konstruktorów w celu rozpoznania przeciążenia.In Visual Studio 2015, the compiler erroneously treated copy-list-initialization in the same way as regular copy-initialization; it considered only converting constructors for overload resolution.

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
}