Oops

OOPSPRESENTATIO

N OPERATOR OVERLOADING

By:-Aditi Chauhan (013)Akhilesh kr Jha (029)Arpan Rathi (056)Chandan Kumar (078)Vikas Verma (L.E.)

Overloading Operator

Operator overloading is a very neat feature of object

oriented programming

Operator overloading allows it to give normal C++ operators such as +,-,==,< additional meanings

It makes statements more intuitive and readable

for example:

Date d1(12,3,1989);

Date d2;

d2.add_days(d1,45);

// can be written with the + operator as

d2=d1+45;

Operator Overloading CS-2303, C-Term 2010

3

C++ Philosophy (continued)

Operators retain their precedence and associativity, even when overloaded

Operators retain their number of operands

Cannot redefine operators on built-in types

Not possible to define new operators Only (a subset of) the built-in C++ operators can be overloaded

Defining Operator Overloading

To define an additional task to an operator, we must specify

what it means in relation to the class to which the operator is

applied.

This is done with the help of a special function called operator

function.

return type class-name : :operator op (arg-list)

{

Function body // task defined

}


5Operators that Can and Cannot be Overloaded

Operators that can be overloaded

+ - * / % ^ & | ~ ! = < > += -= *=

/= %= ^= &= |= << >> >>=

<<= == != <= >= && || ++

-- ->* , -> [] () new delete

new[] delete[]

Operators that cannot be overloaded

. .* :: ?:


6

General Format

returnType operator*(parameters);

any type keyword operator symbol

Return type may be whatever the operator returns Including a reference to the object of the operand

Operator symbol may be any overloadable operator from the list.


return type class-name : :operator op (arg-list)

{

Function body // task defined

} return type is the type of value returned by the specified operation.

op is the operator being overloaded.

op is preceded by the keyword operator.

operator op is the function name.


Operator Function must be either member function (non-static)

Or friend function.

The basic difference : A friend function will have only one argument for unary operators and

two for binary operators.

A member function has no arguments for unary operators and one argument for binary operators.

This is because the object used to invoke the member function is passed implicitly and therefore is available for the member function.

Arguments may be passed either by value or by reference.

continue…

Process of Operator Overloading

The process of overloading involves the following steps:

Create a class that defines the data type that is to be used in the overloading operation.

Declare the operator function operator op( ) in the public part of the class. It may be either a member function or a friend function.

Define the operator function to implement the required operations.

Process of Operator Overloading

Overloaded operator functions can be invoked by expressions such as:

For unary operators: op x or x op

For binary operators: x op y

op x or x op would be interpreted as

for a friend function: operator op (x)

for a member function: x.operator op ( )

x op y would be interpreted as

for a friend function: operator op (x,y)

for a member function: x.operator op (y)

Overloading Unary Operators

Consider a unary minus operator: It takes just one operand.

It changes the sign of an operand when applied to a basic data item.

The unary minus when applied to an object should change the sign of each of its data items.

Overloading Binary Operators

As a rule, in overloading binary operators,

the left-hand operand is used to invoke the operator function and

the right-hand operand is passed as an argument.


return complex((x+c.x), (y+c.y));

The compiler invokes an appropriate constructor, initializes an object with no name and returns the contents for copying into an object.

Such an object is called a temporary object and goes out of space as soon as the contents are assigned to another object.

Overloading Binary Operators Using Friends

Friend function requires two arguments to be explicitly passes to it.

Member function requires only one.

friend complex operator+(complex, complex);

complex operator+(complex a, complex b)

{

return complex((a.x + b.x),(a.y + b.y));

}

Overloading Binary Operators Using Friends

We can use a friend function with built-in type

data as the left-hand operand and an object as

the right-hand operand.

Rules For Overloading Operators

Only existing operators can be overloaded. New operators cannot

be created.

The overloaded operator must have at least one operand that is of

user-defined type.

We cannot change the basic meaning of an operator.

Overloaded operators follow the syntax rules of the original

operators.


The following operators that cannot be

overloaded:

Size of Size of operator

. Membership operator

.* Pointer-to-member operator

: : Scope resolution operator

? ; Conditional operator

continue…


The following operators can be over loaded with the use of

member functions and not by the use of friend functions:

Assignment operator =

Function call operator( )

Subscripting operator [ ]

Class member access operator ->

Unary operators, overloaded by means of a member function, take

no explicit arguments and return no explicit values, but, those

overloaded by means of a friend function, take one reference

argument.

continue…


Binary operators overloaded through a member function

take one explicit argument and those which are overloaded

through a friend function take two explicit arguments.

When using binary operators overloaded through a member

function, the left hand operand must be an object of the

relevant class.

Binary arithmetic operators such as +, -, * and / must

explicitly return a value. They must not attempt to change

their own arguments.

continue…


class Date

{

void operator++(); // prefix increment operator

}

void Date::operator++ ()

{

if (++day > days_in_month())

{

day=1;

if (++month > 12)

month=1;

year++;

}}

Date d1(31,12,1999);

++d1; // results in 1.1.2000


class Date

{

Date operator++(); // prefix increment operator

}

Date Date::operator++ ()

{


{

day=1;

if (++month > 12)

month=1;

year++;

}

return *this; // self-reference to the object

}

Date d1(31,12,1999);

Date d2=++d1; // results in 1.1.2000

Overloading Unary Operatorsclass Date

{

Date operator++(int); // postfix increment operator notice int!!

}

Date Date::operator++ (int)

{

Date tmp=*this;


{

…

}

return tmp; // return copy of object

}

Date d1(31,12,1999);

Date d2=d1++; // results in d2 = 31.12.1999, d1 = 1.1.2000


class Date

{

Date operator+(int days) const;

};

Date Date::operator+(int days) const;

{

Date tmp=*this; // copy object

for (int i=0; i < days; i++)

tmp++;

return tmp;

}

Date d1(1,4,1999);

Date d2=d1+25; // results in 26.4.2000


class Date

{

Date& operator+=(int days); // must be reference as += modifies

// the left hand argument

};

Date& Date::operator+=(int days) // return type reference to object

{

for (int i=0; i < days; i++)

*this++;

return *this; // return reference to object

}

Date d1(1,4,1999);

d1+=25; // results in 26.4.2000

Overloading Relational Operators

class Date

{

bool operator==(Date d)

{

return (day==d.day) && (month=d.month) && (year==d.year);

};

bool operator<(Date d)

{

if (year < d.year)

return true;

else

if (year==d.year) && (month < d.month)

return true;

else

return (month==d.month) && (day < d.day);

};

};


int Date::operator-(Date d) const

{

int days=0;

if (*this > d)

while (*this != ++d)

days++;

else

while (*this != --d)

days--;

return days;

}

Date d1(24,4,1988);

Date d2(13,3,1998);

int diff = d1-d2; // diff = 42

Non-Member Function Operator

Operators can also be implemented as non-member functions instead of member functions

However this approach is usually not recommended

as member data is private to the operator

Necessary for some operators in which the class object does not appear on the left hand side of

the operator for example <<, >>


A binary operator can be defined either by a member function taking one argument or a non-member function taking two arguments

class Date

{

Date operator+(int n); //member function one argument

}

Date Date::operator+(int n)

{ … };

Date operator+(Date d, int n) //non-member func two arguments

{

Date temp=d;

for (int i=0; i<n; i++)

temp++;

return temp;

}


An unary operator can be defined either by a member function taking no argument or a non-member function taking one argument

class Date

{

Date operator++(); //member function postfix increment no argument

}

Date Date::operator++()

{ … };

Date operator++(Date& d) // non-member function one reference argument

{

// more complicated as member data is private to non-member function

int tmp_day = d.get_day();

int tmp_month = d.get_month();

d.set_day(tmp_day+1);

…

}

Overloading << Operator

Overloading the << operator allows you to specify the way in which an object is displayed

As the << operator expects a stream object as

the left hand argument it must be overloaded

as a non-member function :

ostream& operator<<(ostream& os, Date d);

It is possible to grant the non-member function

access to the private data member of the class

by declaring the function as a friend of the class.

Overloading << Operator

#include <iostream>

class Date

{

friend ostream& operator<<(ostream& os, Date d);

// this non-member function is a friend of class date

…

};

ostream& operator<<(ostream& os, Date d)

{

os << d.day << ”.” << d.month << ”.” << d.year; //access private data as friend

};

Date d1(16,3,1998);

cout << ”Today’s date is: ” << d1 << endl;

Thank You !!

Oops

Documents

Transcript of Oops