Understanding scope with inheritance in C++ - c++

Question

I'm testing my understanding of inheritance in C++ and was reading through some example code. Based on the program output, it seems to me that the double add() and int add() functions have different scope, and instead of calling the double add() function with argument 10.5, there is an implicit type conversion from double to int (which is always truncated) and the function int add() is called instead. The type conversion would explain why the output is 11 11.
My questions are as follows:
What is the scope of inherited functions that are overloaded?
When, if ever, is a type conversion from double to int invalid (i.e. would instead result in a compile-time error)?
Where can I read more about the nuances of namespaces/scope with inheritance in C++?
#include <iostream>
using namespace std;
class One {
public:
double add(double x) { return x + 0.1; }
};
class Two : public One {
public:
int add(int x) { return x + 1; }
};
int main(int argc, char *argv[]) {
Two obj;
cout << obj.add(10) << " " << obj.add(10.5) << endl;
return 0;
}

Answer 1

The declaration of add as int add(int x) { return x + 1; } hides any other definitions of add from outer scopes, this is the same behaviour as shadowing of variables in nested blocks in a function.
Name lookup always finds a name in a scope before going on to potential overload resolution amongst multiple occurrences of that name in the same scope; obj.add(10.5) finds Two::add() and so does not go on to check outer scopes.
You can redeclare the functions from outer scopes in Two with using One::add;
On the conversion topic; a double argument always matches an int parameter. It can be invalid if the double is out of range for int but that is runtime undefined behaviour (no diagnostic required).
This topic is covered in C++ FAQ , you could also check the Name Lookup article on cppreference.

Answer 2

Overloading does not work with inheritance in C++:
Overloading doesn’t work for derived class in C++ programming
language. There is no overload resolution between Base and Derived.
The compiler looks into the scope of Derived, finds the single
function “double f(double)” and calls it. It never disturbs with the
(enclosing) scope of Base. In C++, there is no overloading across
scopes – derived class scopes are not an exception to this general
rule
The example they used had double f(double) in the derived class.
https://www.geeksforgeeks.org/does-overloading-work-with-inheritance/
To fix this, the class would have to be redesigned. I can't give any specific feedback as to how to change it as the class is very generic.

Answer 3

In addition to the answers above, I would like to add that you can avoid this issue of overloading by creating a template for One::add() which will allow it to accept both integers and doubles, and then let class Two inherite it.
#include <iostream>
using namespace std;
class One {
public:
template <typename T> //Template allows us to create a function template whose functionality can be adapted to more than one type or class without repeating the entire code for each type.
double add(T x)
{
if (floor(x) == x) //Check if x is integer
return x + 1;
else
{
return x + 0.1;
}
}
};
class Two : public One {
public:
//No need for overloading add() here because in Class One, add() function will accept integers and doubles
};
int main(int argc, char* argv[]) {
Two obj;
cout << obj.add(10) << " " << obj.add(10.5) << endl;
return 0;
}