5

Using Classes

Object-Oriented Programming
Using C++
Second Edition
5
Objectives

In this chapter, you will learn:

How to include declaration and implementation

sections within classes

How and when to use public and private access

modifiers in class definitions

How to use private functions

5
Objectives

In this chapter, you will learn:

How to use the scope resolution operator with

class fields and functions

About the use of static variables

About the this pointer

About the advantages of polymorphism

5 Creating Classes with Declaration
and Implementation Sections
Classes provide a convenient way to group
related data
Consider the Student class in Figure 5-1
It contains three public data fields: idNum,
lastName, and gradePointAverage
C++ programmers would say that the Student
class shown in Figure 5-1 is an abstract data type
(ADT)
This term simply indicates that Student is a type
you define, as opposed to types like char and int
that are defined by C++
5 Creating Classes with Declaration
and Implementation Sections

One advantage of creating the Student class is

that when you create a Student object, you
automatically create all the related Student
fields
5
Creating Classes with Declaration
and Implementation Sections
Another advantage is the ability to pass a
Student object into a function, or receive a
Student objet from a function as a returned
value, and automatically pass or receive all the
individual fields that each Student contains

The first step to creating a class involves

determining the attributes of an object, and
subsequently dealing with the object as a whole
5
Encapsulating Class
Components
Just as the internal components of a radio are
hidden, when you write a program and create
a class name for a group of associated
variables, you hide, or encapsulate, the
individual components

Sometimes you want to change the state of

some components, but often you want to
think about the entry as a whole and not
concern yourself with the details
5
Designing Classes

You can think of the built-in scalar types of C+

+ as classes
You do not have to define those classes; the
creators of C++ have already done so
For most object-oriented classes, then, you
declare both fields and functions
You declare a function by writing its
prototype, which serves as the interface to
the function
5
Designing Classes

When you declare a class with a function definition

such as the one shown in Figure 5-2, and you then
create an object of that class, the object possesses
more than access to each fieldit also possesses
access to the function
5
Implementing Class Functions

After you create a class functions prototype,

you still must write the actual function
When you construct a class, you create two
parts
The first part is a declaration section, which
contains the class name, variables (attributes),
and function prototype
The second part create is an implementation
section, which contains the functions
themselves
5 Student Class That Includes
One Function Definition
and Implementation
5
Implementing Class Functions
5
Implementing Class Functions

In the steps listed on pages 162 to 164 of the textbook,

you create a class that implements a function
Then you write a short demonstration program to
instantiate an object of the class, and use the objects
fields and functions
5
Data Hiding and Encapsulation

Object-oriented programmers strive to make their

classes similar to real-world objects, which
usually do not provide access to their inner
workings; access is available only to the interface
One technique programmers use to provide more
complete object encapsulation is to make objects
data private
One major asset of object-oriented programming
is that the information hiding can be
accomplished more completely than it is with the
procedures used in procedural programs
5
Data Hiding and Encapsulation

Traditional procedural languages do not allow

data to be declared as private; object-oriented
languages do
In C++, data hiding means that you can make data
members of a class inaccessible to functions that
are not part of that class
Within a C++ class, you accomplish data
encapsulation by making the data private instead
of public
A problem arises if you try to run the program
shown in Figure 5-4 and you use the new Student
class shown in Figure 5-7
5
Data Hiding and Encapsulation

When you compile the program, you receive error

messages indicating that the fields idNum, lastName,
and gradePointAverage are inaccessible
5
Using Public Functions to
Alter Private Data

You gain a major advantage when you make a

data field private
Once you create a class, including writing and
debugging all of its member functions, outside
functions can never modify or erroneously use
the private member data of any object in the class
When you create and test a class, and store its
definition in a file, programs that use the
definition can be prevented from using member
data incorrectly
5 Using Public Functions to
Alter Private Data
If a private member of your Student class, such as idNum,
must be a four-digit number, or if you require that the
idNumber always be preceded by a pound sign, functions
that are not a member of your class can never change
those rules (either intentionally or by accident)
5 Using Public Functions to
Alter Private Data
To setLastName() function shown in Figure 5-9 is a member
of the Student class
You can determine this because the class header contains
the Student class name and the scope resolution operator
5 Using Public Functions to
Alter Private Data
When you use the setIdNum() function with an object like
aJunior, you are assured that aJunior receives a valid
idNum
Figure 5-11 shows how the setGradePointAverage() function
can be written to accept a double argument and assure that
the argument is no more than 4.0 before assigning it to any
Students gradePointAverage field
5 Using a Complete Class in
a Program

Figure
5-12
shows the
entire
Student
class, all
its
member
functions,
and a
short
program
that uses
the class
5 Using a Complete Class in
a Program

Perform the
procedures
outlined on pages
170 to 172 of the
textbook, so you
can modify the
CollegeCourse
class you created
earlier, so that it
more closely
adheres to good
object-oriented
programming
principles
5
Using Private Functions

Not all function

are public
When you think
of real-world
objects, such
as kitchen
appliances,
there are many
public
functions you
control through
an interface:
adjusting the
temperature,
etc.
5
Using Private Functions
5 Considering Scope When
Defining Member Functions
There are circumstances when the scope
resolution operator is required with a class field
name

Whenever there is a conflict between local and

class variable names, you must use the scope
resolution operator to achieve the results you
want

In the second function in Figure 5-19, idNum

refers to only the functions local variable named
idNum

The class variable with the same name is hidden

unless you use the scope resolution operator
5
Considering Scope When
Defining Member Functions
5
Using Static Class Members
A C++ object is an instantiation of a class
that can contain both data members and
methods

When you create an object, a block of

memory is set aside for the data members

Sometimes every instantiation of a class

requires the same value
5
Using Static Class Members

To avoid a waste, you declare the athletic fee

variable as static, meaning that is remains
unchanged

A class variable that you declare to be static is

the same for all objects that are instantiations
of the class

Static variables are sometimes called class

variables because they do not belong to a
specific object; they belong to the class
5
Defining Static Data Members

Because it uses only one memory location, a

static data member is defined (given a value) in
a single statement outside the class definition

Most often this statement appears just before

the class implementation section

Even though each Student declared in the

program shown in Figure 5-20 has a unique ID
number, all Student objects share the athletic
fee, which was assigned a value just once
5
A Class That Contains a Static
AthleticFee Field
5
Defining Static Data Members

A static class member exists, even when

you have not instantiated any objects of
the class
5
Using Static Functions

In the program shown in Figure 5-20, the

athleticFee field is public, which is why you
can access it directly, as in
Student::athleticFee = 139.95;

If it were private, you would have to use a

public function to access the value, as with
any other private variable

Additionally, the function would have to be a

static function
5
Using Static Functions

As with a static data field, when you create a

static member function, only one copy of the
function exists for the class
You must use a static function to access a static
field because static functions do not receive a
pointer to the object that uses the function
Using the directions on pages 179 to 181 of the
textbook, you use a private, static class variable
to keep track of how many objects have been
initialized
5
Using Static Functions

You will use a public static function to display the

private static variable
5
Understanding the this Pointer

When you define a class, you include fields and

functions
If the class has one non-static field and one static
field such as the Employee class shown in Figure
5-23, and you then declare two Employee objects,
you reserve storage for two versions of the non-
static field
However, you store only one version of the static
field that every object can use
C++ does not store member functions separately
for each instance of a class
5
Understanding the this Pointer

One copy of each member function is stored, and

each instance of a class uses the same function code
5
Understanding the this Pointer
5
Understanding the this Pointer

Because only one copy of each function

exists, when you call a function, it needs to
know which objects to use
To ensure that the function uses the correct
object, you use the objects name, such as
clerk or driver, with the dot operator
Within the displayValue() function, the
address of the object is stored in a special
pointer called the this pointer
5
Understanding the this Pointer

The this pointer holds the memory

address of the current object that is using
the function

That is why it is named thisit refers to

this object as opposed to any other
object

The this pointer also is passed to member

functions when they receive additional,
explicitly stated arguments
5
Using the this Pointer Explicitly

Within any member function, you can prove that the

this pointer exists and that it holds the address of the
current object
You do so by using the this pointer to access the
objects data fields
5 Using the Pointer-to-Member
Operator

Figure 5-27 shows yet another way to use the this

pointer
The functions operate like those in Figure 5-26,
but they use the C++ pointer-to-member operator,
which looks like an arrow and is constructed by a
programmer by using a dash followed by a right
angle bracket (or greater-than sign)
Any pointer variable that is declared to point to a
class object can be used to access individual
fields or functions of that class by using the
parentheses and the asterisk
5 Using the Pointer-to-Member
Operator

In the steps shown on page 185 of the textbook, you

explicitly add some references to the this pointer to
the Letter class you wrote earlier. You are adding the
reference to illustrate how the this pointer works.
5
Understanding Polymorphism

Polymorphism is the object-oriented program

feature that allows the same operation to be
carried out differently depending on the object
When you write C++ (and other object-oriented)
programs, you can send the same message to
different objects and different types of objects
C++ allows you to create three very different
member functions, one for each of the classes in
question
When you can apply the same function name to
different objects, your programs become easier to
read and make more sense
5 Three displayValues() Functions
from Three Separate Classes
5
Summary

Each class you define is an abstract data type, or

a group type with its own fields and functions
A technique programmers use to provide more
complete object encapsulation is to make most
objects data private
You can make functions private when you want to
hide their use from client programs
You can use the scope resolution operator with
class fields and functions
5
Summary

When you declare a class variable to be static,

only one copy of the variable is stored, no
matter how many class objects you instantiate

When you create a class, one copy of each

member function is stored

Polymorphism is the object-oriented program

feature that allows the same operation to be
carried out differently, depending on the object