The purpose of overloaded operators:
The operations object for predefined operators in C + + is limited to basic built-in data types
Most of the time we need to do similar operations on our similar types, and this time we need to redefine the operators and give them new content
Give them new functionality to meet their own needs
The essence of operator overloading is function overloading or function polymorphism. Operator overloading is a form of C + + polymorphism. The goal is to allow people to perform different basic operations with a function of the same name.
The basic format is as follows:
< return type descriptor > operator < operator symbol > (< parameter table >)
{
< function body >
}
One use case is as follows:
We construct a time class to realize the addition of time to time and to find the current time.
#include <iostream>
using namespace std;
Class Cmytime {
private:
int m_hours;
int m_minutes;
Public:
//constructor and destructor
Cmytime ();
Cmytime (int h, int m = 0);
~cmytime ();
void addmin (int m); The addition of minutes
//void addhr (int h); The hours are added
//void Reset (int h = 0, int m = 0); Reset
cmytime* Sum (const cmytime *t) const; Sum of Time: Add Method 1
cmytime operator+ (const cmytime t) const;//Time Add: Add mode 2
//Time Add way 3 pointer add:
void Show () const; Show Results
};
We can implement a function by calling a function with a time object and adding another time object.
cmytime* cmytime::sum (const cmytime *t) const {
cmytime* Sum = new Cmytime (); Property in the class
sum->m_minutes = T->m_minutes + this->m_minutes;
Sum->m_hours = t->m_hours + this->m_hours + sum->m_minutes/60;
Sum->m_minutes%=;
return sum;
}
The method is invoked as follows:
The time used to add
cmytime* planningtime = new Cmytime (); Default time
cmytime* coding = new Cmytime (2);
cmytime* fixing = new Cmytime (5);
Planningtime->show ();
Coding->show ();
Fixing->show ();
Time sum
cmytime* total = new Cmytime ();
Total = coding->sum (fixing); Add function call
cout << "After the sum: " << Endl;
Total->show ();
In the above example, the time object coding by calling the custom add function sum to add the time object fixing to it
It would be a bit cumbersome to use.
We can add it by overloading the operator.
The following methods are used: first overload the operator with the following methods
Cmytime cmytime::operator+ (const cmytime t) const
{
cmytime sum;
Sum.m_minutes = t.m_minutes + this->m_minutes;
Sum.m_hours = t.m_hours + this->m_hours + sum.m_minutes/60;
Sum.m_minutes%=;
return sum;
}
Here's the point: we can add two class objects using a method like integer addition
Time sum: Add Way 2
cmytime planning2;
Cmytime coding2 (2,40);
Cmytime fixing2 (5,55);
Cmytime Sumtime;
cout << Endl << Endl;
cout << "After the sum of Method 2: " << Endl;
Sumtime = Coding2 + fixing2; After overloading, the plus sign can add two Cmytime class objects directly
sumtime.show ();
This is the simplest example and there will be more ways and examples to introduce