Scribd
Upload
90 views

Operater Overloading C

The document discusses overloading relational, input/output, and increment/decrement operators in C++. It provides examples of overloading the less than operator (<) to compare Distance objects, overloading the insertion (<<) and extraction (>>) operators to input and output Distance objects, and overloading the prefix and postfix increment operators (++). Overloading operators allows user-defined types to be used with operators in a natural way.

Uploaded by

Syed Ijlal Hussain
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
90 views

Operater Overloading C

The document discusses overloading relational, input/output, and increment/decrement operators in C++. It provides examples of overloading the less than operator (<) to compare Distance objects, overloading the insertion (<<) and extraction (>>) operators to input and output Distance objects, and overloading the prefix and postfix increment operators (++). Overloading operators allows user-defined types to be used with operators in a natural way.

Uploaded by

Syed Ijlal Hussain
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 6

Relational Operators Overloading in C++

There are various relational operators supported by C++ language like (<, >, <=, >=,
==, etc.) which can be used to compare C++ built-in data types.
You can overload any of these operators, which can be used to compare the objects of
a class.
Following example explains how a < operator can be overloaded and similar way you
can overload other relational operators.
#include <iostream>
using namespace std;

class Distance {
private:
int feet; // 0 to infinite
int inches; // 0 to 12

public:
// required constructors
Distance() {
feet = 0;
inches = 0;
}
Distance(int f, int i) {
feet = f;
inches = i;
}

// method to display distance


void displayDistance() {
cout << "F: " << feet << " I:" << inches <<endl;
}

// overloaded minus (-) operator


Distance operator- () {
feet = -feet;
inches = -inches;
return Distance(feet, inches);
}

// overloaded < operator


bool operator <(const Distance& d) {
if(feet < d.feet) {
return true;
}
if(feet == d.feet && inches < d.inches) {
return true;
}
return false;
}
};

int main() {
Distance D1(11, 10), D2(5, 11);

if( D1 < D2 ) {
cout << "D1 is less than D2 " << endl;
} else {
cout << "D2 is less than D1 " << endl;
}

return 0;
}

When the above code is compiled and executed, it produces the following result −
D2 is less than D1
Input/Output Operators Overloading in C++
C++ is able to input and output the built-in data types using the stream extraction
operator >> and the stream insertion operator <<. The stream insertion and stream
extraction operators also can be overloaded to perform input and output for user-
defined types like an object.
Here, it is important to make operator overloading function a friend of the class
because it would be called without creating an object.
Following example explains how extraction operator >> and insertion operator <<.
#include <iostream>
using namespace std;

class Distance {
private:
int feet; // 0 to infinite
int inches; // 0 to 12

public:
// required constructors
Distance() {
feet = 0;
inches = 0;
}
Distance(int f, int i) {
feet = f;
inches = i;
}
friend ostream &operator<<(ostream &output, const Distance& D
) {
output << "F : " << D.feet << " I : " << D.inches;
return output;
}

friend istream &operator>>( istream &input, Distance& D ) {


input >> D.feet >> D.inches;
return input;
}
};

int main() {
Distance D1(11, 10), D2(5, 11), D3;

cout << "Enter the value of object : " << endl;


cin >> D3;
cout << "First Distance : " << D1 << endl;
cout << "Second Distance :" << D2 << endl;
cout << "Third Distance :" << D3 << endl;
return 0;
}

When the above code is compiled and executed, it produces the following result −
$./a.out
Enter the value of object :
70
10
First Distance : F : 11 I : 10
Second Distance :F : 5 I : 11
Third Distance :F : 70 I : 10

Overloading Increment ++ & Decrement --


The increment (++) and decrement (--) operators are two important unary operators
available in C++.
Following example explain how increment (++) operator can be overloaded for prefix
as well as postfix usage. Similar way, you can overload operator (--).
#include <iostream>
using namespace std;

class Time {
private:
int hours; // 0 to 23
int minutes; // 0 to 59

public:
// required constructors
Time() {
hours = 0;
minutes = 0;
}
Time(int h, int m) {
hours = h;
minutes = m;
}

// method to display time


void displayTime() {
cout << "H: " << hours << " M:" << minutes <<endl;
}

// overloaded prefix ++ operator


Time operator++ () {
++minutes; // increment this object
if(minutes >= 60) {
++hours;
minutes -= 60;
}
return Time(hours, minutes);
}

// overloaded postfix ++ operator


Time operator++( int ) {

// save the orignal value


Time T(hours, minutes);

// increment this object


++minutes;

if(minutes >= 60) {


++hours;
minutes -= 60;
}

// return old original value


return T;
}
};

int main() {
Time T1(11, 59), T2(10,40);

++T1; // increment T1
T1.displayTime(); // display T1
++T1; // increment T1 again
T1.displayTime(); // display T1

T2++; // increment T2
T2.displayTime(); // display T2
T2++; // increment T2 again
T2.displayTime(); // display T2
return 0;
}

When the above code is compiled and executed, it produces the following result −
H: 12 M:0
H: 12 M:1
H: 10 M:41
H: 10 M:42

You might also like