overloading vs. overriding

Overloading

• C++ allows you to specify more than one definition for a function name or an operator in the same scope.
  • same name
  • different arguments
  • different definition

• When you call an overloaded function or operator, the compiler determines the most appropriate definition to use.
• The process of selecting the most appropriate overloaded function or operator is called overload resolution.

function overloading

You can have multiple definitions for the same function name in the same scope.

• The definition of the function must differ from each other by the types and/or the number of arguments in the argument list.

• You can not overload function declarations that differ only by return type.

• example

#include <iostream>
using namespace std;

class printData 
{
   public:
      void print(int i) {
        cout << "Printing int: " << i << endl;
      }
      void print(double  f) {
        cout << "Printing float: " << f << endl;
      }
      void print(char* c) {
        cout << "Printing character: " << c << endl;
      }
};

int main(void)
{
   printData pd;
   // Call print to print integer
   pd.print(5);
   // Call print to print float
   pd.print(500.263);
   // Call print to print character
   pd.print("Hello C++");

   return 0;
}

The output is

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

Operator overloading

#include <iostream>
using namespace std;
class Box
{
   public:
      double getVolume(void) {
         return length * breadth * height;
      }
      void setLength( double len ) {
          length = len;
      }
      void setBreadth( double bre ) {
          breadth = bre;
      }
      void setHeight( double hei ) {
          height = hei;
      }
      // Overload + operator to add two Box objects.
      Box operator+(const Box& b) {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
   private:
      double length;      // Length of a box
      double breadth;     // Breadth of a box
      double height;      // Height of a box
};
// Main function for the program
int main( ) {
   Box Box1;                // Declare Box1 of type Box
   Box Box2;                // Declare Box2 of type Box
   Box Box3;                // Declare Box3 of type Box
   double volume = 0.0;     // Store the volume of a box here

   // box 1 specification
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);

   // box 2 specification
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);

   // volume of box 1
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;

   // volume of box 2
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // Add two object as follows:
   Box3 = Box1 + Box2;

   // volume of box 3
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;

   return 0;
}

Output

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

• Overloadable opertors

• \ represents to "|" in the above table

function overriding

• Definition
  If you create an object of derived class and write code to access that member function then, the member function in derived class is only invoked, i.e., the member function of derived class overrides the member function of base class. This feature in C++ programming is known as function overriding.

  • Function overriding is how polymorphism works in C++. You override a function to change the behavior of that function in a derived class. In this way, a base class provides interface, and the derived class provides implementation.

• Requirement

  • Inheritance should be there. Function overriding cannot be done within a class. For this we require a derived class and a base class.
  • Function that is redefined must have exactly the same declaration in both base and derived class, that means same name, same return type and same parameter list.

• Example

  class Base {
  public:
    void show() {
      cout << "Base class\n";
    }
  };
  class Derived:public Base {
  public:
    void show() {
      cout << "Derived Class\n";
    }
  };
  

• calling the overrided function using Base class and Derived class object.

  int main() {
    Base b;       //Base class object
    Derived d;     //Derived class object
    b.show();     //Early Binding Ocuurs
    d.show();
    return 0;
  }
  

  output

  Base class
  Derived Class
  

• calling the overrided function using Base class's pointer to hold Derived class's object.

  int main() {
    Base *b = new Derived();       
    b->show();     //Early Binding Ocuurs
    return 0;
  }
  

  output

  Base class
  

• Define show() as a virtual function in the base class:

  class Base {
  public:
    virtual void show() {
      cout << "Base class\n";
    }
  };
  

  Then the above output is:

  Derived Class