Savitch Chapter 10

1
Savitch Chapter 10

• Defining Classes
• Topics
• Structures
• Class Definitions
• Members
• Data Members
• Member Functions
• Public/Private Sections
• Types of Member Functions

2
Structured Data
A major problem with modular code is the need to
use a large number of parameters to deal with
several objects that might be closely related to
each other. A preferable approach would be to
group these values together in a single
structure, which could easily be passed to a
function as a single parameter.
void processSale (string inventoryNbr, float
price, float weight, int
nbrInStock, int
nbrSoldThisYear, int storeNbr,
int month, int day, int year,
float time)
void processSale (Merchandise itemSold, Time
timeOfSale)
3
Structs in C
C provides a struct mechanism for defining such
structures.
struct Merchandise string inventoryNbr
float price float weight int nbrInStock
int nbrSoldThisYear int storeNbr
struct Time int month int day int
year float timeOfDay
4
Structure Variables and Parameters
Once a struct has been defined, variables of that
type can be declared.
const float EmployeeDiscountPercent int
dailyQuota Merchandise saleItem,
itemSold Time timeOfSale, openingTime,
closingTime
And parameters and functions of that type can be
used.
void processSale (Merchandise itemSold, Time
timeOfSale) Time calculateStoreClosing(int
monthNo, int dayNo, int yearNo) ? void
main() ? closingTime calculateStoreClosi
ng(12, 24, 1998) processSale(saleItem,
closingTime) ?
5
Working with the Structure Members
The data elements comprising a struct are known
as its members. The members are accessed by means
of the C dot notation.
Time calculateStoreClosing(int monthNo, int
dayNo, int yearNo) Time t t.month
monthNo t.day dayNo t.year yearNo
if ((monthNo 12) (dayNo 24))
t.timeOfDay 18.00F else t.timeOfDay
22.00F return t void processSale
(Merchandise itemSold, Time timeOfSale) if
(timeOfSale.timeOfDay lt 8.00)
itemSold.price - EmployeeDiscountPercentitemSold
.price itemSold.nbrInStock--
itemSold.nbrSoldThisYear
6
Classes in C

• Classes allow for the combining of a data set
  with a set of functions that work on that data
  set
• This allows for less cumbersome parameter lists,
  and allows the data better protection from being
  set to invalid values.

7
C Classes
To enhance modularity and information hiding even
further, it would be nice if we could create
types for which the internal workings are
private to the rest of our program, and which
can only be accessed or altered by means of
specified public functions.
BankAccount acct cout gtgt Enter interest rate
cin ltlt acct.intRate
BankAccount acct float rate cout gtgt Enter
interest rate cin ltlt rate acct.setIntRate(rat
e) ? void BankAccountsetIntRate(float r)
if ((rlt0.0F) (rgt0.1F)) intRate
0.01F else intRate r return
Doesnt prevent rates below 0 or above 10!
Does prevent rates below 0 or above 10!
8
The C class
C provides a class mechanism for defining such
types.
class BankAccount public void
setIntRate(float newIntRate) void
setBalance(float newBalance) bool
checkAcctNbr(string testAcctNbr) bool
checkATMCode(string testATMCode) float
getIntRate() float getBalance()
private void setAcctNbr(string
newAcctNbr) void setATMCode(string
newATMCode) string getAcctNbr()
string getATMCode() float intRate
float balance string acctNbr string
atmCode
Prototypes for public member functions, which
can be used by any function that declares a
variable of this type.
Prototypes for private member functions, which
can only be used by the other member functions of
this type.
Private data members, which can only be used by
the member functions of this type.
9
The Scope Resolution Operator
When implementing the member functions, the
compiler needs to know that they are members of
the class, and are only defined within the
context of the object thats using them. The
scope resolution operator, , is used to
accomplish this.
void BankAccountsetIntRate(float newIntRate)
if ((newIntRate lt 0.0F) (newIntRate gt
0.1F)) intRate 0.01F else
intRate newIntRate bool BankAccountcheckAT
MCode(string testATMCode) return (atmCode
testATMCode) string BankAccountgetATMCode()
return atmCode
10
Working with the Class Members
Just like with structures, the dot operator is
used to access class members, both data members
and member functions.
void validateAcctNbr(BankAccount acct, string
nbr) if (accountNumber nbr) cout ltlt
Account Number Validated else cout ltlt
Account Number Invalid! Call the cops!
Compilation Error! accountNumber is not a
variable in this function!
Compilation Error! accountNumber is a private
data member of the BankAccount class!
void validateAcctNbr(BankAccount acct, string
nbr) if (acct.accountNumber nbr)
cout ltlt Account Number Validated else
cout ltlt Account Number Invalid! Call the
cops!
void validateAcctNbr(BankAccount acct, string
nbr) if (acct.getAcctNbr() nbr)
cout ltlt Account Number Validated else
cout ltlt Account Number Invalid! Call the
cops!
Compilation Error! getAcctNbr is a private member
function of the BankAccount class!
void validateAcctNbr(BankAccount acct, string
nbr) if (acct.checkAcctNbr(nbr)) cout
ltlt Account Number Validated else cout
ltlt Account Number Invalid! Call the cops!
No problemo! checkAcctNbr is a public member
function of the BankAccount class!
11
A Complete Example
// circleDrawingDriver.cpp
// // This program
generates circle data and draws them using ASCII
characters. // include ltiostreamgt include
ltiomanipgt include ltcmathgtusing namespace
std const float PI 3.1416F const int PADDING
3 const int ASCII_ZERO_VALUE 48 class
Circle public Circle() //
Constructor bool setCoordinates(int x, int
y) // Mutator functions bool setRadius(int
r) bool setASCIICharacter(char ch)
float computeArea() // Member functions
float computePerimeter() void
displayCircleAttributes() void
drawCircle() int getXCoord() const //
Accessor functions int getYCoord() const
int getRadius() const char
getASCIICharacter() const private int
xCoord // Data members int yCoord
int radius char asciiCharacter //
Notice the REQUIRED semicolon!
Constructors create new objects of this class
with no parameters, this ones known as the
default constructor, and is called whenever a
variable of type Circle is declared.
The declaration of the Circle class.
Mutator functions allow programmers to change
data member values.
Regular public member functions they can be
called by any function with a Circle variable.
Accessor public member functions they can access
but not alter a Circle object.
Private data members they can only be used by
Circle member functions.
12
The Circle Example (Continued)
//////////////////////////////////////////////////
//////////////// // The main function serves as a
driver to display a variety of // // circles with
a variety of sizes, positions, and characters.
// ///////////////////////////////////////////////
/////////////////// void main() Circle
circ char YorN int count 1 int
positionX 4 int positionY 2 cout ltlt
"Ready for the first circle? (Enter Y or N) "
cin gtgt YorN while ((YorN 'y') (YorN
'Y')) circ.setASCIICharacter(char(ASCII
_ZERO_VALUEcount)) circ.setRadius(count3)
circ.setCoordinates(positionX,positionY)
circ.displayCircleAttributes()
circ.drawCircle() cout ltlt "Ready for
another circle? (Enter Y or N) " cin gtgt
YorN count positionX (positionX
11) 13 positionY (positionY 13)
11 return
The declaration of a variable of type Circle.
Calling some of Circles public member functions
note the use of the dot notation.
13
The Circle Example (Continued)
// This default constructor sets up the data
members with default values. // CircleCircle()
xCoord yCoord radius 0
asciiCharacter ' ' // Assign the x- and y-
coords of the circle's center with parameterized
values. // bool CirclesetCoordinates(int x, int
y) xCoord x yCoord y return
true // Assign the radius of the circle the
parameterized value. // bool CirclesetRadius(int
r) if(r lt 0) return false radius
r return true // Assign the fill
character of the circle the parameterized value.
// bool CirclesetASCIICharacter(char ch)
asciiCharacter ch return true
The Circles default constructor initializes the
data members default constructors do not have to
do initialization.
Notice that the dot operator is not needed to
access members inside member functions themselves.
14
The Circle Example (Continued)
// Compute and return the area of the circle.
// float CirclecomputeArea() return PI
radius radius // Compute and return the
perimeter of the circle. // float
CirclecomputePerimeter() return 2 PI
radius // Output the circle's data member
values, as // // well as the area and
perimeter of the Circle. // void
CircledisplayCircleAttributes()
cout.setf(iosfixed) cout ltlt
setprecision(4) cout ltlt "Center's
x-coordinate " ltlt xCoord ltlt endl
cout ltlt "Center's y-coordinate " ltlt yCoord
ltlt endl cout ltlt "Circle's radius
" ltlt radius ltlt endl cout ltlt
"Circle's area " ltlt computeArea()
ltlt endl cout ltlt "Circle's perimeter "
ltlt computePerimeter() ltlt endl cout ltlt
"Circle's fill character " ltlt asciiCharacter
ltlt endl
Also notice that the dot operator is not needed
to access member functions in member functions
themselves the compiler still recognizes that
the Circle being operated upon is the one being
referred to.
15
The Circle Example (Continued)
// Output the Circle, using its ASCII character
to draw it, // // as well as vertical and
horizontal symbols to draw the // // coordinate
axes, and an 'X' at the center of the circle.
// void CircledrawCircle() const int
PADDING 4 const float HEIGHT_WIDTH_RATIO
1.5F int lowerX (xCoord-radius lt -PADDING)
? (xCoord-radius-PADDING) -PADDING int
upperX (xCoordradius gt PADDING) ?
(xCoordradiusPADDING) PADDING int lowerY
(yCoord-radius lt -PADDING) ? (yCoord-radius-PADD
ING) -PADDING int upperY (yCoordradius gt
PADDING) ? (yCoordradiusPADDING) PADDING
for (int y upperY y gt lowerY y--)
for (int x int(HEIGHT_WIDTH_RATIOlowerX) x
lt int(HEIGHT_WIDTH_RATIOupperX) x)
if ((x xCoord) (y yCoord))
cout ltlt 'X' else if
(pow((x-xCoord)/HEIGHT_WIDTH_RATIO,2)
pow(y-yCoord,2) lt pow(radius,2))
cout ltlt asciiCharacter else if ((x
0) (y 0)) cout ltlt ''
else if (x 0) cout ltlt ''
else if (y 0) cout ltlt '-'
else cout ltlt ' '
cout ltlt endl
16
The Circle Example (Continued)
// Access and return the Circle's x-coordinate
value. // int CirclegetXCoord() const
return xCoord // Access and return the
Circle's y-coordinate value. // int
CirclegetYCoord() const return
yCoord // Access and return the value of the
Circle's radius. // int CirclegetRadius()
const return radius // Access and return
the value of the Circle's ASCII fill character.
// char CirclegetASCIICharacter() const
return asciiCharacter
The accessor functions have been set up as
constant member functions this guarantees that
calling them will not alter the values of any of
the Circles data members..
17
The Circle Example (Continued)
18
Class Definition and Implementation Files
//////////////////////////////////////////////////
/////// // circle.h The class definition for the
Circle class // //////////////////////////////////
/////////////////////// ifndef
CIRCLE_Hincludeltiostreamgtusing namespace
std class Circle public
Circle() // Constructor void
setCoordinates(int x, int y) // Member
functions void setRadius(int r) void
setASCIICharacter(char ch) float
computeArea() float computePerimeter()
void displayCircleAttributes() void
drawCircle() int getXCoord() const //
Accessor functions int getYCoord() const
int getRadius() const char
getASCIICharacter() const private int
xCoord // Data members int yCoord
int radius char asciiCharacter //
Notice the REQUIRED semicolon! define
CIRCLE_H endif
To relieve the programmer from the burden of
rebuilding the code associated with a completed
class, and to make the class reusable with other
driver programs, the class definition is normally
placed in a header file and the class
implementation is normally placed in a separate
program file.
The Circles class definition file circle.h
19
The Class Implementation File circle.cpp
// Access and return the Circle's x-coordinate
value. // int CirclegetXCoord() const
return xCoord // Access and return the
Circle's y-coordinate value. // int
CirclegetYCoord() const return
yCoord // Access and return the value of the
Circle's radius. // int CirclegetRadius()
const return radius // Access and return
the value of the Circle's ASCII fill character.
// char CirclegetASCIICharacter() const
return asciiCharacter
// Output the Circle, using its ASCII character
to draw it, // // as well as vertical and
horizontal symbols to draw the // // coordinate
axes, and an 'X' at the center of the circle.
// void CircledrawCircle() const int
PADDING 4 const float HEIGHT_WIDTH_RATIO
1.5F int lowerX (xCoord-radius lt -PADDING)
? (xCoord-radius-PADDING) -PADDING int
upperX (xCoordradius gt PADDING) ?
(xCoordradiusPADDING) PADDING int lowerY
(yCoord-radius lt -PADDING) ? (yCoord-radius-PADD
ING) -PADDING int upperY (yCoordradius gt
PADDING) ? (yCoordradiusPADDING) PADDING
for (int y upperY y gt lowerY y--)
for (int x int(HEIGHT_WIDTH_RATIOlowerX)
x lt int(HEIGHT_WIDTH_RATIOupperX)
x) if ((x xCoord) (y
yCoord)) cout ltlt 'X' else
if (pow((x-xCoord)/HEIGHT_WIDTH_RATIO,2)
pow(y-yCoord,2) lt pow(radius,2))
cout ltlt asciiCharacter else if
((x 0) (y 0)) cout ltlt '' else
if (x 0) cout ltlt '' else if (y
0) cout ltlt '-' else cout ltlt ' '
cout ltlt endl
// Assign the fill character of the circle the
parameterized value. // void CirclesetASCIIChara
cter(char ch) asciiCharacter ch
return // Compute and return the area of the
circle. // float CirclecomputeArea()
return PI radius radius // Compute and
return the perimeter of the circle. // float
CirclecomputePerimeter() return 2 PI
radius // Output the circle's data member
values, as // // well as the area and
perimeter of the Circle. // void
CircledisplayCircleAttributes()
cout.setf(iosfixed) cout ltlt
setprecision(4) cout ltlt "Center's
x-coordinate " ltlt xCoord ltlt endl
cout ltlt "Center's y-coordinate " ltlt yCoord
ltlt endl cout ltlt "Circle's radius
" ltlt radius ltlt endl cout ltlt
"Circle's area " ltlt computeArea()
ltlt endl cout ltlt "Circle's perimeter "
ltlt computePerimeter() ltlt endl cout ltlt
"Circle's fill character " ltlt asciiCharacter
ltlt endl
//////////////////////////////////////////////////
/////////////// // circle.cpp The class
implementation for the Circle class.
// ///////////////////////////////////////////////
////////////////// include ltiostreamgt include
ltiomanipgt include ltcmathgt include
"circle.husing namespace stdconst float PI
3.1416Fconst int PADDING 3// This default
constructor sets up the data members with default
values. //CircleCircle() xCoord yCoord
radius 0 asciiCharacter ' //
Assign the x- and y- coordinates of the circle's
center with parameterized values. //bool
CirclesetCoordinates(int x, int y) xCoord
x yCoord y return true// Assign
the radius of the circle the parameterized value.
//bool CirclesetRadius(int r) if(r lt 0)
return false radius r return true
20
The Driver File circleDrawingDriver2.cpp
// circleDrawingDriver2.cpp
// //
This program generates the data for circles and
then draws them using ASCII characters.
// include ltiostreamgt include "circle.h"using
namespace std const int ASCII_ZERO_VALUE
48 // The main function displays a variety of
circles. // void main() Circle circ char
YorN int count 1 int positionX 4
int positionY 2 cout ltlt "Ready for the
first circle? (Enter Y or N) " cin gtgt YorN
while ((YorN 'y') (YorN 'Y'))
circ.setASCIICharacter(char(ASCII_ZERO_VALUEcoun
t)) circ.setRadius(count3)
circ.setCoordinates(positionX,positionY)
circ.displayCircleAttributes()
circ.drawCircle() cout ltlt "Ready for
another circle? (Enter Y or N) " cin gtgt
YorN count positionX (positionX
11) 13 positionY (positionY 13)
11 return
21
An Alternative Driver
//////////////////////////////////////////////////
// // diagonalDotDriver.cpp
// // This program generates same-sized
circles that // // are displayed at a diagonal to
each other. // ///////////////////////////////
///////////////////// include ltiostreamgt include
"circle.h"using namespace std ////////////////
//////////////////////////////////////// // The
main function drives the diagonal dot display.
// ///////////////////////////////////////////////
///////// void main() Circle circ
circ.setASCIICharacter('O')
circ.setRadius(4) for (int i 0 i lt 40 i
8) circ.setCoordinates(i,0)
circ.drawCircle() return
Note that this driver requires no changes to the
definition of the Circle class!
22
Constructors
There are three basic types of constructors in
C programming.
CircleCircle() xCoord yCoord radius
0 asciiCharacter ' '
Default Constructor Called when a new variable of
this type is declared. (Only one allowed.)
CircleCircle()
CircleCircle(int x, int y, int r, char
ch) xCoord x yCoord y radius
r asciiCharacter ch
Initializing Constructor Called when variable of
this type is having some or all of its data
member values initialized. (More than one
allowed.)
CircleCircle(char ch) asciiCharacter
ch
CircleCircle(const Circle c) xCoord
c.xCoord yCoord c.yCoord radius
c.radius asciiCharacter c.asciiCharacter
Copy Constructor Called when a variable of this
type is passed by value to a function. (Only one
allowed.)
Note that constructors always have the same name
as the class.
23
Calling the Constructors
Default Constructor Dont call it with the empty
parentheses the compiler might conclude that
this is a prototype!
void main() Circle roundo ?
void main() Circle C1(3,-2,7,) C2
Circle(!) ?
Initializing Constructor As long as the parameter
lists differ in type, the compiler wont get
confused.
void main() Circle bigArc ?
smileyFace(bigArc) ? ? void
smileyFace(Circle button) ?
Copy Constructor You might be able to pass by
value without one, but the results would be
unpredictable.
24
Abstract Data Types
To what extent does a programmer need to know the
implementation of the Circle class in order to
use it in a driver?
Does the programmer need to know the types of the
data members in order to use the
constructors? Perhaps with that initializing
constructor...
Does the programmer need to know how the area and
perimeter are being computed? Nope!
Does the programmer need to know anything about
the data members in order to draw the circle or
display its attributes? Not really...
Does the programmer need to know the types of the
data members in order to set them or access
them? Well, yeah...
If the programmers who use a data type dont have
to know how its members are implemented, then
its considered an abstract data type.
25
Advantages of ADTs
By limiting the required understanding of the
class to the public members, modifiability,
readability, and reusability are all enhanced!
Object-Oriented Emphasis on what is being done
Procedural Emphasis Upon How To Do Things
26
Achieving ADT Status in C
Private Members Only! (At least, private data
members only!)
Basic Public Broadcasting! (That is, use public
member functions for only basic operations, and
ensure that users know how to use them!)
Show A Little Class! (Put your class definition
and your class implementation in separate .h and
.cpp files!)