How function double,int work? c++ - c++

Question

Could you explain me how these functions work?
double f(int i)
{
cout<<"a";
return 1;
}
int f(double i)
{
cout<<"b";
return 1;
}
For:
f(f(f(1)));
In my opinion the result should be: aaa
but it isaba
And same situation with f(f(f(1.1)));
I think there should be aab but there is bab

Answer 1

When you return from a function, the type of the return value is determined from the function prototype, not what it's written as-is. If the type doesn't match, it'll be implicitly converted to the correct type. So this example function:
double foo(void) { return 1; }
Actually returns double(1), or equivalently, 1.0. It does not return an int because 1 is int. It does, however, convert your int to a double value to match the function's return value type as declared.
So coming to your question, the innermost function called is double f(int), and the second function called is int f(double), and the outermost function called is double f(int). This matched the output you see: aba.
f( f( f(1) ) );
↑ ↑ ↑
| | calls double f(int)
| calls int f(double)
calls double f(int)

Answer 2

The way the compiler reads your f(f(f(1))); function is from the inside out. Let me elaborate, the compiler sees f(1); and it looks for a function called f that takes an int as an argument so that would be:
double f(int i)
{
cout<<"a";
return 1;
}
Now, once your function executes, it returns a double, hence the second f takes in a double -> which calls your next function that takes double
int f(double i)
{
cout<<"b";
return 1;
}
Following the logic explained above, we have arrived at the last/outer layer of your triple f question. Now the compiler has an int and is looking for a function called f that takes int -> which is your first declared function.
And that is why you get aba as a result.

Answer 3

prior to your first use of std::cout in your code, add the line
std::cout << std::fixed;
This changes the output (of parameter i) quite a bit by causing int and double to show their 'true colors'. Perhaps this will illustrates what is happening.
Example:
double f(int i)
{
std::cout << " a" << std::setw(9) << i << " " << std::flush;
return 1;
}
int f(double i)
{
std::cout << " b" << std::setw(9) << i << " " << std::flush;
return 1;
}
int main(int , char** )
{
std::cout << std::fixed << "\n";
f(f(f(1)));
std::cout << std::endl;
f(f(f(1.0)));
return 0;
}
Generates output:
a 1 b 1.000000 a 1
b 1.000000 a 1 b 1.000000
The returned value (always integer 1) is implicitly transformed to the return type, which is different for the two functions.
Which function is invoked is determined by the signature of the function, i.e. the parameters actual type. This also illustrates that the return type is not part of the signature.