What are the situations where overloading function can be an ambiguity?

Answer 1

***Function Overloading and Ambiguity ****

We know that compiler will decide which function to be invoked among the overloaded functions. When the compiler could not choose a function between two or more overloaded functions, the situation is called as an ambiguity in function overloading.

When the program contains ambiguity, the compiler will not compile the program.

The main cause of ambiguity in the program

· Type conversion

· Functions with default arguments

· Functions with pass by reference

Type conversion

#include

using namespace std;

#include

void fun(int i)

{ cout << i;}

void fun(float f)

{ cout << f;}

int main()

{

fun(10);

fun(10.2);

return 0;

}

In this example type conversion creates ambiguity. fun(10) will refer the first function.

We think the value 10.2 is floating point value. So fun(10.2) will refer the second function. But fun(10.2) will refer which function? It could not refer any function. Because 10.2 will be treated as double data type by the compiler. (In c++ all the floating point values are converted by the compiler as double data type.) This is type conversion of float to double. So now compiler could not search the function fun with double data type.

So the compiler will give error message call of overloaded 'fun(double)' is ambiguous.

This example clearly rises the ambiguity in the program because of the type conversion.

Functions with default arguments

#include

using namespace std;

#include

void fun(int i)

{ cout << i;}

void fun(int i, int j=8)

{ cout << i << j;}

int main()

{

fun(10);

fun(10.2f);

return 0;

}

This program will give error message that overloaded 'fun(int)' is ambiguous. Because the fun(int i, int j =8) is a function with default arguments. It can be called in two ways. They are

(i) function with one argument.

fun(2) now the value of i is 2 and j is 8 (8 is the default value).

(ii) function with two arguments fun(5,6). So i is 5 and j is 6.

fun(int i) is a function with one argument. It should be invoked with one argument. So

when we call a function with 1 argument the compiler could not select among the two functions fun(int i) and fun(int i, int j=8).

This example clearly illustrates the ambiguity in the program because of function with default arguments.

Function with reference parameter

#include

using namespace std;

#include

void fun(int i)

{ cout << i;}

void fun(int &i)

{cout <

int main()

{

fun(10);

return 0;

}

This program will show the error message call of overloaded 'fun(int)' is ambiguous.

First fun(int) takes one integer argument and second function fun(int &) takes a reference parameter. In this case, compilers do not know which function is intended by the user when it is called. Because there is no syntactical difference in calling the function between the function with single argument and function with single reference parameter.

So compiler could not decide which function should be invoked when it is called. So this leads ambiguity in the program.

Answer 2

You create ambiguity when two functions share the same signature or the signatures are covariant. For instance: void foo (unsigned int) has the same signature as void foo (size_t), because size_t is implemented as an alias (a typedef) for unsigned int. Such ambiguities can be avoided by placing the functions in separate namespaces. However, you need to be mindful that polluting the global namespace by importing both names will re-introduce the ambiguity. A better solution is to give the functions different names.

Answer 3

Ambiguity in function overloading can only exist at compile time. Ambiguity occurs when two or more functions share the same signature or prototype. That is, the number and type of arguments (including any use of the const keyword) are intrinsically the same. Ambiguity can also occur when calling a function overload with types that do not match any of the existing signatures. You must either provide a suitable implementation or cast the types to suit an appropriate existing signature.