Introduction to operator overloading

. !" # $
%&
. ++. - . +)
. (..... =
" ' ( )$ ' $ * ++ $ '
+ ,' * -

cout << nX + nY << endl;

& / %.. && )$ ( !

$ ' * '.
: *

Mystring cStrin

!!!!!!! !. 0 )&

2 3 / 4 % 5 2 / ( ' $ ) + - 1!/ !

52 7 ( ' $ )+ , ' 6 *
2 4 %
 )$ " ) 5 ( ' $ )+ / $ #'
'
. 5 + / #!

, ' ' + %

... , +

- 5 2 5 9 %+
$ 8 2
:: (%

, ;7 5 ( # )$ - %.. !

3 / + )$

3 / + )$ , ;7 5
++ 7
(; ' $ ' )$ < ' 52

+ - * / = < > += -= *= /= << >>

<<= >>= == != <= >= ++ -- % & ^ ! |
~ &= ^= |= && || %= [] () , ->* -> new
delete new[] delete[]

:= (! - ! > 2
( ' $ )+ ( ' $ )+ '4 % -
% + ! - 524 % 6! 7 "
. + = ! =
' $ 1& ! - ! ' ' $ ! -
.
. = - <52
 2-Overloading the arithmetic operators

2 $ <52 ' / ? * ? -? + 2 / $- *%
. $ 1 '@ " / < * $

6 ! 7 A(4 % 17 ) )$ 8 1 ' %5
. &% ; /
& " % ' $ . + $ $/
*
class Cents
{
private:
int m_nCents;

public:
Cents(int nCents) { m_nCents = nCents; }

// Add Cents + Cents

! " # $ $ %

int GetCents() { return m_nCents; }

};

// note: this function is not a member function!

Cents operator+(const Cents &c1, const Cents &c2)
{
// use the Cents constructor and operator+(int, int)
# &'( &'( %
}

int main()
{
Cents c #)%
#*%
'
std::cout << "I have " << cCentsSum .GetCents() << " cents." <<
std::endl;

+
}
 : %. +

I have 14 cents.

$ 2 * $
% / $ <
.
! " # $ $ %

2. ; &% ! $ < ( ! <52

2 $' ! )$ . . 4 % , 4; !
.

: & $
/
Cents operator+(const Cents &c1, const Cents &c2)
{
// use the Cents constructor and operator+(int, int)
return Cents(c1.m_nCents + c2.m_nCents);
}

, ' 4 %,' A ' ! $

. * - %' - % " / 17 -
3 / %' - 17 ) " %- - =5
!!!!!.... <52 ' $ ; )& )
85 3 / 7 )$ - < %' - $"B
2<52 " / ( 7 ' * %' %' - '
. %;
 : %.& "
#)%
#*%
'

2 D %' C7
: 52 /- ! ($
% %;
'

Cents operator+
%' - 7
- C7 % %& ( % !
Cents cCentsSum & ! " # %

: %& )$ 6 D
Cents operator+(const Cents &c1, const Cents &c2)

. *! - !

# E
EE $
/# !
class Cents
{
private:
int m_nCents;

public:
Cents(int nCents) { m_nCents = nCents; }

// overload Cents + Cents

! " # $ $ %

// overload Cents - Cents

friend Cents operator-# $ $ %

int GetCents() { return m_nCents; }

};

// note: this function is not a member function!

Cents operator+(const Cents &c1, const Cents &c2)
{
// use the Cents constructor and operator+(int, int)
# &'( &'( %
}

// note: this function is not a member function!

Cents operator-(const Cents &c1, const Cents &c2)
{
// use the Cents constructor and operator-(int, int)
return Cents(c1.m_nCents - &'( %
}

. # 7 1 6 ' - - 7 B
.! ' - $ 9 6 + )$
( & = $ 5): # 7
 !

"#$ 6 * ' * ;$/ %& + $ 5

. " %$ %. + 4 % 5( 7 8

$ , 4; (- & $/ & * ' $ ++

. (

2 8 %5 )$. ( & 9 $ 4;
. 5 #' ( , 4;

,-. 6 + Cents(4) &" $ . Cents(4) + 6 *

%6 ; , 4; $ , - %5 ! &" $' /01234
:.. * " C7 . . %) F $/ %5

class Cents
{
private:
int m_nCents;

public:
Cents(int nCents) { m_nCents = nCents; }

// Overload cCents + int

friend Cents operator+(const Cents &cCents, int nCents);

// Overload int + cCents

friend Cents operator+(int nCents, const Cents &cCents);

int GetCents() { return m_nCents; }

};

// note: this function is not a member function!

Cents operator+(const Cents &cCents, int nCents)
{
return Cents(cCents.m_nCents + nCents);
}

// note: this function is not a member function!

Cents operator+(int nCents, const Cents &cCents)
{
return Cents(cCents.m_nCents + nCents);
}

int main()
{
#5% )
) #5%
66 7 8"9 &: #% & 66
66 7 8"9 &: #% & 66

+
}
 % /- $ 0
#5% )
( & "#$

. (; ) ' ! #

-: * * &
class MinMax
{
private:
int m_nMin; // The min value seen so far
int m_nMax; // The max value seen so far

public:
MinMax(int nMin, int nMax)
{
m_nMin = nMin;
m_nMax = nMax;
}

int GetMin() { return m_nMin; }

int GetMax() { return m_nMax; }

"; ! " # "; $ "; $ %

friend MinMax operator+(const MinMax &cM, int nValue);
friend MinMax operator+(int nValue, const MinMax &cM);
};

MinMax operator+(const MinMax &cM1, const MinMax &cM2)

{
// Get the minimum value seen in cM1 and cM2
&'( &'( < &'( 6 &'(

// Get the maximum value seen in cM1 and cM2

"; &'( "; = &'( "; < &'( "; 6 &'( ";

return MinMax(nMin, nMax);

}

MinMax operator+(const MinMax &cM, int nValue)

{
// Get the minimum value seen in cM and nValue
int nMin = cM.m_nMin < nValue ? cM.m_nMin : nValue;

// Get the maximum value seen in cM and nValue

int nMax = cM.m_nMax > nValue ? cM.m_nMax : nValue;

return MinMax(nMin, nMax);

}

MinMax operator+(int nValue, const MinMax &cM)

{
// call operator+(MinMax, nValue)
return (cM + nValue);
}

int main()
{
"; # + >%
"; #* %
"; # %

"; ? " > * )

std::cout << "Result: (" << cMFinal.GetMin() << ", " <<
cMFinal.GetMax() << ")" << std::endl;

+
}
 ' ! D 8" D %F / 4 % ' ' + 52
. %5 ! ( 8 ) % (; )

! % ' $

%' + %'

+ %'

%' +

%. +
Result: (3, 16)

(:... 6
 3-Overloading the I/O operators
:
>> and <<
! "# $% &' (' )
* % &+ ,#- &.
/01-

class Point
{
private:
double m_dX, m_dY, m_dZ;

public:
Point(double dX=0.0, double dY=0.0, double dZ=0.0)
{
m_dX = dX;
m_dY = dY;
m_dZ = dZ;
}

double GetX() { return m_dX; }

double GetY() { return m_dY; }
double GetZ() { return m_dZ; }
};

52 % / 4 % / ' 17 - ! 5
@ @ #>&+ )&+ A&+%
cout << "(" << cPoint.GetX() << ", " <<
cPoint.GetY() << ", " <<
cPoint.GetZ() << ")";

%& 5( ( % ! @ ** )) 4
@ @ #>&+ )&+ A&+%
cout << cPoint;

4; )) . ( % + 4; ! .
&" + , +, $
. - /- 4 ( )) ) * -
 - $ ' cout << cPoint <52 $'
. %' 4 %2 - %' 2
. - 4 % %' 2
%&
friend ostream& operator<< (ostream &out, Point &cPoint);

* - , $ ** ++ !
, , 17 - 6
.. ! )) 2$ $ !
6 * $
/
class Point
{
private:
double m_dX, m_dY, m_dZ;

public:
Point(double dX=0.0, double dY=0.0, double dZ=0.0)
{
m_dX = dX;
m_dY = dY;
m_dZ = dZ;
}

friend ostream& operator<< (ostream &out, Point &cPoint);

double GetX() { return m_dX; }

double GetY() { return m_dY; }
double GetZ() { return m_dZ; }
};

ostream& operator<< (ostream &out, Point &cPoint)

{
// Since operator<< is a friend of the Point class, we can access
// Point's members directly.
out << "(" << cPoint.m_dX << ", " <<
cPoint.m_dY << ", " <<
cPoint.m_dZ << ")";
return out;
}
 ! = > G< C7 % 1&
'
ostream& operator<< (ostream &out, Point &cPoint)
{
// Since operator<< is a friend of the Point class, we can access
// Point's members directly.
out << "(" << cPoint.m_dX << ", " <<
cPoint.m_dY << ", " <<
cPoint.m_dZ << ")";
return out;
}

:!!.. / 5 ,' # 2
/H ! 4 % ! 2 D,' # !
* 0 $ 4;
cout << cPoint << endl;
# ) ! ". D,' A 5 $
%& 9 (
$ % (
cout << cPoint << endl;
.! / - 06 ! ('
! <5( ('
"cout << cPoint )<< endl;
- 4 D- - #
5%2 2 % A
%C"
cout << cPoint
2 & ' - 5; -
C" ! $% '
 0 ** 1
. $ % 1!/ 2 & - <52
- , D,' # 2 5(
%& 5; . - , D,' A D # !
5; .
"cout << cPoint )<< endl;

cout << cPoint

2 ' *
2 ( $% C"
** 1
- , D,' 2 C " 5; 52
' -I D * < < %&
^_*... &
% % -
int main()
{
@ @ # &+ &+ 5&+%
@ @ #)&+ A&+ *&+%

using namespace std;

@ @

+
}

%& %. '/
(2.0, 3.0, 4.0) (6.0, 7.0, 8.0)
 52 ;$/ ! . 6 * $* 52
(:... ! - , %' 2
4 % * 52

class Point
{
private:
double m_dX, m_dY, m_dZ;

public:
Point(double dX=0.0, double dY=0.0, double dZ=0.0)
{
m_dX = dX;
m_dY = dY;
m_dZ = dZ;
}

friend ostream& operator<< (ostream &out, Point &cPoint);

friend istream& operator>> (istream &in, Point &cPoint);
double GetX() { return m_dX; }
double GetY() { return m_dY; }
double GetZ() { return m_dZ; }
};

ostream& operator<< (ostream &out, Point &cPoint)

{
// Since operator<< is a friend of the Point class, we can access
// Point's members directly.
out << "(" << cPoint.m_dX << ", " <<
cPoint.m_dY << ", " <<
cPoint.m_dZ << ")";
return out;
}

istream& operator>> (istream &in, Point &cPoint)

{
in >> cPoint.m_dX;
in >> cPoint.m_dY;
in >> cPoint.m_dZ;
return in;
}

)) ** $ / ! * 52
int main()
{
using namespace std;
cout << "Enter a point: " << endl;

Point cPoint;
cin >> cPoint;

cout << "You entered: " << cPoint << endl;

+
}

$
/ = > ;
3.0 4.5 7.26
%& %. '/
You entered: (3, 4.5, 7.26)

8 7; 2 ! - /-
5% * 7 $
*- % % * * % *

friend ostream& operator<< (ostream &out, Point

&cPoint);

5%2 7-

friend ostream& operator<< (ostream &out, const

Point &cPoint);

. $ 52
 4-Overloading operators using member functions

*23-+4 05+ 06$7 89

: $;<= >< 0 ; )
3-+: $4 ? @95
friend function
*206$7 89
: $;<= > ) / 65@ ;: '
? @95
Member function
3-+: $4 ? @ 3/ A@ # ; 0 ? @>
: 0 A 76 B ;5=C2
.% &+ D# E 4 3/ F+>5 (#+$( 5 G$ H@# -
2+ 7 A - ! -
' ( ! ') ! &-
&" $ **" -3 $

! ' * +&,#"
!. () - ' ( )( ' (=) ' -

: ' 0 1 -/ ! ' .)
! ) ....(-) + *' 2 #

#/
 class Cents
{
private:
int m_nCents;

public:
Cents(int nCents) { m_nCents = nCents; }

// Overload -cCents
friend Cents operator-(const Cents &cCents);
};

// note: this function is not a member function!

Cents operator-(const Cents &cCents)
{
return Cents(-cCents.m_nCents);
}

- -, % (;
class Cents
{
private:
int m_nCents;

public:
Cents(int nCents) { m_nCents = nCents; }

// Overload -cCents
Cents operator-();
};

// note: this function is a member function!

Cents Cents::operator-()
{
return Cents(-m_nCents);
}

/ A0 % 52 /- ' - &
%. : $ % < - -,
%' - 4; ) & 2 + 7 - -,
. $ 7 % 4 % 4;
. ) F 2 + )$ < -
&%; $ %I ' %5
52 *
 Cents Cents::operator-();
BC- DEFGHI2J KHLG MNOP
Cents operator-(const Cents *this)

%& ( # )

Cents operator-(const Cents &cCents)

)! ) 2
.
)$ ' )
class Cents
{
private:
int m_nCents;

public:
Cents(int nCents) { m_nCents = nCents; }

// Overload cCents + int

friend Cents operator+(Cents &cCents, int nCents);

int GetCents() { return m_nCents; }

};

// note: this function is not a member function!

Cents operator+(Cents &cCents, int nCents)
{
return Cents(cCents.m_nCents + nCents);
}

)
class Cents
{
private:
int m_nCents;

public:
Cents(int nCents) { m_nCents = nCents; }

// Overload cCents + int

Cents operator+(int nCents);

int GetCents() { return m_nCents; }

};

// note: this function is a member function!

Cents Cents::operator+(int nCents)
{
return Cents(m_nCents + nCents);
}

! #" 4*5 +3
"
!0 #" ! , */ .
.#
2- 0 6' 0 ! 4
) ' # 6 ! '! *8 7 #"

friend operator+(int, cCents)

( 5 #" 0 ( #"# 0 !' # 6 ! '+&,

... 91 &,
 5-Overloading the increment and decrement operators
*2*:decrement (--) (++) increment /; I$;<!
prefix D# ( eg. nX++; nY--;) postfix 3 # =# <

. ( eg. ++nX; )
--nY;

Overloading prefix increment and decrement

unary 0$ &/; / A4$;<! KJ$ Prefix
.
L. ,#- #
class Digit
{
private:
int m_nDigit;
public:
Digit(int nDigit=0)
{
m_nDigit = nDigit;
}

Digit& operator++();
Digit& operator--();

int GetDigit() const { return m_nDigit; }

};

Digit& Digit::operator++()
{
// If our number is already at 9, wrap around to 0
if (m_nDigit == 9)
'( Q +
// otherwise just increment to next number
else
++m_nDigit;

return *this;
}

Digit& Digit::operator--()
{
// If our number is already at 0, wrap around to 9
if (m_nDigit == 0)
'( Q R
// otherwise just decrement to next number
else
--m_nDigit;

return *this;
}
- ++ ; < 2 3 2 : .& %! - : $ (5
.& % !0 4"* $ # --

#, $ ! , 5 2 = # : !94*5
.$ ! % , # "

'
5 > ,! '( ! 2 = 2 #"
2 =#" % * , &, . 2 99 8

& ( ) / ( * 6 ' '

?6 2 = (# ) ( !

! & 9#, ! ! ) > ,++ # #"

$ $ &, ' ! ' 3 #
... ! ) "
class Digit
{
private:
int m_nDigit;
public:
Digit(int nDigit=0)
{
m_nDigit = nDigit;
}

Digit& operator++(); // prefix

Digit& operator--(); // prefix

Digit operator++(int); // postfix

Digit operator--(int); // postfix

int GetDigit() const { return m_nDigit; }

};

Digit& Digit::operator++()
{
// If our number is already at 9, wrap around to 0
if (m_nDigit == 9)
'( Q +
// otherwise just increment to next number
else
++m_nDigit;

return *this;
}

Digit& Digit::operator--()
{
// If our number is already at 0, wrap around to 9
if (m_nDigit == 0)
'( Q R
// otherwise just decrement to next number
else
--m_nDigit;

return *this;
}
Digit Digit::operator++(int)
{
// Create a temporary variable with our current digit
Digit cResult(m_nDigit);

// Use prefix operator to increment this digit

++(*this); // apply operator

// return temporary result

return cResult; // return saved state
}
Digit Digit::operator--(int)
{
// Create a temporary variable with our current digit
Digit cResult(m_nDigit);

// Use prefix operator to increment this digit

--(*this); // apply operator

// return temporary result

return cResult; // return saved state
}
int main()
{
Q Q #>%
++cDigit; // calls Digit::operator++();
cDigit++; // calls Digit::operator++(int);
 @6; B#') % )JF ( ! > 2
4 4
5 7K 4 4 D; D-
8 52 B $ % / 2 )$ " -
/ -
%' - ($
% ( 4; 4 4 ( 2@ 2 ) -6
%' - ' 4 . ' /- %
2+ ' * 3 L $ ! % $
%.& D52 % &< 2 ' /M 4 %
M' /
5 - "$

5 - (71

** - &&1

** -1

: %1

!. * % 7 !. ) @
$ * 6! & B 4 2' %; 2
.
,' J)J F 8 4 % ( %; 4;
. " B $ D %' -
$
%& 2
D 4; " B $ %' - ,' J -
" B $ <'. $ D %' - ' B
!!:::!!!!!!!!.
D0; D 8 / 2$ %& <52 ! 7A
.( 4 1 ) M ;4 % * %' -
)$ " 5% 1 - ! )J D 8 ,' J *
)$ D D 4; $ D %' - /
. M ; %' -
! - ' B 0-
%5 C =5 . 8 )J
D2 J ,' J % - @
. &%; ( J
... N ' 52 % & /@ ! (; %
#include <iostream>
using namespace std;

class Digit
{
private:
int m_nDigit;
public:
Digit(int nDigit=0)
{
m_nDigit = nDigit;
}

Digit& operator++(); // prefix

Digit& operator--(); // prefix

Digit operator++(int); // postfix

Digit operator--(int); // postfix
friend ostream &operator<<(ostream &out,Digit &digit);
};
ostream &operator<<(ostream &out,Digit &digit)
{
out<<digit.m_nDigit<<endl;
return out;
}
Digit& Digit::operator++()
{
// If our number is already at 9, wrap around to 0
if (m_nDigit == 9)
'( Q +
// otherwise just increment to next number
else
++m_nDigit;

return *this;
}

Digit& Digit::operator--()
{
// If our number is already at 0, wrap around to 9
if (m_nDigit == 0)
'( Q R
// otherwise just decrement to next number
else
--m_nDigit;

return *this;
}

Digit Digit::operator++(int)
{
// Create a temporary variable with our current digit
Digit cResult(m_nDigit);

// Use prefix operator to increment this digit

++(*this); // apply operator

// return temporary result

return cResult; // return saved state
}

Digit Digit::operator--(int)
{
// Create a temporary variable with our current digit
Digit cResult(m_nDigit);

// Use prefix operator to increment this digit

--(*this); // apply operator

// return temporary result

return cResult; // return saved state
}

int main()
{
Q Q #>% Q #+%

cout<<++cDigit; // calls Digit::operator++();

Q // calls Digit::operator++(int);

system("pause");
return +
}
 6-Overloading the subscript operator
0:#4M N K O# ( [] ) ? G 9
: :#4M / ;
" S " T+U A VV ! 8 value 7 in the first element of
the array

0:#4M/ =# $IntList * % &+ ,#G

class IntList
{
private:
'(" W T +U
};

int main()
{
IntList cMyList;
+
}

. & ( " % ;"

/ =5
class IntList
{
private:
'(" W T +U

public:
void SetItem(int nIndex, int nData) { m_anList[nIndex] = nData;
}
int GetItem(int nIndex) { return m_anList[nIndex]; }
};
int main()
{
IntList cMyList;
W & 7 '# %

+
}

6 D " ) D D " ) 6 D A D2
. 7 G) 2& 5
 '$ ;" ! % <= 2 ! 7A
<= 2 * &. )
- -, % #' , - 2 ,
M D' 4% - 2 ' , 2
;"

class IntList
{
private:
'(" W T +U

public:
int& operator[] (const int nIndex);
};

int& IntList::operator[] (const int nIndex)

{
return m_anList[nIndex];
}

-> ? ) " ! . %' - <= / -

' ( - ($ &
IntList cMyList;
W T U VV " 9"
W T U VV " 9"

. / A6 % C7 52 %
 7-Overloading the parenthesis operator
I $ /; 3/D# C2( ) % #P #20 J+ ,#@=C /;
parameter /Q /06 ( #2 06 3 HG5,&
0$ ;<! 0 0 Rparameter 2 =# <== 0 &. /
.( ) /Q5 6G<A
SG /Q 3/0 A A <( 3+$% #P 0 3+
. 0 prototype
. member function '0 (#+<( 5 % #P I$;<!
* L. ,#-

class Matrix
{
private:
X " Q" "T5UT5U
public:
Matrix()
{
// Set all elements of the matrix to 0.0
# + 5 %
# Y Z + Y Z 5 Y Z %
" Q" "T Y ZUT U +&+
}
};

! % (; A D <= 4 D- 4
. " / 4 % 17 ( O) - ;" ) "
) ! - ( - ) )$ < <= -
. O * %) "
" ! =5 *
% )$ < % () %
. 2 O % ( ;" %
. O ;" 6 * 8
 ;" N " <B) " $()
: * &

#include <cassert> // for assert()

class Matrix
{
private:
double adDataT5UT5U
public:
Matrix()
{
// Set all elements of the matrix to 0.0
# + 5 %
# Y Z + Y Z 5 Y Z %
" Q" "T Y ZUT U +&+
}

double& operator()(const int nCol, const int nRow);

};

& ! 17 - ) " 4 % -

Matrix cMatrix;
" ;# % 5&>
66 " ;# %

double& Matrix::operator()(const int nCol, const int nRow)

{
" # = + $$ 5%
" # Y Z = + $$ Y Z 5%

return adData[nRow][nCol];
}

%& %. '/

4.5
 () $
/ -
#include <cassert> // for assert()
class Matrix
{
private:
X " Q" "T5UT5U
public:
Matrix()
{
// Set all elements of the matrix to 0.0
# + 5 %
# Y Z + Y Z 5 Y Z %
" Q" "T Y ZUT U +&+
}

double& operator()(const int nCol, const int nRow);

void operator()();
};

double& Matrix::operator()(const int nCol, const int nRow)

{
" # = + $$ 5%
" # Y Z = + $$ Y Z 5%

return adData[nRow][nCol];
}

void Matrix::operator()()
{
// reset all elements of the matrix to 0.0
# + 5 %
# Y Z + Y Z 5 Y Z %
" Q" "T Y ZUT U +&+
}

;" C () ! %& ( /
Matrix cMatrix;
" ;# % 5&>
cMatrix(); // erase cMatrix
66 " ;# %

%. '/
0

. ( $ *
%6 ! ( / % () ;& *
... $ 52
 8-Overloading typecasts
T/ int D# 3/ T/ @ 3+$0 ++ *G 5, ;/#2 '
.typecast L ? @9
5double &.
/D# 3/ U
int nValue = >
double dValue = nValue; // int implicitly cast to a double

. , - ( % ++
% ! #' M& 4 %<B % - %
. /H, ) , %
. /H, ) 4 % C
: 4 % &
class Cents
{
private:
int m_nCents;
public:
Cents(int nCents=0)
{
m_nCents = nCents;
}

int GetCents() { return m_nCents; }

void SetCents(int nCents) { m_nCents = nCents; }
};

8 ) " $ / ! C7 4 %
.
52 4 % ! % -
D C" ) $ #' ' , 8
: - C7 % * &. ) %
void PrintInt(int nValue)
{
cout << nValue;
}

int main()
{
#A%
@ 7 # &: #%% VV ! A

+
}
$
( <52 ! 8" + %5 ! ! ! /
*
% *
% &%; %+ = %5 %
. - *
%+ =$
( .
) % ! 7
: * &
class Cents
{
private:
int m_nCents;
public:
Cents(int nCents=0)
{
m_nCents = nCents;
}

// Overloaded int cast

operator int() { return m_nCents; }

int GetCents() { return m_nCents; }

void SetCents(int nCents) { m_nCents = nCents; }
};

. P =2 0-
. 5 &% ; *
: %& ( .
int main()
{
#A%
@ 7 # % VV ! A

+
}

:.. " ; $
/
, . 5 &. - -
.
. ' 4 0 O *-
 ) "/ ! = 2 % 59 *-
"$ *2 ' . !
.. 5 ) * ' <52 $ <5( $
* ' 8 <B) 4 % - %
#A%
int nCents = static_cast<int>(cCents);

(A
& , 1 , %
. ) ;& *
. (& , $ * & $
/
*- ' 4 %# % $
/
.... 4 % & - ) %
class Dollars
{
private:
int m_nDollars;
public:
Dollars(int nDollars=0)
{
m_nDollars = nDollars;
}

// Allow us to convert Dollars into Cents

o! " #% [ #'( Q " \ ++% ]
};

4 % %' <B) - 4 % %' <B / 52

.... & 4
: /
void PrintCents(Cents cCents)
{
cout << cCents.GetCents();
}

int main()
{
Q " Q " #R%
PrintCents(cDollars); // cDollars will be cast to a Cents

+
}
 %. '/
@%%
.4 ) - D= 5
. *
% D! ( / % ( ;& *
... $ 52