Error call of overloaded is ambiguous

Pre-requisite: Function Overloading in C++

Function overloading is a feature of object-oriented programming where two or more functions can have the same name but different parameters. When a function name is overloaded with different jobs it is called Function Overloading. Two or more functions are said to be overloaded if they differ in any of the following-

1. The number of arguments.
2. Order of arguments.
3. Type of arguments.

In Function overloading, sometimes a situation can occur when the compiler is unable to choose between two correctly overloaded functions. This situation is said to be ambiguous. 

Ambiguous statements are error-generating statements and the programs containing ambiguity will not compile. Automatic type conversions are the main cause of ambiguity. In C++, the type of argument that is used to call the function is converted into the type of parameters defined by the function. 

Let’s understand ambiguity through a few examples.

Call of overloaded function is ambiguous

Example 1: Call of overloaded ‘test(char)’ is ambiguous

How this ambiguity occurs:
Below is the C++ program to demonstrate the ambiguity.

Output:

prog.cpp: In function ‘int main()’:

prog.cpp:25:11: error: call of overloaded ‘test(char)’ is ambiguous

  test(‘a’);

          ^

prog.cpp:8:6: note: candidate: void test(float)

void test(float f)  

     ^

prog.cpp:15:6: note: candidate: void test(double)

void test(double d)  

     ^

Why ambiguity occurs:

 When there is no exact type match, the compiler looks for the closest match. The closest match for “test(‘a’);” will be “void test(int a)”, since it is not present, void test(double d) and void (float f)will cause ambiguity. Both are valid conversions. This confusion causes an error message to be displayed and prevents the program from compiling.

Note:
According to the C language specification, any integer type shorter than int, for example, bool, char, short are implicitly converted to int.

A char fits into an int without overflowing or losing precision, which explains the first code. But an int doesn’t fit into a char (overflow), double (lack of precision), or int* (incompatible type).

How to resolve ambiguity:

There are two ways to resolve this ambiguity:

1. Typecast char to float.
2. Remove either one of the ambiguity generating functions float or double and add overloaded function with an int type parameter.

Solution 1: Typecast char to float

Below is the C++ program to demonstrate how typecasting char to float resolves the issue.

Overloaded Function with float parameter being called

Solution 2: Remove either one of the ambiguity generating functions float or double and add overloaded function with an int type parameter.

Below is the C++ program to demonstrate how adding an overloading function with an int type parameter can resolve the ambiguity in the above code.

Overloaded Function with int type parameter called

Example 2: Call of overloaded ‘test(float)’ is ambiguous

How this ambiguity occurs:
Below is the C++ program to demonstrate what will happen in the scenario when the type of float value is used to call the overloaded function and there is no function with the float or double parameters.

Output:

prog.cpp: In function ‘int main()’:

prog.cpp:25:12: error: call of overloaded ‘test(float)’ is ambiguous

  test(2.5f);

           ^

prog.cpp:8:6: note: candidate: void test(int)

void test(int f)  

     ^

prog.cpp:15:6: note: candidate: void test(long int)

void test(long d)  

     ^

Why ambiguity occurs:
The above code will throw an error because the test(2.5f) function call will look for float function if not present it is only promoted to double, but there is no function definition with double or float type of parameter.

Unless explicitly specified all floating-point literals are automatically of type double in C++. In this ambiguity, the variable of a float type is implicitly converted to double type and if there is no overloaded function of float or double type and the function is called with a float value then the program will throw an error.

Note:
The float is converted to double under the following situations:

• The float is an argument to a function call, corresponding to a parameter type double in a function prototype.
• A binary operator has double and float as two argument types.
• A conditional operator has double and float as a second and third operand.
• The float value is cast to double.
• The float value is assigned to double.

How to resolve ambiguity:

There are two ways to resolve the ambiguity-

1. Typecast float to int.
2. Remove either one of the ambiguity generating functions int or long and add overloaded function with a double type parameter.

Solution 1: Typecast float to int

Below is the C++ program to demonstrate how typecasting float to int resolves the issue.

Overloaded Function with int type parameter called

Solution 2: Remove either one of the ambiguity generating functions int or long and add overloaded function with a double type parameter.

Below is the C++ program to demonstrate how to resolve this ambiguity by adding an overloaded function with double type parameters.

Overloaded Function with double type parameter called

Call of overloaded function with different number of arguments

Redefinition of ‘void test(int, int) function:
Let’s look at another ambiguity scenario where ambiguity occurs when it is two-parameter and one of the parameters has a default value set.

Output:

prog.cpp: In function ‘void test(int, int)’:

prog.cpp:17:6: error: redefinition of ‘void test(int, int)’

void test(int i, int j = 5)  

     ^

prog.cpp:8:6: note: ‘void test(int, int)’ previously defined here

void test(int i, int j)  

     ^

prog.cpp: In function ‘int main()’:

prog.cpp:35:10: error: too few arguments to function ‘void test(int, int)’

  test(10);

         ^

prog.cpp:8:6: note: declared here

void test(int i, int j)  

     ^

Why ambiguity occurs:

Here, in the unambiguous call statement test(10, 11) two arguments are specified, therefore there is no ambiguity. In the ambiguous call statement test(10), the compiler gets confused about whether to call the first function test() which takes one argument or to call the second test() function with two arguments out of which one is the default. This causes the program to throw an error.

How to resolve the ambiguity:

One solution to resolve the ambiguity is to remove the default value from the overloaded function with two int parameters. Below is the C++ program to demonstrate the above approach-

Overloaded function with two int parameter called 
21
Overloaded function with one int parameter called 
10

Time Complexity: O(1)

Auxiliary Space: O(1)

Problem

Suppose you have a JsonDocument, named doc, and you want to print the value "myValue".

If you do this:

Serial.println(doc["myValue"]);

you’ll get the following compilation error:

call of overloaded 'println(ArduinoJson6101_00000::enable_if<true, ArduinoJson6101_00000::MemberProxy<ArduinoJson6101_00000::JsonDocument&, const char*> >::type)' is ambiguous

Quite scary, right?

Explanation

It’s not that complicated. The compiler tells us that we passed some obscure type to Serial.println() and that he didn’t know which overload of println() to choose.

What’s an overload, you ask? When the same function has several versions with different parameters, we call each version an “overload.” In our case, Serial.println() has 12 overloads:

size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);

As you can see, there is no overload for JsonVariant, so how can the compiler decide which one to use?

Solution

There are two ways to solve the ambiguity:

1. You can explicitly cast the JsonVariant to type supported by println()
2. You can avoid println()

The first solution only works if you know the type of the value. For example, if you know that "myValue" contains an integer, you can write:

Serial.println(doc["myValue"].as<int>());

However, if you don’t know the type, you must use the second solution: replace println() with serializeJson():

serializeJson(doc["myValue"], Serial);

What about Printable?

As you saw above, println() has an overload that takes a Printable, an interface that allows supporting custom types. If JsonVariant implemented Printable, the call to println() would not be ambiguous. So why ArduinoJson doesn’t do that?

Unfortunately, implementing Printable makes the code of the library significantly bigger, and having a small footprint is one of the primary goals of ArduinoJson. Early versions supported Printable, but this feature was removed because it was not worth the extra bytes.

Causes[edit | edit source]

Arguments in a function call do not match those in any function declaration[edit | edit source]

For example, a function, «foo», is called from inside main with an argument that is not a perfect match for any of the currently existing implementations of «foo».

void foo(int x);
void foo(double x);

int main () {
   long x = 5000;
   foo(x);
   ...

Solution 1: Cast the argument to match a declaration

int main () {
   long x = 5000;
   foo((int)x);

Solution 2: Create a new, overloaded version of the called function to match the arguments

void foo(int x);
void foo(double x);
void foo(long x);

int main () {
   long x = 5000;
   foo(x);

The same function is defined more than once[edit | edit source]

Solution 1: Look for a misspelled or duplicate function definition/declaration

Solution 2: Make sure you’re not using a function name defined in the standard library

template <typename T>
void swap(T &a, T &b) {  // error, "swap" is defined by the C++ standard library
   T tmp = a;
   a = b;
   b = tmp;
}

// Possible Fix
template <typename T>
void Swap(T &a, T &b) {  // Capitalized the first letter
   T tmp = a;
   a = b;
   b = tmp;
}

Notes[edit | edit source]

• Message found in GCC versions 3.2.3, 4.5.1

#include <iostream>
#include <string>
using std::cout;
using std::string;
template<class C>
C min(C a,C b) {
return a<b?a:b;
}
int main()
{
string a="first string";
string b="second string";
cout<<"minimum string is: "<<min(a,b)<<'n';
int c=3,d=5;
cout<<"minimum number is: "<<min(c,d)<<'n';
double e{3.3},f{6.6};
cout<<"minimum number is: "<<min(e,f)<<'n';
char g{'a'},h{'b'};
cout<<"minimum number is: "<<min(g,h)<<'n';
return 0;
}

13  [Error] call of overloaded 'min(std::string&, std::string&)' is ambiguous

6   [Note] C min(C, C) [with C = std::basic_string<char>]

Решение

main.cpp:13:34: error: call to 'min' is ambiguous
cout<<"minimum string is: "<<min(a,b)<<'n';
^~~
/usr/include/c++/v1/algorithm:2579:1: note: candidate function [with _Tp = std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >]
min(const _Tp& __a, const _Tp& __b)
^
main.cpp:6:3: note: candidate function [with C = std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >]
C min(C a,C b) {
^

Другие решения

Let’s say we want to write a templated function with a specialized version for integral types and a generic version for all other types. My naive attempt looked like this and resulted in a call of overloaded ‘func(int)’ is ambiguous compiler error:

#include <iostream>
#include <type_traits>

template<typename T>
void func(const T& x) {
    std::cout << "generic: " << x << std::endl;
}

template<typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
void func(const T& x) {
    std::cout << "specialized: " << x << std::endl;
}

int main() {
    func(5);
    return 0;
}

Adding the negated template condition to the generic function declaration fixes it:

template<typename T, typename std::enable_if<!std::is_integral<T>::value>::type* = nullptr>
...

But it’s somewhat redundant and becomes annoying if we want to add another overload, for example, for floating point types. Then the generic version becomes:

template<typename T, 
    typename std::enable_if<!std::is_integral<T>::value>::type* = nullptr,
    typename std::enable_if<!std::is_floating_point<T>::value>::type* = nullptr,
>
...

Is there a cleaner way to write the generic version without having to duplicate all specialized declarations?