Operator Overloading

Back to Fractions...

Implementing an Object

• We’ve talked at length about object-orientation.

– We’ve looked heavily at encapsulation and related concerns.

• We’ve started to implement a data structure for fractions.

– Data structures are special classes/objects designed to organize data within a program.

Fractions

• As noted earlier, C++ does not have a fraction or rational data type or object class

– This does not mean that we can’t create a class that provides this functionality!

– Let's do it! – Get out laptops and bring up the code we started a couple weeks ago

Object Requirements

• Our core idea: we want a class of objects that behave like fractions

– What are some of the implications of this?

– What must we store/track?

– What operations should be possible?

– What conversions?

– What about operators?

Object Requirements

• Our core idea: we want a class of objects that behave like fractions

– Fractions have a numerator and a denominator – we must store these

– We can assign, compare, add, subtract, multiply, and divide fractions

– It would be nice to convert a fraction to an int or a double. How about the reverse directions?

– What about strings?

Object Requirements

• Our core idea: we want a class of objects that behave like fractions

– Converting to int or double is easy.

– Converting from int is easy

– Converting from double...

… not so much!

– Converting to a string is easy...

… from a string a bit harder

Object Requirements

• Our core idea: we want a class of objects that behave like fractions

– What about binary operators like +, -?

– We can overload these just like functions!

– How about +=, -=, etc.? Yep!

– How about =, <, >, etc.? Yep, those too!

Object Requirements

• We need constructors and destructors

• We may also need getters and setters for numerator and denominator

• We can also provide for “automatic” type conversion!

Implementing Our Object

• Step 1: determining the declarations

– These go in the header (Fraction.h) file.

class Fraction { private: int numerator; int denominator;

public: Fraction(int, int); Fraction();// more later

Implementing Our Object

• Step 1 (con't): more declarationsFraction add(const Fraction &f) const;Fraction subtract(const Fraction &f) const;Fraction multiply(const Fraction &f) const;Fraction divide(const Fraction &f) const; // comparison methodsint compare(const Fraction &f) const;bool equals(const Fraction &f) const; // conversion methodsint intValue() const;double doubleValue() const;string toString() const;

Implementing Our Object

Step 1(con't): more declarations

Fraction add(const Fraction &f) const;Fraction subtract(const Fraction &f) const;Fraction multiply(const Fraction &f) const;Fraction divide(const Fraction &f) const;int compare(const Fraction &f) const;bool equals(const Fraction &f) const;int intValue() const;double doubleValue() const;string toString() const;

Note the use of const here -This means that the method willNOT change the object on which

it is called

Implementing Our Object

Step 1(con't): more declarations

Fraction add(const Fraction &f) const;Fraction subtract(const Fraction &f) const;Fraction multiply(const Fraction &f) const;Fraction divide(const Fraction &f) const;int compare(const Fraction &f) const;bool equals(const Fraction &f) const;int intValue() const;double doubleValue() const;string toString() const;

Note also that we are returningthe object itself rather than

a pointer to the object as before(no *)

Use of string means we must#include <string>

Implementing Our Object

• Step 2: implementing the methods (goes in Fraction.cpp file).

Fraction::Fraction() : numerator(0), denominator(1) {}

Fraction::Fraction(int n, int d) { numerator = n; denominator = d;}

Wouldn't it be nice if the fractionwere in reduced form?

Solution: implement a privategcd() function in Fraction,

use it to reduce form

Implementing Our Object

• Revised version of constructor:Fraction::Fraction() : numerator(0), denominator(1) {}

Fraction::Fraction(int n, int d) { int g = gcd(n, d); if (g > 1) { n /= g; d /= g; } numerator = n; denominator = d;}

Implementing Our Object

• What does gcd look like?int Fraction::gcd(int n, int d) { int n1 = abs(n); // want these positive int n2 = abs(d); int gcd = 1;

for (int k = 1; k <= n1 && k <= n2; ++k) { if (n1 % k == 0 && n2 % k == 0) gcd = k; } return gcd;}

Note: this is a cheesy implementation

of the gcd function!

Remember to putprototype in .h fileas private, static!

Oh yeah! And be sureto #include <cstdlib>in Fraction.cpp file!

Implementing Our Object

• Step 2: OK – constructors done, now for addition, etc.

(we did this one before, 'member?)

Fraction Fraction::add(const Fraction &f) const{ int num = this->numerator * f.denominator; num += f.numerator * this->denominator; int dnm = f.denominator * denominator;

return Fraction(num, dnm);}

Implementing Our Object

• Step 2: … subtraction, multiplication,...

Pretty straight-forward…

Fraction Fraction::subtract(const Fraction &f) const{ int num = this->numerator * f.denominator; num -= f.numerator * this->denominator; int dnm = f.denominator * denominator;

return Fraction(num, dnm);}

Implementing Our Object

• Step 2: … multiplication, division, ...

Fraction Fraction::multiply(const Fraction &f) const{ int num = this->numerator * f.numerator; int dnm = this->denominator * f.denominator;

return Fraction(num, dnm);}

Implementing Our Object

• Step 2: … division,...

Fraction Fraction::divide(const Fraction &f) const{ // divide is multiply by reciprocal int num = this->numerator * f.denominator; int dnm = this->denominator * f.numerator;

return Fraction(num, dnm);}

Implementing Our Object

• Step 2: Now for comparison...int Fraction::compare(const Fraction &f) const{ Fraction temp = subtract(f); // difference int num = temp.getNum(); if (num < 0) return -1; // neg => smaller return (num > 0 ? 1 : 0); // pos => bigger}

bool Fraction::equals(const Fraction &f) const{ return(0 == compare(f));}

Implementing Our Object

• Step 2: Conversion to built-ins ...

Easy peasy

int Fraction::intValue() const{ return (numerator)/(denominator);}

double Fraction::doubleValue() const{ return ((double) numerator )/((double) denominator);}

Implementing Our Object

• Step 2: … and conversion to stringstring Fraction::toString() const{ stringstream ss; ss << numerator; if (denominator > 1 && numerator != 0) ss << "/" << denominator; return (ss.str());}

What is the if for???

Prevent output like 3/1 and 0/4

Testing Our Class

• Step 3: Writing some test code

(This goes in testFraction.cpp)

#include <iostream>#include <string>#include "Fraction.h"using namespace std;

int main() { int i; int j; Fraction g1; ...

Testing Our Class

• Step 3: Writing test code ... Fraction g1;

cout << "Enter two integers: " << flush; cin >> i >> j; g1.setNum(i); // test setters g1.setDenom(j);

cout << "Enter two integers: " << flush; cin >> i >> j; Fraction g2(i,j); // test list constructor ...

Testing Our Class

• Step 3: Writing test code cout << g1.toString() // test toString << " plus " << g2.toString() << " equals " << g1.add(g2).toString() // test add << endl;

Testing Our Class

• Step 3: etc. etc. etc. for other 3 fcns,

then do compare: cout << g1.toString() << " compare " << g2.toString() << " is " << g1.compare(g2) << endl;

Testing Our Class

• Step 3: and equals: cout << g1.toString() << " equals " << g2.toString() << " is " << g1.equals(g2) << endl;

Return 0; // done for now!}

Exercise 1:

• Implement Fraction class (you should have most of this from before) – just constructors, setters, add(), toString(), and compare() for now...

• Use direct form rather than pointer version

• Compile – no need to have these as 3 files for now... check #includes!!!

• Run test and see that it works

Review Requirements

• We have met all the basic requirements

Arithmetic operations, comparison, conversion to float, int, and string

• Missing conversion from int, float, or string

• What about operators?

• And automatic conversion?

Conversion from int

• Automatic (compiler) conversion from other types can occur when a function is called (such as add) that needs another Fraction, but an int or float is the actual parameter

• Compiler will first search for overloaded function with matching signature – not there!

• Then it looks for … constructor!

Conversion from int

• Step 1: More declarationsclass Fraction { private: int numerator; int denominator; static int gcd(int n, int d);

public: Fraction(int, int); Fraction(); Fraction(int n); // conversion from int ...

Conversion from int

• Step 2: implementation

Fraction::Fraction(int n){ numerator = n; denominator = 1;}

So what about floats?

Hmmmmmm....

Overloading Operators

• Wouldn't it be nice to be able to use code like

if (f1 > f2) { … }

• Well, C++ allows this!

• In fact, C++ allows lots of operators to be overloaded

• Use the special operator function

• Named with operator keyword followed by the actual operator

Overloading Operators

• Step 1: More declarationsclass Fraction { private: int numerator; int denominator; static int gcd(int n, int d);

public: ... bool operator<(const Fraction& f) const; bool operator==(const Fraction& f) const; ...

operator keyword Operator symbol(s)

Overloading Operators

• Step 2: implementation

bool Fraction::operator<(const Fraction& f) const{ return (compare(f) < 0);}

bool Fraction::operator==(const Fraction& f) const{ return (compare(f) == 0);}

Testing Operator Overload

• Step 3: Writing some test code... // test overloading < operator cout << g1.toString() << " < " << g2.toString() << " is " << (g1 < g2) << endl; // now test auto conversion from int cout << g1.toString() << " plus 1 equals " << g1.add(1).toString() << endl;...

Exercise 2:

• Add declarations and implementation for integer conversion and overloading < operator

• Add a little code to test these

• Compile

• Run test and see that it works

More Operators

• Step 1: More declarationsclass Fraction {...public:... Fraction operator+(const Fraction& f) const; Fraction operator-(const Fraction& f) const; Fraction operator*(const Fraction& f) const; Fraction operator/(const Fraction& f) const;...

operator keyword Operator symbol(s)

More Operators

• Step 2: implementation

Fraction Fraction::operator+(const Fraction& f) const{ return (add(f));}

Fraction Fraction::operator-(const Fraction& f) const{ return (subtract(f));}

Augmented Assignment

• What about code like f1 += f2;

• Well, C++ also allows this!

• Issue here is that assignment also returns a Lvalue... how to solve?

• So declare as reference Fraction& and return object

• Can't use const any more!!! Why not?

AA Operators

• Step 1: More declarationsclass Fraction {...public:... Fraction& operator+=(const Fraction& f) ; Fraction& operator-=(const Fraction& f) ; Fraction& operator*=(const Fraction& f) ; Fraction& operator/=(const Fraction& f) ;

...

reference type return value No more const!

More Operators

• Step 2: implementation

Fraction& Fraction::operator+=(const Fraction& f){ *this = this->add(f); return *this;}

reference return type so it can be Lvalue

Modify object

Return modified object

More Testing Overload

• Step 3: Writing some test code... cout << g1.toString() << " plus equal " << g2.toString() << " equals "; g1 += g2; cout << g1.toString() << endl;...

Exercise 3:

• Add declarations and implementation for overloading + and += operators

• Add a little code to test these

• Compile

• Run test and see that it works

Operator Overloading

• Can also overload [] indexing operator – see lab

• Only operators that can't be overloaded in C++ are:

?: . .* ::

• Only overload operators when the overloaded function fulfills the logical function of the original operator!

Questions?

• Project 4:

• Implement overload operators for set and multiset:

+ (union), - (subtraction), +=, -=,

* (intersect), ^ (difference), *=, ^=,

== (equality),

< (proper subset), <= (subset)