OperatorsOperators
andand
Operators OverloadingOperators Overloading
IntroductionIntroduction
• C++ allows operators to be overloaded specifically for a user-defined class.
• Operator overloading offers a programmer a more elegant and powerful mathematical shorthand for performing operations on object.
• Example: overloading the arithmetic binary operators
Matrix m3;
m3.Add(m1, m2);
Matrix m3 = m1 + m2
Without operator overloading
With operator overloading
class Point{ private: double x, y;
// constructors……….. public: void Add ( const Point &p1, const Point &p2){
x = p1.x + p2.x; y = p1.y + p2.y; } void Subtract ( const Point &p1, const Point &p2){
x = p1.x - p2.x; y = p1.y - p2.y; }};
void main( ){ Point p1 (3.0, 4.0); Point p2 (1.0, 2.0); Point p3, p4;
p3.Add(p1, p2); p4.Subtract(p1. p2);} Note: Without
Overloaded Operator
class Point{ private: double x, y;
// constructors……….. public: //overloaded operator
Point operator + (const Point &p); Point operator - (const Point &p); };
Point Point::operator + (const Point &p) {return Point(x + p.x, y + p.y) }
Point Point::operator - (const Point &p) {return Point(x - p.x, y - p.y) }
void main( ){ Point p1 (3.0, 4.0); Point p2 (1.0, 2.0); Point p3, p4; p3 = p1 + p2; p4 = p1 – p2;}
Note: With Overloaded Operator
The Unary Increment (++) and The Unary Increment (++) and Decrement (--) OperatorDecrement (--) Operator
• Overloaded prefix (++p) operator increments each data member by the value of 1 and then returns the incremented object.
• Overloaded the postfix (p++) increment operator C++ adopts a similar style to the prefix operator, but uses a dummy member function argument of type int.
• For p++, each data member is reduced by the constant 1 before it is returned, thus returning the original object before incrementing occurred.
• A similar procedure is exercised for the prefix and postfix decrement operators.
class Point{ //….. public: Point operator ++ ( );
Point operator ++ (int); Point operator -- ( ); Point operator -- (int); };
Point Point::operator ++ ( ){ x += 1.0; y += 1.0; return Point(x, y); }Point Point::operator ++ (int){ x += 1.0; y += 1.0; return Point(x -1.0, y- 1.0); }Point Point::operator -- ( ){ x -= 1.0; y -= 1.0; return Point(x, y); }Point Point::operator -- (int); { x -= 1.0; y -= 1.0; return Point(x +1.0, y +1.0); }
void main( ){ Point p1 (1.0, 2.0); Point p2 (1.0, 2.0); Point r;
r = ++p1; r = p2++;}
Output: 2, 3
1, 2
(1)
(2)
(1)
(2)
The Relational OperatorsThe Relational Operators
• Relational operators (<, <=, >, >=, == and !=).• Relational operator involving either logical-true or
logical-false.• Provided the Boolean FALSE is denoted by zero
and Boolean TRUE by any non-zero value.• Boolean data type is most conveniently
implemented as an enum.
enum Boolean {FALSE, TRUE
};
Thus, making use of the Boolean type, the overloaded equality operators are implemented as:
Boolean Point::operator == (const Point &p){return (x==p.x && y==p.y && z==p.z) ? TRUE : FALSE;}Boolean Point::operator != (const Point &p){ return (x!=p.x && y!=p.y && z!=p.z) ? TRUE : FALSE;}or, without Boolean type:int Point::operator == (const Point &p){ return (x==p.x && y==p.y && z==p.z);}int Point::operator != (const Point &p){ return (x!=p.x && y!=p.y && z!=p.z);}
class Point{ private: double x, y; public: Point operator = (const Point &p );};
Point Point::operator = (const Point &p ){ x = p.x; y = p.y; cout<<“Overloaded = operator called”; return Point(x, y);}
main( ){ Point p1(3.0, 4.0), p2; p2 = p1; cout << “p2” << p2.x << p2.y << endl; }
Output:
Overloaded = operator called
P2 3 4
Overloaded = operator
Overloaded Assignment Overloaded Assignment OperatorOperator• The operation of the overloaded assignment operator = ( )
function is similar to the operation of the copy constructor.
• The overloaded assignment operator member function definition is:
Which indicates that the two data members of a Point object on the right-hand side of the operator = are directly assigned to the data members of the object on the left-hand side.
• The overloaded = operator member function is passed a const object by reference rather than by value, and a Point object is returned.
• This pointer enables a function to return the object which invokes the overloaded operator member function.
Point Point::operator = (const Point &p ){ x = p.x; y = p.y; cout<<“Overloaded = operator called”; return Point(x, y);}
Non-Member Overloaded Operator Non-Member Overloaded Operator FunctionsFunctions
• Overloaded operator functions can be non-member functions.
class Point{ //……… public: double x, y;};
inline Point operator + (const Point &p1, const Point &p2){ return Point ( p1.x + p2.x, p1.y + p2.y );}inline Point operator - (const Point &p1, const Point &p2){ return Point ( p1.x - p2.x, p1.y - p2.y );}
main( ){ Point p1(3.0, 4.0); Point p2(1.0, 2.0); Point p3, p4, p5;
p3 = p1 + p2; p4 = p1 – p2;}
p3 (4, 6)p4 (2, 2)
Overloading Input Extraction and Overloading Input Extraction and Output Insertion OperatorsOutput Insertion Operators
• cout is an object of class ostream, which provides standard output.
• The insertion (<<) operator is sufficiently overloaded to output all of C++’s integral types so that a user of the ostream class does not have to specify the type of identifier or object when performing output.
• Overloaded insertion and extraction functions must be non-member functions of a user-defined class.
cout << “integer 1 = ” << x << endl;
Typical IOSTREAM.H Header
• If the << operator is not overloaded for a given class, it is the responsibility of the designer to overload the << operator.
class ostream : public ios { //… public:
// Character ostream & operator << (char);
ostream & operator << (signed char);ostream & operator << (unsigned char);// Integer
ostream & operator << (int);ostream & operator << (long);ostream & operator << (double);ostream & operator << (float);
};
class Point{ public: double x, y; //….};
ostream& operator << (ostream &s, const Point &p){ s << “(” << p.x << “,” << p.y << “)” << endl; return s;}istream& operator >> (istream &s, const Point &p){ cout << “Enter x and y coordinates of a point: ”; s >> p.x >> p.y; return s;}
main( ){ Point p(1.0, 2.0), q; cout << p; cin >> q; cout << q;}
Output:
(1, 2)
Enter x and y coordinates of a Point: 4 5
(4, 5)
• Two objects are passed as arguments to the function.
• The first argument is a reference to the output stream which occurs on the left-hand side of the << operator.
• The second argument is a const reference to the object on the right-hand side of the overloaded operator to be chained.
• The function returns a reference to an object of class ostream, which allows the overloaded operator to be chained.
ostream& operator << (ostream &s, const Point &p){ s << “(” << p.x << “,” << p.y << “)” << endl; return s;}
Operators Which Cannot be OverloadedOperators Which Cannot be Overloaded
• C++ is very generous as to which of the available operators can be overloaded.
• However, there are a few exceptions. Operators that cannot be overloaded are:
:: scope resolution
. Direct member access
sizeof size, in bytes, of an object
.* direct member pointer access
?: conditional
Friend and Overloaded Friend and Overloaded OperatorsOperators
class Point{ private: double x, y, z; public: Point(double x_arg, double y_arg, double z_arg = 0.0) : x(x_arg), y(y_arg), z(z_arg){} friend Point operator + (const Point &p1, const Point &p2); };
inline Point operator + (const Point &p1, const Point &p2){ return Point(p1.x + p2.x, p1.y+p2.y, p1.z+p2.z); }
void main( ){ Point p (1.0,1.0); Point q (-1.0,-1.0); Point r = p + q; }
Friend also can defined as inline
class Complex{ private: double re, im; public: Complex (double r, double i); friend Complex operator + (const Complex &c1, const Complex &c2); friend Complex operator - (const Complex &c1, const Complex &c2); friend ostream &operator << (ostream &s, const Complex &c); friend istream &operator << (istream &s, const Complex &c); };
Complex::Complex(double r, double i){ re = r; im = i; }
inline Complex operator + (const Complex &c1, const Complex &c2){ return Complex (c1.re + c2.re, c1.im + c2.im); }
inline Complex operator - (const Complex &c1, const Complex &c2){ return Complex (c1.re - c2.re, c1.im - c2.im); }
inline ostream &operator << (ostream &s, const Complex &c){ return s << "(" << c.re << "," << c.im << ")" << endl; }
void main( ){
Complex c1(1.0, 2.0);
Complex c2(3.0, 4.0);
Complex c3 = c1 + c2;
Complex c4 = c1 - c2;
cout << "c3 " << c3;
cout << "c4 " << c4;
}
Output: c3 (4,6)
c4 (-2,-2)
Summary of Standard Operator Overloading Implementation
Binary Arithmetic Operators
Operator + (addition)
ClassName operator+(const ClassName &op1, const ClassName &op2)
{
// your calculations here
return ClassName(...); // return the related constructor
}
Definition:
friend ClassName operator+(const ClassName &op1,
const ClassName &op2);
Declaration:
Non-Member: to allow operation from other class, e.g.:
int a = 3; ClassName b, c(4);
b = a+c;
Summary of Standard Operator Overloading Implementation
Binary Arithmetic Operators
Operator (subtraction)
ClassName operator(const ClassName &op1, const ClassName &op2)
{
// your calculations here
return ClassName(...); // return the related constructor
}
Definition:
friend ClassName operator(const ClassName &op1,
const ClassName &op2);
Declaration:
Non-Member: to allow operation from other class, e.g.:
int a = 3; ClassName b, c(4);
b = a-c;
Summary of Standard Operator Overloading Implementation
Binary Arithmetic Operators
Operator (multiplication)
ClassName operator(const ClassName &op1, const ClassName &op2)
{
// your calculations here
return ClassName(...); // return the related constructor
}
Definition:
friend ClassName operator(const ClassName &op1,
const ClassName &op2);
Declaration:
Non-Member: to allow operation from other class, e.g.:
int a = 3; ClassName b, c(4);
b = a*c;
Summary of Standard Operator Overloading Implementation
Binary Arithmetic Operators
Operator / (division)
ClassName operator/(const ClassName &op1, const ClassName &op2)
{
// your calculations here
return ClassName(...); // return the related constructor
}
Definition:
friend ClassName operator/(const ClassName &op1,
const ClassName &op2);
Declaration:
Non-Member: to allow operation from other class, e.g.:
int a = 3; ClassName b, c(4);
b = a/c;
Summary of Standard Operator Overloading Implementation
Binary Arithmetic Operators
Operator + (addition)
ClassName ClassName::operator+(const ClassName &op)
{
// your calculations here
return ClassName(...); // return the related constructor
}
Definition:
ClassName operator+(const ClassName &op);
Declaration:
Member: to disallow operation from other class, e.g.:
int a = 3; ClassName b, c(4);
b = a+c; // error
Summary of Standard Operator Overloading Implementation
Binary Arithmetic Operators
Operator (subtraction)
ClassName ClassName::operator(const ClassName &op)
{
// your calculations here
return ClassName(...); // return the related constructor
}
Definition:
ClassName operator(const ClassName &op);
Declaration:
Member: to disallow operation from other class, e.g.:
int a = 3; ClassName b, c(4);
b = a-c; // error
Summary of Standard Operator Overloading Implementation
Binary Arithmetic Operators
Operator (multiplication)
ClassName ClassName::operator(const ClassName &op)
{
// your calculations here
return ClassName(...); // return the related constructor
}
Definition:
ClassName operator(const ClassName &op);
Declaration:
Member: to disallow operation from other class, e.g.:
int a = 3; ClassName b, c(4);
b = a*c; // error
Summary of Standard Operator Overloading Implementation
Binary Arithmetic Operators
Operator / (division)
ClassName ClassName::operator/(const ClassName &op)
{
// your calculations here
return ClassName(...); // return the related constructor
}
Definition:
ClassName operator/(const ClassName &op);
Declaration:
Member: to disallow operation from other class, e.g.:
int a = 3; ClassName b, c(4);
b = a/c; // error
Summary of Standard Operator Overloading Implementation
Unary Operators
Operator ++ (postfix increment)
ClassName Classname::operator++(int)
{
ClassName cn(...) // save original
// your calculations here
return cn; // return the original
}
Definition:
ClassName operator++(int);
Declaration:
Summary of Standard Operator Overloading Implementation
Unary Operators
Operator (postfix decrement)
ClassName Classname::operator(int)
{
ClassName cn(...) // save original
// your calculations here
return cn; // return the original
}
Definition:
ClassName operator(int);
Declaration:
Summary of Standard Operator Overloading Implementation
Unary Operators
Operator ++ (prefix increment)
ClassName &Classname::operator++()
{
// your calculations here
return *this; // return the same object
}
Definition:
ClassName &operator++();
Declaration:
Summary of Standard Operator Overloading Implementation
Unary Operators
Operator (prefix decrement)
ClassName &Classname::operator()
{
// your calculations here
return *this; // return the same object
}
Definition:
ClassName &operator();
Declaration:
Summary of Standard Operator Overloading Implementation
Unary Operators
Operator (negation)
ClassName Classname::operator()
{
ClassName cn(...); // initialize an object
// your calculations here
return cn; // return the same object
}
Definition:
ClassName operator();
Declaration:
Summary of Standard Operator Overloading Implementation
Unary Operators
Operator + (affirmation)
ClassName &Classname::operator+()
{
return *this;
}
Definition:
ClassName &operator+();
Declaration:
Summary of Standard Operator Overloading Implementation
Assignment Operators
Operator = (normal assignment)
ClassName &ClassName::operator=(const ClassName &op)
{
// your calculations here
return *this; // return the same object
}
Definition:
ClassName &operator=(const ClassName &op);
Declaration:
Summary of Standard Operator Overloading Implementation
Assignment Operators
Operator + (additive assignment)
ClassName &ClassName::operator+(const ClassName &op)
{
// your calculations here
return *this; // return the same object
}
Definition:
ClassName &operator+(const ClassName &op);
Declaration:
Summary of Standard Operator Overloading Implementation
Assignment Operators
Operator (subtractive assignment)
ClassName &ClassName::operator(const ClassName &op)
{
// your calculations here
return *this; // return the same object
}
Definition:
ClassName &operator(const ClassName &op);
Declaration:
Summary of Standard Operator Overloading Implementation
Assignment Operators
Operator (multiplicative assignment)
ClassName &ClassName::operator(const ClassName &op)
{
// your calculations here
return *this; // return the same object
}
Definition:
ClassName &operator(const ClassName &op);
Declaration:
Summary of Standard Operator Overloading Implementation
Assignment Operators
Operator / (divisive assignment)
ClassName &ClassName::operator/(const ClassName &op)
{
// your calculations here
return *this; // return the same object
}
Definition:
ClassName &operator/(const ClassName &op);
Declaration:
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator == (equal to)
ClassName operator==(const ClassName &op1, const ClassName &op2)
{
return (...); // return a value of a comparison calculation
}
Definition:
friend int operator==(const ClassName &op1,
const ClassName &op2);
Declaration:
Non-Member: to allow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a == c);
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator != (not equal to)
ClassName operator!=(const ClassName &op1, const ClassName &op2)
{
return (...); // return a value of a comparison calculation
}
Definition:
friend int operator!=(const ClassName &op1,
const ClassName &op2);
Declaration:
Non-Member: to allow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a != c);
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator = (less than or equal to)
ClassName operator=(const ClassName &op1, const ClassName &op2)
{
return (...); // return a value of a comparison calculation
}
Definition:
friend int operator=(const ClassName &op1,
const ClassName &op2);
Declaration:
Non-Member: to allow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a <= c);
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator = (greater than or equal to)
ClassName operator=(const ClassName &op1, const ClassName &op2)
{
return (...); // return a value of a comparison calculation
}
Definition:
friend int operator=(const ClassName &op1,
const ClassName &op2);
Declaration:
Non-Member: to allow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a >= c);
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator (less than)
ClassName operator(const ClassName &op1, const ClassName &op2)
{
return (...); // return a value of a comparison calculation
}
Definition:
friend int operator(const ClassName &op1,
const ClassName &op2);
Declaration:
Non-Member: to allow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a < c);
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator (greater than)
ClassName operator(const ClassName &op1, const ClassName &op2)
{
return (...); // return a value of a comparison calculation
}
Definition:
friend int operator(const ClassName &op1,
const ClassName &op2);
Declaration:
Non-Member: to allow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a > c);
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator == (equal to)
int ClassName::operator==(const ClassName &op)
{
return (...); // return a value of a comparison calculation
}
Definition:
int operator==(const ClassName &op);
Declaration:
Member: to disallow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a == c); // error
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator != (not equal to)
int ClassName::operator!=(const ClassName &op)
{
return (...); // return a value of a comparison calculation
}
Definition:
int operator!=(const ClassName &op);
Declaration:
Member: to disallow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a != c); // error
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator = (less than or equal to)
int ClassName::operator=(const ClassName &op)
{
return (...); // return a value of a comparison calculation
}
Definition:
int operator=(const ClassName &op;
Declaration:
Member: to disallow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a <= c); // error
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator = (greater than or equal to)
int ClassName::operator=(const ClassName &op)
{
return (...); // return a value of a comparison calculation
}
Definition:
int operator=(const ClassName &op);
Declaration:
Member: to disallow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a >= c); // error
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator (less than)
int ClassName::operator(const ClassName &op)
{
return (...); // return a value of a comparison calculation
}
Definition:
int operator(const ClassName &op);
Declaration:
Member: to disallow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a < c); // error
Summary of Standard Operator Overloading Implementation
Relational Operators
Operator (greater than)
int ClassName::operator(const ClassName &op)
{
return (...); // return a value of a comparison calculation
}
Definition:
int operator(const ClassName &op);
Declaration:
Member: to disallow operation from other class, e.g.:
int a = 3, b; ClassName c(4);
b = (a > c); // error
Summary of Standard Operator Overloading Implementation
Shift Operators (for streaming)
Operator (shift right / input)
istream &operator(istream &is, ClassName &obj)
{
is >> ... // your calculations here
obj = ClassName(...); // reset the class object
return is; // return the istream
}
Definition:
friend istream &operator(istream &is,
ClassName &obj);
Declaration:
Summary of Standard Operator Overloading Implementation
Shift Operators (for streaming)
Operator (shift left / output)
ostream &operator(ostream &os, const ClassName &obj)
{
return (os << ...); // return the final ostream
}
Definition:
friend ostream &operator(ostream &os,
const ClassName &obj);
Declaration: