What is function overloading and operator overloading?

The C++ compiler identifies a function by its signature (function signature). The function signature is broken down into the following components in that order.

<function label or name>


The parameter list is further defined as parameter label or name. If the order of the parameters (datatype name) changes, even if the function name/label does not change, the signature is considered unique. So, in C++, it is conceivable to have many different functions/methods with exact same label name (for example Function1) so long as the entire signature is considered unique. So, changing the number of parameters, their data types, the order of them, or any combination of these can change the function signature.
Important Note: Changing the return type ALONE is NOT considered change in signature.

Now, answering the actual question of overloading function vs. operator:
Function Overloading: When you define many different functions (unique signatures) which have the exact label name, it is function overloading. For example, void Function_Foo();
void Function_Foo(int);        // Overloaded
void Function_Foo(int, int);  // Overloaded
int Function_Foo();    // Error - function redefined (because only return type is different)

Operator Overloading: In C++, basic operators are also considered functions at a compiler level. So, when you define a different operation for an operator by changing the standard parameter list, it is operator overloading. For example
MyClass operator + (MyClass& cls); //Add the data members of two instances of the same class

... etc.

  1 User has rated as useful.

  

Login to rate this answer.

Here are some examples
1) Function overloading

class FuncOver {
public:
      // Constructors can also be overloaded.
      FuncOver();

      // Overloaded constructor.
      FuncOver(int i);

      // Functions example.
      int sum(int a, int b);

      int sum(float a, float b);
};

Operator overloading example...

class MyInt {
public:
       // + operator overloaded.
       int operator+(MyInt b);
private:
    int a;
};

Overloading basically refers to the provision of second of subsequent version of the same function or operator based on different parameters.

In terms of functions each different version of the function takes different parameters. Thus allowing for the same logic to be executed in different contexts

In terms of operators, overloading refers to the redefinition of the affect of an operators on different class types. So that we could define a sence of addition or greater than for a handcoded class