Function overloading problems in inheritance - c++

Question

When I am learning function overloading, I know that a function differs from another by its name and number of parameters. So I try similar things for inheritance.
I declare a function without parameters in base class, and declare another function with the same name but different number of parameters in derived class.
From my function overloading and inheritance knowledge, the main code should work, but it turns out that the function in the base class is not inherited and I have to explicitly call it.
Could anyone explain to me about this behavior? Shouldn't breathe() be inherited by the derived class? Thanks a lot.
#include <iostream>
using namespace std;
//base class
class animal {
public:
void breathe(){
cout << "animal breathe" << endl;
}
};
//derived class
class fish: public animal {
public:
void breathe(int a){
cout << "fish bubble" << endl;
}
};
int main() {
fish fh;
// correct
fh.breathe(1);
// correct
fh.animal::breathe();
// error
fh.breathe();
return 0;
}

Answer 1

Google method hiding. Add
using animal::breathe;
To class fish

Answer 2

fh.breathe();
is an error message, because there is another breathe() defined in the derived class, which effectively hides the breathe() defined in the base class.
You can correct this by adding the statement:
using animal::breathe;
in the class fish.
Modified fish class:
class fish: public animal {
public:
//Make sure to make this statement public
//otherwise animal::breathe will not be accessible
//to the object of fish.
using animal::breathe;
void breathe(int a){
cout << "fish bubble" << endl;
}
};

Answer 3

When you declare a function in derived class with same name as in base class, you are hiding the base class function. To bring base class function within derived class scope, you have to explicitly specify it using using animal::breath like so:
class fish: public animal {
public:
using animal::breath;
void breathe(int a){
cout << "fish bubble" << endl;
}
};

Answer 4

n3376 10.2/3-4-5
The lookup set for f in C, called S(f, C), consists of two component
sets: the declaration set, a set of members named f; and the subobject
set, a set of subobjects where declarations of these members (possibly
including using-declarations) were found. In the declaration set,
using-declarations are replaced by the members they designate, and
type declarations (including injected-class-names) are replaced by the
types they designate. S(f, C) is calculated as follows:
> If C contains a declaration of the name f, the declaration set
contains every declaration of f declared in C that satisfies the
requirements of the language construct in which the lookup occurs. If
the resulting declaration set is not empty, the subobject set contains
C itself, and calculation is complete.
> Otherwise (i.e., C does not contain a declaration of f or the
resulting declaration set is empty), S(f, C) is initially empty. If C
has base classes, calculate the lookup set for f in each direct base
class subobject B i , and merge each such lookup set S(f, B i ) in
turn into S(f, C).
In your case, there is function breathe in class fish, compiler will not trying to found breathe in base class. You can resolve this by explicitly inserting using declaration in derived class.
using animal::breathe;
Now, compiler has two variant and due overloading resolution animal::breathe will be called.