Working with Classes

A method dealing with two objects C++ has a pointer which call this. It gives the address of an object. Suppose we have two objects of BankAccount class and we want to know which one has more balance.

Solution : Have a method that returns a reference to the object with larger balance.

Header file for BankAccount class #ifndef BANK1_H #define BANK1_H class BankAccount { private : double balance; string name; public : BankAccount(); BankAccount(double initial_balance); void deposit (double amount); void withdraw (double amount ); double getBalance(); const BankAccount & topval( const BankAccount & s) const; ~BankAccount(); }; #endif

CPP file #include #include “bank1.h” BankAccount :: BankAccount() { balance = 0; } BankAccount :: BankAccount(double initialBalance, string str) { balance = initialBalance; name=str; }

void BankAccount ::deposit(double amount { balance =balance+amount ; } void BankAccount::withdraw(double amount) { if ( amount > balance ) amount=0; else balance=balance-amount; }

double BankAccount :: getBalance() { return balance; } BankAccount :: ~BankAccount() { cout<<“good bye”; }

const BankAccount & BankAccount :: topval( const BankAccount & s) const { if (s.balance > balance) return s; else return *this; } /* const in parenthesis says that the function won’t modify the explicitly accessed object */

/* the const after parenthesis says that the function won’t modify the implicitly accessed objects*/ The function returns a reference to one of the two const objects has to be constant. top=account1.topval(account2);

Operator Overloading Like function overloading we can have operator overloading. We have already used operator overloading we use * for multiplication and * for pointer. C++ allows user to overload operators.

Suppose we want to overload “+” to add two arrays. for(int i=0; i<20;i++) Array3[i]=Array1[i]+Array2[i]; // add element by element We can define a class that overload + so we can have Array3=Array1+Array2;

To overload an operator we use a special function call. operatorop(arguments-list); here op is a operator known for C++. For example: operator+(); // overload + // is not a C++ operator

#ifndef MYTIME0_H_ #define MYTIME0_H_ class Time { private: int hours; int minutes; public: Time(); Time(int h, int m); void AddMin(int m); void AddHr(int h); void Reset(int h, int m); Time Sum (const Time &t) const ; void Show(); }; #endif

#include #include “mytime0.h”; Time :: Time() { hours=minutes=0; } Time::Time(int h, int m) { hours=h; minutes=m; }

void Time::AddMin(int m) { minutes+=m; hours+=minutes/60; minutes %=60; } void Time::AddHr(int h) { hours+=h; }

void Time::Reset(int h, int m) { hours=h; minutes=m; } Time Time::Sum(const Time &t) const { Time sum; sum.minutes=minutes+t.minutes; sum.hours=hours+t.hours+sum.minutes/60; sum.minutes %=60; return sum; }

void Time:: Show() { cout<<hours<<“hours,” <<minutes<<“ minutes”; }

#include #include “mytime0.h”; int main() { Time coding(2,40); Time fixing(5,55); Time total; total=coding.Sum(fixing); total.Show(); return 0; }

#ifndef MYTIME0_H_ #define MYTIME0_H_ class Time { private: int hours; int minutes; public: Time(); Time(int h, int m); void AddMin(int m); void AddHr(int h); void Reset(int h, int m); Time operator+(const Time &t) const; Time operator *(double mult) const; void Show(); }; #endif

#include #include “mytime0.h”; Time :: Time() { hours=minutes=0; } Time::Time(int h, int m) { hours=h; minutes=m; }

void Time::AddMin(int m) { minutes+=m; hours+=minutes/60; minutes %=60; } void Time::AddHr(int h) { hours+=h; }

void Time::Rese(int h, int m) { hours=h; minutes=m; } Time Time::operator+(const Time &t) const { Time sum; sum.minutes=minutes+t.minutes; sum.hours=hours+t.hours+sum.minutes/60; sum.minutes %=60; return sum; }

Time Time::operator*(double mult) const { Time result; long totalmin=hours*mult*60+minutes*mult; result.hours=totalmin/60; result.minutes =totalmin % 60; return result; } void Time:: Show() { cout<<hours<<“hours,” <<minutes<<“ minutes”; }

#include #include “mytime0.h”; int main() { Time coding(2,40); Time fixing(5,55); Time total; total=coding+fixing; total.Show(); Time morefixing(3,28); total=morefixing.operator+(total); total.Show(); total=morefixing* 2.5; total.Show(); return 0; }

Time t1,t2,t3,t4; t4=t1+t2+t3; t4=t1.operator+(t2+t3); t4=t1. operator+(t2.operator+(t3));

Overloading Restriction Should preserve the syntax for the original operator. Time test, %test /// invalid We can’t create new operator symbols like operator **(); We can’t overload the following operators : sizeof. :: ?:

Operators can be overloaded + - * / % ^ > += -= ! = %= ^= &= |= << && -- () [ ] new -> delete

= Assignment () Function call [ ] Subscripting -> class member access by pointer Can be overloaded only by member function.

Friend Function When a function f is a friend of a class, f has the same access to class as a function member has. We could write : Time A,B; A=B*2.5 ; // A=B.operator*(2.5); But not A=2.5*B;

Creating a Friend function friend Time operator*( double m, const Time &t); Place it in the class declaration. Time operator*(double m, const Time &t) { Time result; long totalmin=t.hours*m*60+t.minutes*m; result.hours=totalmin/60; result.minutes =totalmin % 60; return result; }

A=2.5*B; Is A=operator*(2.5,B); Time operator*(double m, const Time &t) { return t*m; }

Overload << We want to have Time t; cout<<t; instead of t.Show(); both cout and t are objects. If we want to overload << with a member function then we should write t<<cout; //odd

Add friend void operator<<(ostream &os,const Time &t); Then the body : void operator<<(ostream &os,const Time &t) { os<<t.hours<<“ hours, “<<t.minutes<<“minutes”; }

Can we write cout<< “ time “ << t<< “ Tuesday \n”; ?? No “ Note that cout<<x; return an object cout of class ostream”; int x,y; cout<<x<<y; we have (cout<<x) <<y;

ostream & operator<<(ostream &os,const Time &t) { os<<t.hours<<“hours,“<<t.minutes<<“minutes”; return os; }

Type Casting for Classes When we write long count=8; double time=11; we have conversion automatically.

#ifndef STONEWT_H_ #define STONEWT_H_ class Stonewt { private: enum{lbs_per_stn=14}; int stone; double pds_left; double pounds; public: Stonewt(double lbs); Stonewt(int stn, doub lbs); Stonewt(); ~Stonewt(); void show_lbs() ; void show_stn(); }; #endif;

#include #include “stonewt.h”; Stonwt::Stonewt(double lbs) { stone=int(lbs) / lbs_per_stn; pds_left=int(lbs)%lbs_per_stn+lbs-int(lbs); pounds=lbs; } Stonewt::Stonewt(int stn, double lbs) { stone=stn; pds_left=lbs; pounds=stn*lbs_per_stn+lbs; }

Stonewt::Stonewt() { stone=0; pound=pds_left=0.0; } void Stonewt::show_stn() { cout<<stone<<“ stone,“ <<pds_left<<“ pounds\n”; } void Stonewt::show_lbs() { cout<<pounds<<“ pounds\n”; }

now we can write Stonewt mycat; mycat=19.6; this conversion automatically happen and is implicit conversion. // it can lead to unexpected conversion In order to make a conversion explicit we can write explicit Stonewt(double lbs);

Stonewt mycat; mycat=19.6 // is not valid mycat=Stonewt(19.6); Can we convert an object to double ? Yes, but not using constructors. We can use conversion function.

#ifndef STONEWT_H_ #define STONEWT_H_ class Stonewt { private: enum{lbs_per_stn=14}; int stone; double pds_left; double pounds; public: Stonewt(double lbs); Stonewt(int stn, double lbs); Stonewt(); ~Stonewt(); void show_lbs() ; void show_stn(); operator int() const; operator double() const; }; #endif;

Stonewt::operator int() const { return int (pounds+0.5); } Stonewt::operator double() const { return pounds; }

We can write : Stonewt poppins(9,2.8); double p_wt= poppins; //implicit cout<<p_wt<<endl; cout<<int( poppins);