C++ Programming:
From Problem Analysis
to Program Design, Fourth Edition
Chapter 12: Classes and Data Abstraction
Objectives
In this chapter, you will:
• Learn about classes
• Learn about private, protected, and
public members of a class
• Explore how classes are implemented
• Examine constructors and destructors
• Learn about the abstract data type (ADT)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 2
Objectives (continued)
• Explore how classes are used to implement
ADTs
• Learn about information hiding
• Explore how information hiding is implemented
in C++
• Learn about the static members of a class
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 3
Classes
• Class: collection of a fixed number of
components (members)
• Definition syntax:
− Defines a data type; no memory is allocated
− Don’t forget the semicolon after closing brace
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 4
Classes (continued)
• Class member can be a variable or a function
• If a member of a class is a variable
− It is declared like any other variable
• In the definition of the class
− You cannot initialize a variable when you
declare it
• If a member of a class is a function
− Function prototype is listed
− Function members can (directly) access any
member of the class
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 5
Classes (continued)
• Three categories of class members
− private (default)
• Member cannot be accessed outside the class
− Public
• Member is accessible outside the class
− Protected //will be discussed later
class A {
int x;
void fun();
Any member (variable or
}; function) can be public or
private or protected
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 6
Classes (continued)
These functions cannot
modify the member variables
of a variable of type
clockType
const: formal parameter
private can’t modify
the value of the actual
members, parameter
can’t be
accessed
from
outside the
class
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 7
Unified Modeling Language Class
Diagrams
To describe the class graphically
+: member is public
-: member is private
#: member is protected
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 8
Variable (Object) Declaration
• Once a class is defined, you can declare
variables of that type
clockType myClock;
clockType yourClock;
• A class variable is called a class object or
class instance
OOP stands for Object Oriented
Programming: encapsulates data
and functions into packages called
classes.
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 9
Accessing Class Members
• Once an object is declared, it can access the
public members of the class
• Syntax:
− The dot (.) is the member access operator
• If object is declared in the definition of a
member function of the class, it can access
the public and private members
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 10
5 10
Built-in Operations on Classes
• Most of C++’s built-in operations do not apply
to classes
− Arithmetic operators cannot be used on class
objects unless the operators are
overloaded //ch 15
− You cannot use relational operators to
compare two class objects for equality
• Built-in operations valid for class objects:
− Member access (.)
− Assignment (=)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 13
Assignment Operator and Classes
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 14
Class Scope
• An object can be automatic or static
• A member of the class is local to the class
• You access a class member outside the
class by using the class object name and
the member access operator (.)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 15
Functions and Classes
• Objects can be passed as parameters to
functions and returned as function values
• As parameters to functions
− Objects can be passed by value or by
reference
• If an object is passed by value
− Contents of data members of the actual
parameter are copied into the corresponding
data members of the formal parameter
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 16
Reference Parameters and Class
Objects (Variables)
• Passing by value might require a large
amount of storage space and a considerable
amount of computer time to copy the value of
the actual parameter into the formal
parameter
• If a variable is passed by reference
− The formal parameter receives only the
address of the actual parameter
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 17
Reference Parameters and Class
Objects (Variables) (continued)
• Pass by reference is an efficient way to pass a
variable as a parameter
− Problem: when passing by reference, the actual
parameter changes when formal parameter
changes
− Solution: use const in the formal parameter
declaration
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 18
Example:
Implementation of Member
Functions
Scope resolution operator
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 20
Implementation of Member
Functions (continued)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 21
if hr= 23 then hr= 0
if hr= 23 min=59 then
min =0 hr++
hr=0 min=0
if hr= 23 min= 59 sec = 59 then by sec++
sec=0 min++
min=0 hr++
hr= 0 min=0 sec=0
Implementation of Member
Functions (continued)
• Once a class is properly defined and
implemented, it can be used in a program
− A program that uses/manipulates the objects
of a class is called a client of that class
• When you declare objects of the class
clockType, every object has its own copy of
the member variables (hr, min, and sec)
• Variables such as hr, min, and sec are
called instance variables of the class
− Every object has its own instance of the data
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 25
Accessor and Mutator Functions
• Accessor function: member function that only
accesses the value(s) of member variable(s)
• Mutator function: member function that
modifies the value(s) of member variable(s)
− Constant function:
• Member function that cannot modify member
variables
• Use const in function heading
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 26
Order of public and private
Members of a Class
• C++ has no fixed order in which you declare
public and private members
• By default, all members of a class are
private
• Use the member access specifier public to
make a member available for public access
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 27
Order of public and private
Members of a Class (continued)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 28
Order of public and private
Members of a Class (continued)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 29
Order of public and private
Members of a Class (continued)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 30
Constructors
• Use constructors to guarantee that data
members of a class are initialized
• Two types of constructors:
− With parameters
− Without parameters (default constructor)
• The name of a constructor is the same as the
name of the class
• A constructor has no type
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 31
Constructors (continued)
• A class can have more than one constructor
− Each must have a different formal parameter
list
• Constructors execute automatically when a
class object enters its scope
− They cannot be called like other functions
− Which constructor executes depends on the
types of values passed to the class object
when the class object is declared
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 33
Constructors (continued)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 35
e
d
w
i
t
h
:
s
e
t
T
i
m
e
(
h
o
u
r
s
,
m
i
n
Invoking a Constructor
• A constructor is automatically executed when
a class variable is declared
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 37
Invoking the Default Constructor
• To invoke the default constructor:
• Example:
clockType yourClock;
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 38
Invoking a Constructor with
Parameters
• Syntax:
• The number of arguments and their type
should match the formal parameters (in the
order given) of one of the constructors
− Otherwise, C++ uses type conversion and
looks for the best match
− Any ambiguity leads to a compile-time error
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 39
Constructors and Default
Parameters
• If you replace the constructors of clockType
with the constructor in Line 1, you can
declare clockType objects with zero, one,
two, or three arguments as follows:
clockType clock1; //Line 2
clockType clock2(5); //Line 3
clockType clock3(12, 30); //Line 4
clockType clock4(7, 34, 18); //Line 5
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 40
Classes and Constructors:
A Precaution
• If a class has no constructor(s), C++ provides
the default constructor
− However, object declared is still uninitialized
• If a class includes constructor(s) with
parameter(s), but not the default constructor
− C++ does not provide the default constructor
Note: if you have a constructor with all default parameters you cannot declare
a constructor without parameters, they both called default constructor.
clockType clockType(int = 0, int = 0, int = 0);
clockType clockType (); //illegal in the same class
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 41
Examples
class A { class A { class A { class A {
private: private: private: private:
int x; int x; int x; int x;
public: public: public: Int y;
A (int =0); A (int =0); A (int); public:
}; A(); }; A (int);
}; A(int, int=0);
void main() void main() { };
void main()
{ { A obj1; //illegal
A obj1();//Not Correct?! A obj1; //illegal } void main() {
}
A obj1; //Correct A obj1(3); //illegal
} }
Arrays of Class Objects (Variables)
and Constructors
• If a class has constructors and you declare
an array of that class’s objects, the class
should have the default constructor
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 43
Arrays of Class Objects (Variables)
and Constructors (continued)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 44
Destructors
• Destructors are functions without any type
• The name of a destructor is the character '~'
followed by class name
− For example:
~clockType();
• A class can have only one destructor
− The destructor has no parameters
• The destructor is automatically executed when
the class object goes out of scope
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 45
Example
Example
Data Abstraction, Classes, and
Abstract Data Types
• Abstraction
− Separating design details from usage
− Separating the logical properties from the
implementation details
• Abstraction can also be applied to data
− Abstract data type (ADT): data type that
separates the logical properties from the
implementation details
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 48
Data Abstraction, Classes, and
Abstract Data Types (continued)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 49
Data Abstraction, Classes, and
Abstract Data Types (continued)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 50
Data Abstraction, Classes, and
Abstract Data Types (continued)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 51
A struct versus a class
• By default, members of a struct are
public
− private specifier can be used in a struct
to make a member private
• By default, the members of a class are
private
• classes and structs have the same
capabilities
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 52
A struct versus a class
(continued)
• In C++, the definition of a struct was
expanded to include member functions,
constructors, and destructors
• If all member variables of a class are
public and there are no member functions
− Use a struct
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 53
Information Hiding
• Information hiding: hiding the details of the
operations on the data
• Interface (header) file: contains the
specification details
• Implementation file: contains the
implementation details
• In header file, include function prototypes and
comments that briefly describe the functions
− Specify preconditions and/or postconditions
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 54
Information Hiding (continued)
• Precondition: a statement specifying the
condition(s) that must be true before the
function is called
• Postcondition: a statement specifying what is
true after the function call is completed
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 55
Information Hiding (continued)
• Header file has an extension .h
• Implementation file has an extension .cpp
• Implementation file must include header file
via include statement
• In include statement:
− User-defined header files are enclosed in
double quotes
− System-provided header files are enclosed
between angular brackets
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 59
Executable Code
• To use an object in a program
− The program must be able to access the
implementation
• Visual C++, Visual Studio .NET, C++ Builder,
and CodeWarrior put the editor, compiler, and
linker into a package
− With one command, the program is compiled
and linked with the other necessary files
− These systems also manage multiple file
programs in the form of a project
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 60
Executable Code (continued)
• A project consists of several files, called the
project files
• These systems usually have a command,
called build, rebuild, or make
• When applied to a project, system compiles
and links all files required to create the
executable code
− When file(s) in the project change, use these
commands to recompile and relink the files
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 61
Executable Code (continued)
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 63
Static Members of a Class
• Use the keyword static to declare a
function or variable of a class as static
• A public static function or member of a
class can be accessed using the class name
and the scope resolution operator
• static member variables of a class exist
even if no object of that class type exists
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 65
Static Members of a Class
• A static member function of a class can
only access a static member variable
• A static member variable should be
initialized out the class braces by using the
class name and the scope resolution
operator(::)
• static const member variable should be
initialized within the class
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 66
Examples
Summary
• Class: collection of a fixed number of
components
• Members: components of a class
− Accessed by name
− Classified into one of three categories:
• private, protected, and public
• Class variables are called class objects or,
simply, objects
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 69
Summary (continued)
• The only built-in operations on classes are
the assignment and member selection
• Constructors guarantee that data members
are initialized when an object is declared
− Default constructor has no parameters
• Destructors automatically execute when a
class object goes out of scope
− A class can have only one destructor
− The destructor has no parameters
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 70
Summary (continued)
• Abstract data type (ADT): data type that
separates the logical properties from the
implementation details
• A public static member, function or data,
of a class can be accessed using the class
name and the scope resolution operator
• Static data members of a class exist even
when no object of the class type exists
• Instance variables: non-static data members
C++ Programming: From Problem Analysis to Program Design, Fourth Edition 71
