11/17/2008MET CS 563 - Fall 2008 8.Overloading Functions and Operators 1 8. Overloading Operators...

11/17/2008 MET CS 563 - Fall 2008 8.Overloading Functions and Operators

1

8. Overloading Operators8. Overloading Operators

Main Idea: Main Idea: Use the same function name (function overload) or operator symbol (operator overload) to perform different computations, initializations or other actions.


2

Example 2: Overloading the class constructorAssume a complex class type has been definedclass Complex {…};We want to be able to initialize a class object in different ways, e.g. by giving values to its data members or by initializing it to some object of the same class Solution: overload the class constructor, so that

Complex first(re, im);and

Complex second(first);

can be used.

Overload: Examples

argument values of the type of the corresponding data members

single argument of type Complex, the same type as the object being initialized


3

Example 3: We want to manipulate user defined objects, such as Date class objects or aggregate types such as strings the same way as we manipulate integers or floats, e.g.

a) Overloading the '<' operator for Date today < tomorrow should produce true

b) the '+' and '==' operator for strings

"Welcome " + " home !" should produce "Welcome home !" "myPassword" == "myPasswd" should produce false

Overload: Examples (continued)


4

Overloading OperatorsOverloading OperatorsGoal:Goal: Manipulate aggregate data types, such as arrays, structures, classes in the same manner as built-in types, i.e. with infix operators that perform user defined operations on the objects.

Main Idea:Main Idea: A binary operator is a function with two arguments, e.g. the expression

3+5 that evaluates to 8 is the same as the function plus()

plus(3, 5) returning the value 8. Thus operator overload is in essence function overload. In order to implement it we need to write the appropriate definitions and to agree on a way to unambiguously relate these definitions to the operator symbol.

Example:Example: operator + {…},

operator - {…}

Syntax:Syntax: operator <OperatorSymbol> {…}

keyword

overloaded operator

function body


5

Implementing Operator Overload: Implementing Operator Overload: Member Function or Member Function or friendfriend Function ? Function ?

A fundamental question of implementing operator overload is:

Can we always implement it as a member function of the class Can we always implement it as a member function of the class or do we need another mechanism as well? or do we need another mechanism as well?

We will explore this question by overloading the '+' operator for a user defined class type Rational for rational numbers. The class Rational represents the rational numbers, i.e. all numbers that can be represented as

p/ q where p and q are integers, e.g 2/3, 1/4, etc.The class includes the arithmetic and comparison operators and prints the rational number in quotient form by keeping the nominator and denominator as small as possible (as shown in the above examples).


6

Class Class RationalRational

RationalInterface / Behavior

Initialize itself to 0

Perform addition '+' with integers and rationals//other arithmetic operations…

Perform comparison '<' with integers and rationals//other comparison operations…

Tell its value in reduced quotient form

Attributes / Data and Internalsnominatordenominatorreducing the nominator and denominator to smallest value

11/17/2008 MET CS 563 - Fall 2008 8.Overloading Functions and

Operators

7

(i) First Try: Overloaded (i) First Try: Overloaded '+''+' as a Member Function of class Rational as a Member Function of class Rational

class Rational{public:

Rational(int n=0, int d=1); //constructor initializing to 0 (0/1)//overloaded '+' prototype//input: single argument of type Rational,//returns value of (input + object)Rational operator+(const Rational& ); …

private:int nom; //nominatorint denom; //denominator… //functions for reducing nom and denom to smallest values

};


Operators

8

Class Class RationalRational - Constructors and Use of Overloaded '+' - Constructors and Use of Overloaded '+'

Constructor Definition:Constructor Definition:Rational :: Rational (int n, int d): nom(n), denom(d) {} Object Definitions: Object Definitions:

Rational t(5,4), s(3), u, v;

Use of Overloaded Operator:Use of Overloaded Operator:

Function Style (acc. Signature): t.operator+(s);

Operator Style (Shorthand): t + s;

function name according to syntax


Operators

9

Class Class RationalRational - Definition of Overloaded '+' as Member Function - Definition of Overloaded '+' as Member Function

Rational Rational :: operator+(const Rational &b ) { Rational sum; sum.nom = b.denom * nom + b.nom * denom; sum.denom = denom * b.denom; sum.reduce();

return sum;}

Similar definitions can be written for the remaining binary arithmetic operators such as -, *, /, etc.

Use:Use: t.operator+(s);t + s; t + 5; //works as 5 becomes the initial value for argument b5 + t; // illegal!!! 5 is a literal and 5.operator is not defined!!

Problem: t+5 5+t !! when using our new + operatorThe addition is not commutative contrary to everything we have been taught since elementary school. Not a good idea.


Operators

10

Class Class RationalRational - Declaring Overloaded '+' as - Declaring Overloaded '+' as friendfriend Function within the class Function within the class

class Rational {public:

Rational(int n=0, int d=1); //constructor

friend Rational operator+( const Rational&, const Rational&);//overloaded '+' prototype as friend function//input two arguments of type Rational,//returns sum of two arguments…//Similar declarations can be written for the remaining binary

//arithmetic operators such as -, *, /, etc.…

private: //same as in previous definitionint nom; //nominatorint denom; //denominator//functions for reducing nom and denom to smallest values

};

keyword argument1

argument2


Operators

11

Defining theDefining the Overloaded '+' Overloaded '+' friendfriend Function Outside the Class Function Outside the Class

Rational operator+( const Rational &a, const Rational &b ) { Rational sum; sum.nom = b.denom * a.nom + b.nom * a.denom; sum.denom = a.denom * b.denom; sum.reduce(); return sum;}

Similar definitions can be written for the remaining binary arithmetic operators such as -, *, /, etc.

Note: The definition has no indication that there is any relation to some class(es). It is a regular function definition and only the class can give it special meaning by declaring it a friend and giving access to its private data members.

Use:Use: operator+(t, s);t + s; t + 5; //works as 5 becomes the initial value for argument b5 + t; // works as well!!! 5 is a literal for argument a!!


Operators

12

(iii) Overloaded Computer Specific Operators Return Objects Not Just Values (iii) Overloaded Computer Specific Operators Return Objects Not Just Values

Important Shared Characteristics:Important Shared Characteristics: I/O as well as assignment operators should return objects, not just values to allow compound statements, such as

cout << "The sum is " << a+b; t += s += a;

Assignment I/OObject of output stream class ostream

modified coutof type ostream resulting from insertion of "The sum is " in cout

s = s +a;returns object s

modified coutof type ostream resulting from insertion of a+b in previously modified cout

left-to-right associativity

t = t +s;returns object t

right -to- left associativity


Operators

13

Overloaded Computer Specific Operators: I/O Friends and Assignment MembersOverloaded Computer Specific Operators: I/O Friends and Assignment Members

Input / Output Input / Output OperatorsOperatorsare implemented as are implemented as

friendfriend functions:functions:

Important Difference:Important Difference:

cout << a+b; t += s;

Assignment I/O

lhs and rhs are of different types

lhs and rhs are of the same type

Assignment Assignment Operators Operatorsare implemented as are implemented as

membermember functions:functions:


Operators

14

Another look at class Rationalclass Rational {public:

Rational (int = 0, int = 1 ); // default constructor//Arithmetic operators as friend functions

friend Rational operator+( const Rational&, const Rational& );//Similarly the remaining arithmetic operators

//Comparison operators as friend functions friend bool operator>( const Rational&, const Rational& );

//Similarly the remaining comparison operators //Output operator as friend function

friend ostream& operator<<(ostream& , const Rational& );//Similarly the input operator

//Assignment operators as member functions Rational& operator+=(const Rational& );

//Similarly the remaining assignment operators

private: int nom; int denom; int gcd(int , int ); //input: two integers, returns greatest common devisor void reduce( void ); //reduces nom and denom to smallest value};


Operators

15

Class Class RationalRational - Definition and Use of Overloaded Output - Definition and Use of Overloaded Output

Prototype in class definition:Prototype in class definition:

friend ostream& operator<<(ostream& , const Rational& );

Definition:Definition:

ostream& operator<<(ostream& out, const Rational& s){out << s.nom << '/' << s.denom ;return out;

}

Use:Use:Rational d( 3, 9 );

cout << "d = " << d << endl;

d = 1/3

Reference as it will change after insertion of expressions to be output

Reference: returns class object, not just object value; thus allowing compound operations

overloadedstream insertion operator

argument1: out argument2: s


Operators

16

Class Class RationalRational - Definition and Use of Overloaded Assignment - Definition and Use of Overloaded Assignment


Rational& operator+=(const Rational& );

Definition:Definition:Rational& Rational :: operator+=(const Rational& r){

nom = nom * r.denom + denom * r.nom;denom *= r.denom;reduce();return *this;

}Use:Use:

Rational r(3, 2);Rational r(3, 2);cout<< "r = " << r << endl;cout<< "r = " << r << endl;cout<< r << "+ 2 =";cout<< r << "+ 2 =";r += 2;r += 2;cout<< r << endl;cout<< r << endl;

Refers to object itself, i.e. object that received message and was modified.

r = 3/23/2+ 2 =7/2

Reference: returns class object, not just object value; thus allowing compound operations


Operators

17

The The thisthis Pointer Gives Access to Object's Own Address Pointer Gives Access to Object's Own Address

Goal: Provide object with the ability to refer to itselfGoal: Provide object with the ability to refer to itself

As shown in the overloaded addition assignment this can be quite useful.

Solution: Each object is provided with a pointer Solution: Each object is provided with a pointer this this that contains the object's that contains the object's address.address.

Note:Note:

• The type of the this pointer is given by the type of the corresponding object.

• The this pointer is not part of the object itself, i.e. it is not reflected in the result of the sizeof operation that returns the size of an object. It is passed into object as an implicit first argument with every non-static message (call) to the object.

• The this pointer is used implicitly or explicitly to reference data members and methods of the class


Operators

18

Operators that Cannot Be OverloadedOperators that Cannot Be Overloaded

Most operators in C++ can be overloaded.

However, the following operators cannot be overloaded

. .* :: ?: sizeof


19

7.3. Class 7.3. Class String - String - (i) C - strings(i) C - strings

- String literals (constants):- String literals (constants): sequence of characters enclosed in double quotes, e.g.

"I am a string"The internal representation is an array of characters terminated by the NULL character '\0'. Thus the length of the array is always the string length + 1

- Character arrays - can have variable contents- Character arrays - can have variable contentschar s[] = "error";orchar* ps = "error";

I a m a s t r i n g \0

e r r o r \0

pse r r o r \0


20

Why bother with operator overload for strings?Why bother with operator overload for strings?

ButButC++ does not provide any operators that process strings as units!!C++ does not provide any operators that process strings as units!! Thus we need to define our own overloaded operators if we want more comfort Thus we need to define our own overloaded operators if we want more comfort in handling strings!in handling strings!

- - C++ has an extensive library of functionsC++ has an extensive library of functions that becomes accessible by including the header <string.h> , e.g.

char *strcpy(char *s1, const char *s2) copies string s2 into s1. Returns value of s1

char *strcat(char *s1, const char *s2) appends string s2 to string s1. Returns value of s1.

char *strcmp(const char *s1, const char *s2) compares string s1 to string s2. Returns 0 for s1=s2, <0 for s1<s2, and >0 for s1>s2.

size_t strlen(const char *s) returns length of s = number of characters in s not including '\0' .

return type of sizeof operator for arrays, typically unsigned int; sizeof returns the total number of bytes in array


21

(ii) (ii) newnew and and delete delete Allocate and Deallocate Memory at Run TimeAllocate and Deallocate Memory at Run Time

Goal: Use and free memory as needed during program execution instead of Goal: Use and free memory as needed during program execution instead of blocking it in a static size array throughout the run of the programblocking it in a static size array throughout the run of the program

Solution: Solution: Operatora) new allocates memory of the required type, provides pointer to it, and calls constructor:

Rational * rationalPtr;rationalPtr = new Rational;

In general:<typeNamePtr> = new <TypeName> ;

b) delete frees the memory allocated by new :delete rationalPtr; //memory allocated to *rationalPtr is freed

In general: delete <typeNamePtr> ;

rationalPtr

nom

denom

0

1

* rationalPtr

Important Note: In order to deallocate an entire array, not just the first element, one needs to use

delete [ ] <arrayPtr> ;Otherwise access to memory is lost, but memory is not freed and cannot be used anymore --> memory leak.


22

(iii) A (iii) A User Defined class StringUser Defined class StringStringInterface / Behavior

Construct String object from C-stringConstruct String object from another String object

copy constructorDestruct String object freeing the memory

Assign String (=) object to another String objectAppend Assign (+=) String object to another String objectAppend (+) String object to another String object

Tell its length

Tell its C-string value

Tell the character at a given location overloaded subscripts []

Perform comparisons with other String instances

Perform I/O of String instances

Attributes / Data & Internalsstring value, i.e. the sequence of characters composing the string


23

class class String - DefinitionString - Definition

class String {public:

String(const char s[]=""); //constructs deep copy of C-string s String(const String& s); //constructs deep copy of String type s ~String(); //deallocates string memory

String& operator=(const String& rhs); //Assigns deep copy rhs

String& operator+=(const String& rhs); //Appends (catenates) deep copy of rhs

friend String operator+(const String& s, const String& t); //Returns deep copy of s appended with deep copy of t

int length() const; //Returns number of string characters const char* charString() const; //Returns C-string value//Subscripts char& operator[](unsigned i); //Element of variable string at position i char operator[](unsigned i) const; //Element of constant string at position i

Constructors and Constructors and DestructorsDestructors

Append and AssignAccess Member Functions


24

class class String - Definition (continued)String - Definition (continued)

friend bool operator==(const String& s, const String& t); friend bool operator!=(const String& s, const String& t); friend bool operator< (const String& s, const String& t); friend bool operator<=(const String& s, const String& t); friend bool operator> (const String& s, const String& t); friend bool operator>=(const String& s, const String& t);

friend istream& operator>>(istream& in, String& s); //Reads <= 999 char to newline; Newline is extracted, but not assigned.

friend ostream& operator<<(ostream& out, const String& s); //Ouputs string s

private: char* info_; //pointer to char, NO dimension defined

};

ComparisonComparison

I/O OperatorsI/O Operators

11/17/2008MET CS 563 - Fall 2008

8.Overloading Functions and Operators 25

class class String - ConstructorsString - Constructors


String(const char s[]=""); //constructs deep copy of C-string s String(const String& s); //constructs deep copy of String type s

//copy constructor

Definition:Definition:String::String(const char *s) { info_= new char[strlen(s)+1]; //allocates char numbers +1 for '\0' strcpy(info_, s);}

Use:Use: String a("Jane"), b("George");

Definition:Definition:String::String(const String& s) {

info_= new char[strlen(s.info_)+1]; //allocates char numbers +1 for '\0' strcpy(info_, s.info_);}

Use: Use: String c(a);

deep copy means that the C-string is copied to the private array of the object, as opposed to a shallow copy that simply copies the array name i.e. the address of the first element.

In general signature of copy constructor of some class A A(const A&)


26

class class String - DestructorString - Destructor


~String(); //deallocates string memory


String::~String() { delete [] info_; //Deallocates array (of any length!) pointed to by info_

}

Use: Use: Called automatically at end of object life time.

We absolutely need the [] in order to free all memory allocated to the array info_ points to. Omitting it will lead to memory leak

11/17/2008MET CS 563 - Fall 2008

8.Overloading Functions and Operators 27

class class String - Assign and Assign Append Operators Are MembersString - Assign and Assign Append Operators Are MembersPrototype in class definition:Prototype in class definition:

String& operator=(const String& rhs); //Assigns deep copy rhs

String& operator+=(const String& rhs); //Appends(catenates) deep copy of rhs Definitions:Definitions:String& String::operator=(const String& rhs) {

if(this != &rhs) { delete [] info_; info_ = new char[strlen(rhs.info_)+1]; strcpy(info_, rhs.info_);

} return *this;

}

String& String::operator+=(const String& rhs){ char *temp= new char[strlen(info_)+strlen(rhs.info_)+1]; strcpy(temp, info_); strcat(temp, rhs.info_); //catenates s.info_ to temp delete [] info_; //deallocate memory pointed to by info_ info_ = temp; //assign info_ to point to catenation of string return *this;

}Use:Use: a=b; a+=b; //exactly as for any built-in type


28

(ii) Second Try: Overloaded (ii) Second Try: Overloaded '+''+' as a as a friendfriend Function of class Rational Function of class Rational

Solution:Solution: Introduce a new type of function that is

• not a member functions but still

• has access to the private data members of the class

Such functions are referred as friend functions and are

• declared within the class as are the member functions, but are differentiated from them through the keyword friend preceding the prototype.

• defined outside the class with no mention to the class of which they are friends, i.e. the class knows who its friends are, but not the outside world.


29

class class String - Append Operator (+) Is String - Append Operator (+) Is friendfriend


friend String operator+(const String& s, const String& t); //Returns deep copy of s appended with deep copy of t


String operator+(const String& s, const String& t)//Returns deep copy of s appended with deep copy of t{

String temp(s); //Copy constructor invoked for temp, temp initialized to s temp += t;//t appended to temp with overloaded += return temp;

}

Use:Use: c = a + b; //exactly as for any built-in type


30

class class String - Access Member FunctionsString - Access Member Functions

The methods accessing length and the C-string value of the String class are similar to any other access member functions and pretty unremarkable:

int String::length() const //Returns number of string characters{

return strlen(info_);}

and

const char* String::charString() const//Returns C-string value {

return info_;}

The overload of the subscript, however, is more interesting.


31

class class String - Subscripts Member FunctionsString - Subscripts Member Functions

char& String::operator[](unsigned i)//Element of variable string at position i {

if(i<0 || i>strlen(info_)){ cerr<<"Subscript range error"<<endl; exit(1);

} return info_[i];

}

char String::operator[](unsigned i) const //Element of constant string at position i{

cout<<"(returned from constant []) "; if(i<0 || i>strlen(info_)){

cerr<<"Subscript range error"<<endl; exit(1);

} return info_[i];

}

exit(1) terminates program as if it executed normally; used typically for input errors

returns object

returns value


32

class class String - Comparison OperatorsString - Comparison Operators

Prototype in class definition:Prototype in class definition:friend bool operator==(const String& s, const String& t);

Definition:Definition:bool operator==(const String& s, const String& t){

int l=s.length(); if( l < t.length())

l=s.length(); for (int i = 0; i<l ; i++)

if(s.info_[i]!=t.info_[i]) return false;

return true;}

Use:Use: bool equal = a == b; //exactly as for any built-in type


33

class class String - I/O OperatorsString - I/O Operators


friend istream& operator>>(istream& in, String& s); //Reads <= 999 char to newline; Newline is extracted, but not assigned.

friend ostream& operator<<(ostream& out, const String& s); //Ouputs string s

Definition:Definition:istream& operator>>(istream& in, String& s)//Reads <= 999 char to newline; Newline is extracted, but not assigned.

{ char buffer[1000]; in.getline(buffer,1000,'\n');//Remove <=999 char from in

//up to and including '\n', store all but '\n' in buffer, append '\0' s=String(buffer); return in;

}

ostream& operator<<(ostream& out, const String& s) //Ouputs string s

{ out << s.charString(); return out;

}

Use:Use: cout << a; cin >> b; //exactly as for any built-in type


34

class class String Driver – Constructors and EqualityString Driver – Constructors and Equality

void main(){

String a("Jane"), b("George"); cout<<"String a is "<<a<<" of length "<< a.length()<<endl; cout<<"String b is "<<b<<" of length "<< b.length()<<endl;

cout << "String c is constructed with copy constructor with argument string a"

<< endl; String c(a);

cout<<"String c is "<<c<<" of length "<< c.length()<<endl;

String a is Jane of length 4String b is George of length 6String c is constructed with copy constructor with argument string aString c is Jane of length 4


35

class class String Driver (continued) - SubscriptsString Driver (continued) - Subscriptscout<< "\nThe positions of the letters in string a are:"<<endl; for(int i=0; i< a.length(); i++)

cout << "Position "<< i << " holds " << a[i] <<endl; cout<< "\nThe positions of the letters in string b are:"<<endl; for(i=0; i< b.length(); i++)

cout << "Position "<< i << " holds " << b[i] <<endl;if(a==b)

cout<<"\nStrings a and b are equal"<<endl; else

cout<<"\nStrings a and b are not equal"<<endl;The positions of the letters in string a are:Position 0 holds JPosition 1 holds aPosition 2 holds nPosition 3 holds e

The positions of the letters in string b are:Position 0 holds GPosition 1 holds ePosition 2 holds oPosition 3 holds rPosition 4 holds gPosition 5 holds e

Strings a and b are not equal


36

class class String Driver (continued)- Subscripts for String Driver (continued)- Subscripts for const const ObjectsObjects

const String message("Careful!!"); cout<<"The message is "<<message<<" of length "<< message.length()<<endl;

cout<< "\nThe positions of the letters in the message are:"<<endl; for(i=0; i< message.length(); i++)

cout << "Position "<< i << " holds " << message[i] <<endl;

The message is Careful!! of length 9

The positions of the letters in the message are:(returned from constant []) Position 0 holds C(returned from constant []) Position 1 holds a(returned from constant []) Position 2 holds r(returned from constant []) Position 3 holds e(returned from constant []) Position 4 holds f(returned from constant []) Position 5 holds u(returned from constant []) Position 6 holds l(returned from constant []) Position 7 holds !(returned from constant []) Position 8 holds !


37

class class String Driver (continued) – I/OString Driver (continued) – I/O

String friendList[5]; cout<<"\nBegin input for list of five friends:"<<endl; for(i=0; i<5 ; i++){

cout<<"Enter name "<< i+1 <<":"; cin>>friendList[i];

}cout<<"\n Your list of five friends contains:"<<endl; for(i=0; i<5 ; i++){

cout<<" >"<<friendList[i]<<" and the length is " << friendList[i].length() <<endl;

}}//end main()

Begin input for list of five friends:Enter name 1:Jane BrownEnter name 2:David MonroeEnter name 3:Mary SimmonsEnter name 4:Sam VoigtEnter name 5:Steve Cushing

Your list of five friends contains: >Jane Brown and the length is 10 >David Monroe and the length is 12 >Mary Simmons and the length is 12 >Sam Voigt and the length is 9 >Steve Cushing and the length is 13


38

Overload - Summary• An overloaded function is a set of functions with the same name and different

argument lists

• An overloaded operator is a C++ operator that has been extended through an additional definition to manipulate user defined and aggregate types in the same way as built-in types.

• To overload an operator a function with the name

operator<OperatorSymbol> ,

where operator is a keyword, must be defined.

• Friend functions of a class are functions that are not member functions but have access to the private data members of the class.

• Friend functions are declared within the class with the keyword friend preceding the function prototype, and are defined outside the class as a regular function, with no indication of their friendship relation to any class.


39

Overload – Summary (continued)• Operator overload can be implemented as a member function or a friend

function:

- overloaded binary operators (arithmetic and comparison) are implemented as friends in order to treat both their arguments in the same way;

- overloaded assignment operators are implemented as member functions returning objects instead of values;

- overloaded I/O operators are implemented as friend functions returning objects instead of values.

• Strings are implemented as character arrays terminating with the NULL character '\0'.

• User-defined classes with overloaded functions and operators make working with the user-defined and aggregate type objects as easy as working with simple built-in type such as integers.

• The operators new and delete allocate and deallocate memory at run time.

A final note:A final note: From this point on read as much code as possible and focus on design rather than on syntax.

11/17/2008MET CS 563 - Fall 2008 8.Overloading Functions and Operators 1 8. Overloading Operators...

Documents

Transcript of 11/17/2008MET CS 563 - Fall 2008 8.Overloading Functions and Operators 1 8. Overloading Operators...