Compiler Error C2668

'function' : ambiguous call to overloaded function

The specified overloaded function call couldn't be resolved. You may want to explicitly cast one or more of the actual parameters.

You can also get this error through template use. 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. This limitation remains in the current implementation of Visual C++.


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 )

Another way to resolve this error is with a using declaration:

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

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

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

class AppTestCase : public TestCase {
   // 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");

Conversion on a cast using constant 0 is ambiguous since int requires a conversion both to long and to void*. To resolve this error, cast 0 to the exact type of the function parameter it's being used for. Then no conversions need to take place.

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

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

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

This code succeeds in Visual Studio 2015 but fails in Visual Studio 2017 and later with C2668. 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