Argument Matching
Overloaded functions are selected for the best match of function declarations in the current scope to the arguments supplied in the function call. If a suitable function is found, that function is called. "Suitable" in this context means one of the following:

An exact match was found.

A trivial conversion was performed.

An integral promotion was performed.

A standard conversion to the desired argument type exists.

A userdefined conversion (either conversion operator or constructor) to the desired argument type exists.

Arguments represented by an ellipsis were found.
The compiler creates a set of candidate functions for each argument. Candidate functions are functions in which the actual argument in that position can be converted to the type of the formal argument.
A set of "best matching functions" is built for each argument, and the selected function is the intersection of all the sets. If the intersection contains more than one function, the overloading is ambiguous and generates an error. The function that is eventually selected is always a better match than every other function in the group for at least one argument. If this is not the case (if there is no clear winner), the function call generates an error.
Consider the following declarations (the functions are marked Variant 1, Variant 2, and Variant 3, for identification in the following discussion):
Fraction &Add( Fraction &f, long l ); // Variant 1 Fraction &Add( long l, Fraction &f ); // Variant 2 Fraction &Add( Fraction &f, Fraction &f ); // Variant 3 Fraction F1, F2;
Consider the following statement:
F1 = Add( F2, 23 );
The preceding statement builds two sets:
Set 1: Candidate Functions That Have First Argument of Type Fraction  Set 2: Candidate Functions Whose Second Argument Can Be Converted to Type int 

Variant 1  Variant 1 (int can be converted to long using a standard conversion) 
Variant 3 

Functions in Set 2 are functions for which there are implicit conversions from actual parameter type to formal parameter type, and among such functions there is a function for which the "cost" of converting the actual parameter type to its formal parameter type is the smallest.
The intersection of these two sets is Variant 1. An example of an ambiguous function call is:
F1 = Add( 3, 6 );
The preceding function call builds the following sets:
Set 1: Candidate Functions That Have First Argument of Type int  Set 2: Candidate Functions That Have Second Argument of Type int 

Variant 2 (int can be converted to long using a standard conversion)  Variant 1 (int can be converted to long using a standard conversion) 
Note that the intersection between these two sets is empty. Therefore, the compiler generates an error message.
For argument matching, a function with n default arguments is treated as n+1 separate functions, each with a different number of arguments.
The ellipsis (...) acts as a wildcard; it matches any actual argument. This can lead to many ambiguous sets, if you do not design your overloaded function sets with extreme care.
Note 

Ambiguity of overloaded functions cannot be determined until a function call is encountered. At that point, the sets are built for each argument in the function call, and you can determine whether an unambiguous overload exists. This means that ambiguities can remain in your code until they are evoked by a particular function call. 