Overloading in Derived Classes

Yes, if a function is overloaded in a base class, you can also overload it in a derived class. However, there's a subtle point to be aware of: the overloads in the derived class will hide the overloads in the base class, even if they have different parameters. This is due to a C++ feature called "name hiding".

Consider this example:

1#include <iostream>
2#include <string>
3
4class Base {
5public:
6  void Print(int x) {
7    std::cout << "Base: Print(int)\n";
8  }
9
10  void Print(double x) {
11    std::cout << "Base: Print(double)\n";
12  }
13};
14
15class Derived : public Base {
16public:
17  void Print(std::string x) {
18    std::cout << "Derived: Print(string)\n";
19  }
20};
21
22int main() {
23  Derived obj;
24  obj.Print(10);
25  obj.Print(10.0);
26
27  // calls Derived::Print(string)
28  obj.Print(std::string("abc"));
29}

1error: no matching function for call to 'Derived::Print(int)'
2error: no matching function for call to 'Derived::Print(double)'

In this code, even though Base has overloads of Print that take int and double, these are hidden by the Print overload in Derived. When you call Print on a Derived object, the compiler only considers the overloads in Derived.

To make the overloads from Base available in Derived, you need to use the using keyword:

1class Derived : public Base {
2 public:
3  // bring all overloads of Print from
4  // Base into scope
5  using Base::Print;  
6
7  void Print(std::string x) {
8    std::cout << "Derived: Print(string)\n";
9  }
10};

Now, when you call Print on a Derived object, the compiler will consider all overloads from both Derived and Base:

1int main() {
2  Derived obj;
3
4  // calls Base::Print(int)
5  obj.Print(10);
6  
7  // calls Base::Print(double)
8  obj.Print(10.0);
9  
10  // calls Derived::Print(string)
11  obj.Print(std::string("abc"));
12}

1Base: Print(int)
2Base: Print(double)
3Derived: Print(string)

The using Base::Print; statement brings all overloads of Print from Base into the scope of Derived, essentially "unhiding" them.

This is a common pitfall when overloading functions in derived classes. If you want the base class overloads to be available, remember to use the using keyword. Otherwise, the derived class overloads will hide the base class overloads, which can lead to unexpected behavior or compilation errors.