C++ Program to Perform operator overloading on unary operator decrement -- with no return type

In this example program, the decrement -- operator is overloaded. i.e., decrease the value of a data member by 1 if the -- operator operates on an object.

What is operator overloading?

Polymorphism: Polymorphism (or operator overloading) is a manner in which OO systems allow the same operator name or symbol to be used for multiple operations. That is, it allows the operator symbol or name to be bound to more than one implementation of the operator.
Before practicing the concept of operator overloading, you should have to know about the below topics.

Classes and Objects in C++

A class is a blueprint for the object.

We can think of a class as a sketch (prototype) of a house. It contains all the details about the floors, doors, windows, etc. Based on these descriptions we build the house. House is the object.

class className {
   // some data
   // some functions
};

A class is defined in C++ using the keyword class followed by the name of the class.
The body of the class is defined inside the curly brackets and terminated by a semicolon at the end.

C++ Objects

When a class is defined, only the specification for the object is defined; no memory or storage is allocated.
To use the data and access functions defined in the class, we need to create objects.
className objectVariableName;

// sample function
void sampleFunction() {
    // create objects
    Room room1, room2;
}

int main(){
    // create objects 
    Room room3, room4;
}

Here, two objects room1 and room2 of the Room class are created in sampleFunction(). Similarly, the objects room3 and room4 are created in the main().
As we can see, we can create objects of a class in any function of the program. We can also create objects of a class within the class itself, or in other classes.

C++ constructors

A constructor is a special type of member function that is called automatically when an object is created.
In C++, a constructor has the same name as that of the class and it does not have a return type.
class  Wall {
  public:
    // create a constructor
    Wall() {
      // code
    }
};

Here, the function Wall() is a constructor of the class Wall. Notice that the constructor
•    has the same name as the class,
•    does not have a return type, and
•    is public

Operator overloading in C++

In C++, we can change the way operators work for user-defined types like objects and structures. This is known as operator overloading.
 

class className {
    ... .. ...
    public
       returnType operator symbol (arguments) {
           ... .. ...
       } 
    ... .. ...
};

Here,
•    returnType is the return type of the function.
•    operator is a keyword.
•    symbol is the operator we want to overload. Like: +, <, -, ++, etc.
•    arguments are the arguments passed to the function

C++ program to Overload Prefix -- decrement Operator with no return type

Create a class check and declare a variable i in private 
The class members declared as private can be accessed only by the member functions inside the class.
A constructor check () is created in public and set the value of variable i to 0. Here, we are using the operator -- to work in a way that increases the value of the variable by 1.
 

Void operator --()
{ --i; }

A function to display the value of the variable is defined.

Void Display()
{ cout << “i=” << i << endl; }

Within the main function body, create an object obj for the class check. Display the initial value of the data memberfor object obj.
Involke the operator function void operator --( )
--obj; 

Display the value of the data member after the operation
obj.Display();

Algorithm

Step 1:  Call the header file iostream.

Step 2: Use the namespace std.

Step 3: Create a class check with a private variable i

Step 4: create a constructor check( ); set the value of i to 0

Step 5: Define the function for operator overloading 

Step 6: Define function display for displaying the data member.

Step 7: call the function main

Step 8: create an object obj for the class check

Step 9: Display the value of the data member by accessing the function with the object

Step 10: call the function for operator overloading

Step 11: Display the data member after the operation by calling the display function.

Step 12: Exit 

C++ Source Code

                                          #include <iostream>
using namespace std;

class Check
{
    private:
       int i;
    public:
       Check(): i(0) {  }
       void operator --() 
          { --i; }
       void Display() 
          { cout << "i=" << i << endl; }
};

int main()
{
    Check obj;

    // Displays the value of data member i for object obj
    obj.Display();

    // Invokes operator function void operator --( )
    --obj; 
  
    // Displays the value of data member i for object obj
    obj.Display();

    return 0;
}
                                      

OUTPUT

i=0
i=-1