A call to an overloaded function is resolved to a particular
instance of the function through a process called argument matching. Argument matching involves
comparing the actual arguments of the call with the formal arguments of each
declared instance of the function.
There are three possible cases, a function call may result in
:
A match : A match is found for the
function call.
No match : No match is found for the
function call.
Ambiguous Match : More than one defined
instance match for a function call.
The compiler tries to find the best possible match for the
function call.
Search for an Exact Match
If the types and number of the actual arguments exactly match
the types and number of formal arguments, the compiler invokes that particular
instance. For example,
Output Screen :
Function 1 called
Reason : The actual argument (here 0)
is int type.
A Match through Promotion
If no exact match is found, an attempt is made to achieve a
match through type promotion of the actual argument.
Integral Promotion : Conversion
of integer types (char, short, enumerator) into int
(if all values of type can be represented by int) or unsigned int
(if all values can’t be represented by int) is called integral promotion.
So, if there is any overloaded function with int formal
type, all smaller integer type (char, short, enumerator)
are converted to int if a perfect match is not found. (Note: In function
overloading, the conversion of smaller integer datatypes to int is
favoured over their conversions to some larger types like long int
or long long int.)
For example,
Output Screen :
Function 1 called
Reason : ‘a’ is of type char and thus promoted to type int after no exact match is found thereby matching f(int).
A match through conversions following Standard Conversion Rules of C++
As C++ puts it, it’s possible to convert any datatype to the
other if we are fine with loss of information in some cases. Following this
rule, the actual argument of any type can be converted to any other type to
match the formal arguments. Here the program may show warnings regarding loss
of information, but it will not be counted as an error. This last step is used
when the matching through the first two steps has failed.
The following program makes the point clearer.
Let us try to understand the steps taken by the compiler one
by one.
Step 1. When the compiler executes the
statement f(‘a’); it first tries to find a
function named f() that has a character type
formal argument. As no such function exists, the compiler takes the next step.
Step 2. As char is a smaller
type than int, compiler tries to find any function named f() with int formal type so that it may
match the function using integral promotion. It fails again and takes the next
step.
Step 3. It then goes for a standard
conversion from char to short (in this case) and thus calls the
function.
But, there is an associated problem with this type conversion.
As any type can be converted to any other type, there is a possibility of
multiple matches. If the compiler encounters such a condition where the actual
argument type can be changed to match the formal types of more than one
function, it is flagged as an error.
Look at the following program.
Output Screen :
[error] call of overloaded
f(char) is ambiguous
[note] candidates are
[note] void f(double)
[note] void f(short int)
The compiler goes to
step 3 as before. But while converting char, it finds two possible matches. It
can convert char to double and also to short int. This results in an error as
shown in the output.
If you find something wrong or if you
wish to add some information in this article, feel free to comment on this post
or contact us at coding.nkcoder@gmail.com.
Which topics you want an article on? Comment down on this
post.
Do not stop here. Read all articles related to C++ here.
If you want to contribute any article for the website, feel
free to share it on coding.nkcoder@gmail.com. We will
publish it on the website with your name.
Post a Comment