Chapter 2:
Classes and Data Abstraction
Objectives
In this chapter, you will:
• Learn about classes
• Learn about private, protected, and public
members of a class
• Implement classes
• Examine constructors and destructors
• Learn about the abstract data type (ADT)
C++ Programming: Program Design Including Data Structures, Sixth Edition 2
Objectives (cont’d.)
• Use classes to implement ADTs
• Learn about information hiding
• Implement information hiding in C++
• Learn about the static members of a class
C++ Programming: Program Design Including Data Structures, Sixth Edition 3
Classes
• Object-oriented design (OOD): a problem solving
methodology
• Objects: components of a solution
• Class: a collection of a fixed number of components
• Member: a component of a class
C++ Programming: Program Design Including Data Structures, Sixth Edition 4
Classes (cont’d.)
• Class definition:
– Defines a data type; no memory is allocated
– Don’t forget the semicolon after the closing brace
• Syntax:
C++ Programming: Program Design Including Data Structures, Sixth Edition 5
Classes (cont’d.)
• 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
– 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: Program Design Including Data Structures, Sixth Edition 6
Classes (cont’d.)
• Three categories of class members:
– private (default)
• Member cannot be accessed outside the class
– public
• Member is accessible outside the class
– protected
C++ Programming: Program Design Including Data Structures, Sixth Edition 7
Unified Modeling Language
Class Diagrams
• Unified Modeling Language (UML) notation: used to
graphically describe a class and its members
– +: member is public
– -: member is private
– #: member is protected
C++ Programming: Program Design Including Data Structures, Sixth Edition 8
Unified Modeling Language Class
Diagrams (cont’d.)
C++ Programming: Program Design Including Data Structures, Sixth Edition 9
Variable (Object) Declaration
• Once defined, you can declare variables of that
class type
clockType myClock;
• A class variable is called a class object or class
instance
C++ Programming: Program Design Including Data Structures, Sixth Edition 10
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 an object is declared in the definition of a member
function of the class, it can access the public
and private members
C++ Programming: Program Design Including Data Structures, Sixth Edition 11
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
– Cannot use relational operators to compare two class
objects for equality
• Built-in operations that are valid for class objects:
– Member access (.)
– Assignment (=)
C++ Programming: Program Design Including Data Structures, Sixth Edition 12
Assignment Operator and Classes
C++ Programming: Program Design Including Data Structures, Sixth Edition 13
Class Scope
• An object can be automatic or static
– Automatic: created when the declaration is reached and
destroyed when the surrounding block is exited
– Static: created when the declaration is reached and
destroyed when the program terminates
• Object has the same scope as other variables
C++ Programming: Program Design Including Data Structures, Sixth Edition 14
Class Scope (cont’d.)
• A member of the class is local to the class
• Can access a class member outside the class by
using the class object name and the member
access operator (.)
C++ Programming: Program Design Including Data Structures, Sixth 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: Program Design Including Data Structures, Sixth 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: Program Design Including Data Structures, Sixth Edition 17
Reference Parameters and Class
Objects (Variables) (cont’d.)
• 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: Program Design Including Data Structures, Sixth Edition 18
Implementation of Member
Functions
• Must write the code for functions defined as function
prototypes
• Prototypes are left in the class to keep the class
smaller and to hide the implementation
• To access identifiers local to the class, use the scope
resolution operator ::
C++ Programming: Program Design Including Data Structures, Sixth Edition 19
Implementation of Member
Functions (cont’d.)
C++ Programming: Program Design Including Data Structures, Sixth Edition 20
Implementation of Member
Functions (cont’d.)
C++ Programming: Program Design Including Data Structures, Sixth Edition 21
Implementation of Member
Functions (cont’d.)
• Once a class is properly defined and implemented,
it can be used in a program
– A program that uses/manipulates objects of a class is
called a client of that class
• When you declare objects of the class
clockType, each object has its own copy of the
member variables (hr, min, and sec)
• Called instance variables of the class
– Every object has its own instance of the data
C++ Programming: Program Design Including Data Structures, Sixth Edition 22
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: Program Design Including Data Structures, Sixth Edition 23
Order of public and private
Members of a Class
• C++ has no fixed order in which to 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: Program Design Including Data Structures, Sixth Edition 24
Constructors
• Use constructors to guarantee that member variables
of a class are initialized
• Two types of constructors:
– With parameters
– Without parameters (default constructor)
– Name of a constructor = name of the class
– A constructor has no type
C++ Programming: Program Design Including Data Structures, Sixth Edition 25
Constructors (cont’d.)
• 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: Program Design Including Data Structures, Sixth Edition 26
Invoking a Constructor
• A constructor is automatically executed when a class
variable is declared
• Because a class may have more than one constructor,
you can invoke a specific constructor
C++ Programming: Program Design Including Data Structures, Sixth Edition 27
Invoking the Default Constructor
• To invoke the default constructor:
• Example:
clockType yourClock;
C++ Programming: Program Design Including Data Structures, Sixth Edition 28
Invoking a Constructor with
Parameters
• Syntax:
• Number and type of arguments 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 causes a compile-time error
C++ Programming: Program Design Including Data Structures, Sixth Edition 29
Constructors and Default
Parameters
• A constructor can have default parameters
– Rules for declaring formal parameters are the same as for
declaring default formal parameters in a function
– Actual parameters are passed according to same rules for
functions
• Default constructor: a constructor with no
parameters or with all default parameters
C++ Programming: Program Design Including Data Structures, Sixth Edition 30
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
C++ Programming: Program Design Including Data Structures, Sixth Edition 31
Arrays of Class Objects (Variables)
and Constructors
• If you declare an array of class objects, the class
should have the default constructor
C++ Programming: Program Design Including Data Structures, Sixth Edition 32
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
• Destructor automatically executes when the class
object goes out of scope
C++ Programming: Program Design Including Data Structures, Sixth Edition 33
Data Abstract, 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: Program Design Including Data Structures, Sixth Edition 34
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: Program Design Including Data Structures, Sixth Edition 35
A struct Versus a class
(cont’d.)
• 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: Program Design Including Data Structures, Sixth Edition 36
Information Hiding
• Information hiding: hiding the details of the operations
on the data
• Interface (header) file: contains the specification details
• File extension is .h
• Implementation file: contains the implementation details
• File extension is .cpp
• In header file, include function prototypes and
comments that briefly describe the functions
– Specify preconditions and/or postconditions
C++ Programming: Program Design Including Data Structures, Sixth Edition 37
Information Hiding (cont’d.)
• 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: Program Design Including Data Structures, Sixth Edition 38
Information Hiding (cont'd.)
• 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: Program Design Including Data Structures, Sixth Edition 39
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
– One command (build, rebuild, or make) compiles program
and links it with the other necessary files
– These systems also manage multiple file programs in the
form of a project
C++ Programming: Program Design Including Data Structures, Sixth Edition 40
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: Program Design Including Data Structures, Sixth Edition 41
Static Members of a Class (cont’d.)
• Multiple objects of a class each have their own copy
of non-static member variables
• All objects of a class share any static member of the
class
C++ Programming: Program Design Including Data Structures, Sixth Edition 42
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: Program Design Including Data Structures, Sixth Edition 43
Summary (cont’d.)
• The only built-in operations on classes are
assignment and member selection
• Constructors guarantee that data members are
initialized when an object is declared
– Default constructor has no parameters
• Destructor automatically executes when a class
object goes out of scope
– A class can have only one destructor
– The destructor has no parameters
C++ Programming: Program Design Including Data Structures, Sixth Edition 44
Summary (cont’d.)
• 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: Program Design Including Data Structures, Sixth Edition 45
