5/14/2014

Lecture 2 Classes and

Data Abstraction (C++)
Lecture adapted from
C++ How to Program (9th Edition)
By Paul Deitel and Harvey Deitel
Prentice Hall, Inc. All rights reserved.

CS162 Object Oriented Programming

Imran Ihsan
www.imranihsan.com
OOP 02 - Classes - I

imranihsan.com

+ 2.1 Introduction

Object-oriented programming (OOP)

Information hiding

Encapsulates data (attributes) and functions (behavior) into

packages called classes

Class objects communicate across well-defined interfaces

Implementation details hidden within classes themselves

User-defined (programmer-defined) types: classes

Data (data members)

Functions (member functions or methods)
Similar to blueprints reusable
Class instance: object

imranihsan.com

OOP 02 - Classes - I

5/14/2014

+ 2.2 Structure Definitions

Structures

Aggregate data types built using elements of other types

struct Time {
int hour;
int minute;
int second;
};

Structure Members

Structure member naming

Structure tag

In same struct: must have unique names

In different structs: can share name

struct definition must end with semicolon

imranihsan.com

OOP 02 - Classes - I

+ 2.2 Structure Definitions

Self-referential structure

Structure member cannot be instance of enclosing struct

Structure member can be pointer to instance of enclosing struct
(self-referential structure)
Used for linked lists, queues, stacks and trees

struct definition

Creates new data type used to declare variables

Structure variables declared like variables of other types

Examples:
Time timeObject;
Time timeArray[ 10 ];
Time *timePtr;
Time &timeRef = timeObject;

imranihsan.com

OOP 02 - Classes - I

5/14/2014

+ 2.3 Accessing Structure Members

Member access operators

Dot operator (.) for structure and class members

Arrow operator (->) for structure and class members via pointer
to object

Print member hour of timeObject:

cout << timeObject.hour;
OR
timePtr = &timeObject;
cout << timePtr->hour;

timePtr->hour same as ( *timePtr ).hour

Parentheses required
* lower precedence than .

imranihsan.com

OOP 02 - Classes - I

+ 2.4 Implementing a User-Defined Type Time

with a struct

Default: structures passed by value

Pass structure by reference

Avoid overhead of copying structure

C-style structures

No interface
If implementation changes, all programs using that struct
must change accordingly

Cannot print as unit

Must print/format member by member

Cannot compare in entirety

Must compare member by member

imranihsan.com

OOP 02 - Classes - I

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//
// Create a structure, set its members, and print it.
#include <iostream>
using std::cout;
using std::endl;
#include <iomanip>

Define structure type Time

with three integer members.

using std::setfill;
using std::setw;

// structure definition
struct Time {
int hour;
// 0-23 (24-hour clock format)
int minute;
// 0-59
int second;
// 0-59
}; // end struct Time
void printUniversal( const Time & );
void printStandard( const Time & );

// prototype
// prototype

Pass references to constant

Time objects to eliminate
copying overhead.

OOP 02 - Classes - I

imranihsan.com

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

int main()
{
Time dinnerTime;
dinnerTime.hour = 18;
dinnerTime.minute = 30;
dinnerTime.second = 0;

Use dot operator to initialize

structure members.
// variable of new type Time
// set hour member of dinnerTime
// set minute member of dinnerTime
// set second member of dinnerTime

cout << "Dinner will be held at ";

printUniversal( dinnerTime );
cout << " universal time,\nwhich is ";
printStandard( dinnerTime );
cout << " standard time.\n";
dinnerTime.hour = 29;
dinnerTime.minute = 73;

// set hour to invalid value

// set minute to invalid value

cout << "\nTime with invalid values: ";

printUniversal( dinnerTime );
cout << endl;
return 0;

Direct access to data allows

assignment of bad values.

} // end main

imranihsan.com

OOP 02 - Classes - I

5/14/2014

49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// print time in universal-time format

void printUniversal( const Time &t )
{
cout << setfill( '0' ) << setw( 2 ) << t.hour << ":"
<< setw( 2 ) << t.minute << ":"
<< setw( 2 ) << t.second;
} // end function printUniversal

Use parameterized stream

manipulator setfill.

// print time in standard-time format

void printStandard( const Time &t )
{
cout << ( ( t.hour == 0 || t.hour == 12 ) ?
12 : t.hour % 12 ) << ":" << setfill( '0' )
<< setw( 2 ) << t.minute << ":"
<< setw( 2 ) << t.second
<< ( t.hour < 12 ? " AM" : " PM" );
} // end function printStandard

Use dot operator to access

data members.

Dinner will be held at 18:30:00 universal time,

which is 6:30:00 PM standard time.
Time with invalid values: 29:73:00
imranihsan.com

OOP 02 - Classes - I

+ 2.5 Implementing a Time Abstract Data Type

with a class

Classes

Model objects
Attributes (data members)
Behaviors (member functions)
Defined using keyword class
Member functions
Methods
Invoked in response to messages

Member access specifiers

public:
Accessible wherever object of class in scope
private:
Accessible only to member functions of class
protected:

imranihsan.com

OOP 02 - Classes - I

5/14/2014

+ 2.5 Implementing a Time Abstract Data Type

with a class

Constructor function

Special member function

Initializes data members
Same name as class

Called when object instantiated

Several constructors
Function overloading

No return type

imranihsan.com

OOP 02 - Classes - I

Definition of class begins with

keyword class.
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Class body starts with left

brace.

class Time {

public:
Member access specifiers.
Time();
// constructor
void setTime( int, int, int ); // set hour, minute, second
void printUniversal();
// print universal-time format
void printStandard();
// print standard-time format
private:
int hour;
int minute;
int second;

// 0 - 23 (24-hour clock format)

// 0 - 59
// 0 - 59

}; // end class Time

Class body ends with right

brace.

Function prototypes for public

member functions.
private data members
accessible only to member
functions.

Definition terminates with

semicolon.

Constructor has same name as

class, Time, and no return
type.

imranihsan.com

OOP 02 - Classes - I

5/14/2014

+ 2.5 Implementing a Time Abstract Data Type

with a class

Objects of class

After class definition

Class name new type specifier
C++ extensible language
Object, array, pointer and reference declarations
Example:
Class name becomes new
type specifier.
Time
Time
Time
Time

sunset;
arrayOfTimes[ 5 ];
*pointerToTime;
&dinnerTime = sunset;

//
//
//
//

object of type Time

array of Time objects
pointer to a Time object
reference to a Time object

imranihsan.com

OOP 02 - Classes - I

+ 2.5 Implementing a Time Abstract Data Type

with a class

Member functions defined outside class

Binary scope resolution operator (::)

Ties member name to class name
Uniquely identify functions of particular class
Different classes can have member functions with same name
Format for defining member functions
ReturnType ClassName::MemberFunctionName( ){

Does not change whether function public or private

Member functions defined inside class

Do not need scope resolution operator, class name

Compiler attempts inline
Outside class, inline explicitly with keyword inline

imranihsan.com

OOP 02 - Classes - I

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

//
// Time class.
#include <iostream>
using std::cout;
using std::endl;
#include <iomanip>
using std::setfill;
using std::setw;
// Time abstract data type (ADT) definition
class Time {

Define class Time.

public:
Time();
// constructor
void setTime( int, int, int ); // set hour, minute, second
void printUniversal();
// print universal-time format
void printStandard();
// print standard-time format

OOP 02 - Classes - I

imranihsan.com

22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

private:
int hour;
int minute;
int second;

// 0 - 23 (24-hour clock format)

// 0 - 59
// 0 - 59

}; // end class Time

// Time constructor initializes each data member to zero and
// ensures all Time objects start in a consistent state
Constructor initializes private
Time::Time()
data members to 0.
{
hour = minute = second = 0;
} // end Time constructor
// set new Time value using universal time, perform validity
// checks on the data values and set invalid values to zero
void Time::setTime( int h, int m, int s )
{
hour = ( h >= 0 && h < 24 ) ? h : 0;
minute = ( m >= 0 && m < 60 ) ? m : 0;
second = ( s >= 0 && s < 60 ) ? s : 0;
public member function
} // end function setTime

imranihsan.com

checks parameter values for

validity before setting private
data members.

OOP 02 - Classes - I

5/14/2014

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

No arguments (implicitly

// print Time in universal format

know purpose is to print
void Time::printUniversal()
data members); member
{
cout << setfill( '0' ) << setw( 2 ) << hour <<
":"
function
calls more concise.
<< setw( 2 ) << minute << ":"
<< setw( 2 ) << second;
} // end function printUniversal
// print Time in standard format
void Time::printStandard()
{
cout << ( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 )
<< ":" << setfill( '0' ) << setw( 2 ) << minute
<< ":" << setw( 2 ) << second
<< ( hour < 12 ? " AM" : " PM" );
} // end function printStandard

Declare variable t to be object

of class Time.

int main()
{
Time t;

// instantiate object t of class Time

OOP 02 - Classes - I

imranihsan.com

70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// output Time object t's initial values

cout << "The initial universal time is ";
t.printUniversal();
// 00:00:00
cout << "\nThe initial standard time is ";
t.printStandard();
// 12:00:00 AM
t.setTime( 13, 27, 6 );

Invoke public member

functions to print time.

// change time

// output Time object t's new values

cout << "\n\nUniversal time after setTime is ";
t.printUniversal();
// 13:27:06
cout << "\nStandard time after setTime is ";
t.printStandard();
// 1:27:06 PM
t.setTime( 99, 99, 99 );

Set data members using

public member function.
Attempt to set data members
to invalid values using public
member function.

// attempt invalid settings

// output t's values after specifying invalid values

cout << "\n\nAfter attempting invalid settings:"
<< "\nUniversal time: ";
t.printUniversal();
// 00:00:00
cout << "\nStandard time: ";
t.printStandard();
// 12:00:00 AM
cout << endl;
return 0;
} // end main

imranihsan.com

OOP 02 - Classes - I

5/14/2014

The initial universal time is 00:00:00

The initial standard time is 12:00:00 AM
Universal time after setTime is 13:27:06
Standard time after setTime is 1:27:06 PM
After attempting invalid settings:
Universal time: 00:00:00
Standard time: 12:00:00 AM

Data members set to 0 after

attempting invalid settings.

imranihsan.com

OOP 02 - Classes - I

+ 2.5 Implementing a Time Abstract Data Type

with a class

Advantages of using classes

Simplify programming

Interfaces
Hide implementation

Software reuse
Composition (aggregation)
Class objects included as members of other classes
Inheritance
New classes derived from old

imranihsan.com

OOP 02 - Classes - I

10

5/14/2014

+ 2.6 Class Scope and Accessing Class

Members

Class scope

Data members, member functions

Within class scope
Class members
Immediately accessible by all member functions
Referenced by name
Outside class scope
Referenced through handles
Object name, reference to object, pointer to object

File scope

Nonmember functions

imranihsan.com

OOP 02 - Classes - I

+ 2.6 Class Scope and Accessing Class

Members

Function scope

Variables declared in member function

Only known to function
Variables with same name as class-scope variables
Class-scope variable hidden
Access with scope resolution operator (::)
ClassName::classVariableName

Variables only known to function they are defined in

Variables are destroyed after function completion

imranihsan.com

OOP 02 - Classes - I

11

5/14/2014

+ 2.6 Class Scope and Accessing Class

Members

Operators to access class members

Identical to those for structs

Dot member selection operator (.)

Object
Reference to object

Arrow member selection operator (->)

Pointers

imranihsan.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

OOP 02 - Classes - I

// Fig. 6.4: fig06_04.cpp

// Demonstrating the class member access operators . and ->
//
// CAUTION: IN FUTURE EXAMPLES WE AVOID PUBLIC DATA!
#include <iostream>
using std::cout;
using std::endl;
// class Count definition
class Count {
public:
int x;

Data member x public to

illustrate class member
access operators; typically
data members private.

void print()
{
cout << x << endl;
}
}; // end class Count

imranihsan.com

OOP 02 - Classes - I

12

5/14/2014

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

Use dot member selection

int main()
operator for counter object.
{
Count counter;
// create counter object
Count *counterPtr = &counter; // create pointer to counter
Count &counterRef = counter; // create reference to counter
cout << "Assign 1 to x and print using the object's name: ";
counter.x = 1;
// assign 1 to data member x
counter.print();
// call member function print
cout << "Assign 2 to x and print using a reference: ";
counterRef.x = 2;
// assign 2 to data member x
counterRef.print(); // call member function print
cout << "Assign 3 to x and print using a pointer: ";
counterPtr->x = 3;
// assign 3 to data member x
counterPtr->print(); // call member function print
return 0;
} // end main

Use arrow member selection

operator for counterPtr
pointer to object.

Assign 1 to x and print using the object's name: 1

Assign 2 to x and print using a reference: 2
Assign 3 to x and print using a pointer: 3

imranihsan.com

OOP 02 - Classes - I

+ 2.7 Separating Interface from

Implementation

Separating interface from implementation

Advantage
Easier to modify programs
Disadvantage
Header files
Portions of implementation
Inline member functions
Hints about other implementation
private members
Can hide more with proxy class

imranihsan.com

OOP 02 - Classes - I

13

5/14/2014

+ 2.7 Separating Interface from

Implementation

Header files

Class definitions and function prototypes

Included in each file using class
#include
File extension .h

Source-code files

Member function definitions

Same base name
Convention
Compiled and linked

imranihsan.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

OOP 02 - Classes - I

Preprocessor code to prevent

// time1.h
multiple inclusions.
// Declaration of class Time.
// Member functions are defined in time1.cpp
// prevent multiple inclusions of header file
#ifndef TIME1_H
#define TIME1_H
// Time abstract data type definition
class Time {

Preprocessor directive
defines name TIME1_H.
Naming convention:
header file name with
underscore replacing period.

public:
Time();
// constructor
void setTime( int, int, int ); // set hour, minute, second
void printUniversal();
// print universal-time format
void printStandard();
// print standard-time format
private:
int hour;
int minute;
int second;

// 0 - 23 (24-hour clock format)

// 0 - 59
// 0 - 59

}; // end class Time

#endif

imranihsan.com

OOP 02 - Classes - I

14

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// time1.cpp
// Member-function definitions for class Time.
#include <iostream>
using std::cout;

Include header file time1.h.

#include <iomanip>

Name of header file enclosed in quotes; angle

brackets cause preprocessor to assume header
part of C++ Standard Library.

using std::setfill;
using std::setw;

// include definition of class Time from time1.h

#include "time1.h"
// Time constructor initializes each data member to zero.
// Ensures all Time objects start in a consistent state.
Time::Time()
{
hour = minute = second = 0;
} // end Time constructor

imranihsan.com

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

OOP 02 - Classes - I

// Set new Time value using universal time. Perform validity

// checks on the data values. Set invalid values to zero.
void Time::setTime( int h, int m, int s )
{
hour = ( h >= 0 && h < 24 ) ? h : 0;
minute = ( m >= 0 && m < 60 ) ? m : 0;
second = ( s >= 0 && s < 60 ) ? s : 0;
} // end function setTime
// print Time in universal format
void Time::printUniversal()
{
cout << setfill( '0' ) << setw( 2 ) << hour << ":"
<< setw( 2 ) << minute << ":"
<< setw( 2 ) << second;
} // end function printUniversal
// print Time in standard format
void Time::printStandard()
{
cout << ( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 )
<< ":" << setfill( '0' ) << setw( 2 ) << minute
<< ":" << setw( 2 ) << second
<< ( hour < 12 ? " AM" : " PM" );
} // end function printStandard

imranihsan.com

OOP 02 - Classes - I

15

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// program.cpp
// Program to test class Time.
// NOTE: This file must be compiled with time1.cpp.
#include <iostream>
using std::cout;
using std::endl;
// include definition of class Time from time1.h
#include "time1.h"
int main()
{
Time t;

// instantiate object t of class Time

// output Time object t's initial values

cout << "The initial universal time is ";
t.printUniversal();
// 00:00:00
cout << "\nThe initial standard time is ";
t.printStandard();
// 12:00:00 AM
t.setTime( 13, 27, 6 );

Include header file time1.h to

ensure correct
creation/manipulation and
determine size of Time class
object.

// change time

OOP 02 - Classes - I

imranihsan.com

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// output Time object t's new values

cout << "\n\nUniversal time after setTime is ";
t.printUniversal();
// 13:27:06
cout << "\nStandard time after setTime is ";
t.printStandard();
// 1:27:06 PM
t.setTime( 99, 99, 99 );

// attempt invalid settings

// output t's values after specifying invalid values

cout << "\n\nAfter attempting invalid settings:"
<< "\nUniversal time: ";
t.printUniversal();
// 00:00:00
cout << "\nStandard time: ";
t.printStandard();
// 12:00:00 AM
cout << endl;
return 0;
} // end main

The initial universal time is 00:00:00

The initial standard time is 12:00:00 AM
Universal time after setTime is 13:27:06
Standard time after setTime is 1:27:06 PM

imranihsan.com

OOP 02 - Classes - I

16

5/14/2014

+ 2.8 Controlling Access to Members

Access modes

private
Default access mode
Accessible to member functions and friends

public
Accessible to any function in program with handle to class
object

protected
Will be discussed in later lectures

imranihsan.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

OOP 02 - Classes - I

//
// Demonstrate errors resulting from attempts
// to access private class members.
#include <iostream>
using std::cout;
// include definition of class Time from time1.h
#include "time1.h"
int main()
{
Time t;

// create Time object

t.hour = 7;

// error: 'Time::hour' is not accessible

// error: 'Time::minute' is not accessible

cout << "minute = " << t.minute;
return 0;
} // end main

Recall data member hour is

private; attempts to access
private members results in
error.

Data member minute also private;

attempts to access private
members produces error.
Errors produced by
attempting to access private
members.

d:\cpp\oop\code.cpp(16) : error C2248:

'hour' : cannot access private member declared in class 'Time'
d:\cpp\oop\code.cpp(19) : error C2248:
'minute' : cannot access private member declared in class 'Time'
imranihsan.com

OOP 02 - Classes - I

17

5/14/2014

+ 2.8 Controlling Access to Members

Class member access

struct member access

Default private
Explicitly set to private, public, protected

Default public
Explicitly set to private, public, protected

Access to classs private data

Controlled with access functions (accessor methods)

Get function
Read private data
Set function
Modify private data

imranihsan.com

OOP 02 - Classes - I

+ 2.9 Access Functions and Utility Functions

Access functions

public
Read/display data
Predicate functions
Check conditions

Utility functions (helper functions)

private
Support operation of public member functions
Not intended for direct client use

imranihsan.com

OOP 02 - Classes - I

18

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// salesp.h
// SalesPerson class definition.
// Member functions defined in salesp.cpp.
#ifndef SALESP_H
#define SALESP_H
class SalesPerson {
public:
SalesPerson();
//
void getSalesFromUser();
//
void setSales( int, double ); //
void printAnnualSales();
//
private:
double totalAnnualSales();
double sales[ 12 ];

Set access function performs

validity checks.

constructor
input sales from keyboard
set sales for a month
summarize and print sales

// utility function
// 12 monthly sales figures

}; // end class SalesPerson

#endif

private utility function.

OOP 02 - Classes - I

imranihsan.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// salesp.cpp
// Member functions for class SalesPerson.
#include <iostream>
using
using
using
using

std::cout;
std::cin;
std::endl;
std::fixed;

#include <iomanip>
using std::setprecision;
// include SalesPerson class definition from salesp.h
#include "salesp.h"
// initialize elements of array sales to 0.0
SalesPerson::SalesPerson()
{
for ( int i = 0; i < 12; i++ )
sales[ i ] = 0.0;
} // end SalesPerson constructor

imranihsan.com

OOP 02 - Classes - I

19

5/14/2014

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// get 12 sales figures from the user at the keyboard

void SalesPerson::getSalesFromUser()
{
double salesFigure;
for ( int i = 1; i <= 12; i++ ) {
cout << "Enter sales amount for month " << i << ": ";
cin >> salesFigure;
setSales( i, salesFigure );
} // end for

Set access function performs

validity checks.

} // end function getSalesFromUser

// set one of the 12 monthly sales figures; function subtracts

// one from month value for proper subscript in sales array
void SalesPerson::setSales( int month, double amount )
{
// test for valid month and amount values
if ( month >= 1 && month <= 12 && amount > 0 )
sales[ month - 1 ] = amount; // adjust for subscripts 0-11
else // invalid month or amount value
cout << "Invalid month or sales figure" << endl;

OOP 02 - Classes - I

imranihsan.com

49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

} // end function setSales

// print total annual sales (with help of utility function)
void SalesPerson::printAnnualSales()
{
cout << setprecision( 2 ) << fixed
<< "\nThe total annual sales are: $"
<< totalAnnualSales() << endl; // call utility function
} // end function printAnnualSales
// private utility function to total annual sales
double SalesPerson::totalAnnualSales()
{
double total = 0.0;
// initialize total
for ( int i = 0; i < 12; i++ )
total += sales[ i ];

private utility function to help

function printAnnualSales;
encapsulates logic of
manipulating sales array.

// summarize sales results

return total;
} // end function totalAnnualSales

imranihsan.com

OOP 02 - Classes - I

20

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// program.cpp
// Demonstrating a utility function.
// Compile this program with salesp.cpp
// include SalesPerson class definition from salesp.h
#include "salesp.h"
int main()
{
SalesPerson s;

// create SalesPerson object s

s.getSalesFromUser();
s.printAnnualSales();

// note simple sequential code; no

// control structures in main

return 0;
} // end main

OOP 02 - Classes - I

imranihsan.com

Simple sequence of member

function calls; logic
encapsulated in member
functions.

Enter
Enter
Enter
Enter
Enter
Enter
Enter
Enter
Enter
Enter
Enter
Enter

sales
sales
sales
sales
sales
sales
sales
sales
sales
sales
sales
sales

amount
amount
amount
amount
amount
amount
amount
amount
amount
amount
amount
amount

for
for
for
for
for
for
for
for
for
for
for
for

month
month
month
month
month
month
month
month
month
month
month
month

1: 5314.76
2: 4292.38
3: 4589.83
4: 5534.03
5: 4376.34
6: 5698.45
7: 4439.22
8: 5893.57
9: 4909.67
10: 5123.45
11: 4024.97
12: 5923.92

The total annual sales are: $60120.59

imranihsan.com

OOP 02 - Classes - I

21

5/14/2014

+ 2.10 Initializing Class Objects: Constructors

Constructors

Initialize data members

Or can set later
Same name as class
No return type

Initializers

Passed as arguments to constructor

In parentheses to right of class name before semicolon
Class-type ObjectName( value1,value2,);

imranihsan.com

OOP 02 - Classes - I

+ 2.11

Using Default Arguments with

Constructors

Constructors

Can specify default arguments

Default constructors
Defaults all arguments
OR

Explicitly requires no arguments

Can be invoked with no arguments
Only one per class

imranihsan.com

OOP 02 - Classes - I

22

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// time2.h
// Declaration of class Time.
// Member functions defined in time2.cpp.
// prevent multiple inclusions of header file
#ifndef TIME2_H
#define TIME2_H

Default constructor specifying

all arguments.

// Time abstract data type definition

class Time {
public:
Time( int = 0, int = 0, int = 0); // default constructor
void setTime( int, int, int ); // set hour, minute, second
void printUniversal();
// print universal-time format
void printStandard();
// print standard-time format
private:
int hour;
int minute;
int second;

// 0 - 23 (24-hour clock format)

// 0 - 59
// 0 - 59

}; // end class Time

#endif

imranihsan.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

OOP 02 - Classes - I

// time2.cpp
// Member-function definitions for class Time.
#include <iostream>
using std::cout;
#include <iomanip>
using std::setfill;
using std::setw;
// include definition of class Time from time2.h
#include "time2.h"
// Time constructor initializes each data member to zero;
// ensures all Time objects start in a consistent state
Time::Time( int hr, int min, int sec )
{
setTime( hr, min, sec ); // validate and set time

Constructor calls setTime to

validate passed (or default)
values.

} // end Time constructor

imranihsan.com

OOP 02 - Classes - I

23

5/14/2014

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// set new Time value using universal time, perform validity

// checks on the data values and set invalid values to zero
void Time::setTime( int h, int m, int s )
{
hour = ( h >= 0 && h < 24 ) ? h : 0;
minute = ( m >= 0 && m < 60 ) ? m : 0;
second = ( s >= 0 && s < 60 ) ? s : 0;
} // end function setTime
// print Time in universal format
void Time::printUniversal()
{
cout << setfill( '0' ) << setw( 2 ) << hour << ":"
<< setw( 2 ) << minute << ":"
<< setw( 2 ) << second;
} // end function printUniversal

imranihsan.com

42
43
44
45
46
47
48
49
50

OOP 02 - Classes - I

// print Time in standard format

void Time::printStandard()
{
cout << ( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 )
<< ":" << setfill( '0' ) << setw( 2 ) << minute
<< ":" << setw( 2 ) << second
<< ( hour < 12 ? " AM" : " PM" );
} // end function printStandard

imranihsan.com

OOP 02 - Classes - I

24

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// code.cpp
// Demonstrating a default constructor for class Time.
#include <iostream>
using std::cout;
using std::endl;
// include definition of class Time from time2.h
#include "time2.h"
int main()
{
Time t1;
Time t2(
Time t3(
Time t4(
Time t5(

//
2 );
//
21, 34 );
//
12, 25, 42 ); //
27, 74, 99 ); //

Initialize Time objects using

default arguments.

all arguments defaulted

minute and second defaulted
second defaulted
all values specified
all bad values specified

cout << "Constructed with:\n\n"

<< "all default arguments:\n ";
t1.printUniversal(); // 00:00:00
cout << "\n ";
t1.printStandard();
// 12:00:00 AM

Initialize Time object with

invalid values; validity
checking will set values to 0.

OOP 02 - Classes - I

imranihsan.com

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

cout << "\n\nhour specified; default minute and second:\n

t2.printUniversal(); // 02:00:00
cout << "\n ";
t2.printStandard();
// 2:00:00 AM

";

cout << "\n\nhour and minute specified; default second:\n

t3.printUniversal(); // 21:34:00
cout << "\n ";
t3.printStandard();
// 9:34:00 PM

";

cout << "\n\nhour, minute, and second specified:\n

t4.printUniversal(); // 12:25:42
cout << "\n ";
t4.printStandard();
// 12:25:42 PM
cout << "\n\nall invalid values specified:\n
t5.printUniversal(); // 00:00:00
cout << "\n ";
t5.printStandard();
// 12:00:00 AM
cout << endl;

";

";

t5 constructed with invalid

arguments; values set to 0.

return 0;
} // end main

imranihsan.com

OOP 02 - Classes - I

25

5/14/2014

Constructed with:
all default arguments:
00:00:00
12:00:00 AM
hour specified; default minute and second:
02:00:00
2:00:00 AM
hour and minute specified; default second:
21:34:00
9:34:00 PM
hour, minute, and second specified:
12:25:42
12:25:42 PM
all invalid values specified:
00:00:00
12:00:00 AM

imranihsan.com

OOP 02 - Classes - I

+ 2.12 Destructors

Destructors

Special member function

Same name as class
Preceded with tilde (~)
No arguments
No return value
Cannot be overloaded
Performs termination housekeeping
Before system reclaims objects memory
Reuse memory for new objects
No explicit destructor
Compiler creates empty destructor

imranihsan.com

OOP 02 - Classes - I

26

5/14/2014

+ 2.13

When Constructors and Destructors

Are Called

Constructors and destructors

Called implicitly by compiler

Order of function calls

Depends on order of execution

When execution enters and exits scope of objects
Generally, destructor calls reverse order of constructor calls

imranihsan.com

OOP 02 - Classes - I

+ 2.13

When Constructors and Destructors

Are Called

Order of constructor, destructor function calls

Global scope objects

Constructors
Before any other function (including main)
Destructors
When main terminates (or exit function called)
Not called if program terminates with abort

Automatic local objects

Constructors
When objects defined
Each time execution enters scope
Destructors
When objects leave scope
Execution exits block in which object defined
Not called if program ends with exit or abort

imranihsan.com

OOP 02 - Classes - I

27

5/14/2014

+ 2.13

When Constructors and Destructors

Are Called

Order of constructor, destructor function calls

static local objects

Constructors
Exactly once
When execution reaches point where object defined
Destructors
When main terminates or exit function called
Not called if program ends with abort

imranihsan.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

OOP 02 - Classes - I

// create.h
// Definition of class CreateAndDestroy.
// Member functions defined in create.cpp.
#ifndef CREATE_H
#define CREATE_H
class CreateAndDestroy {
public:
CreateAndDestroy( int, char * );
~CreateAndDestroy();
private:
int objectID;
char *message;

Constructor and destructor

member functions.

// constructor
// destructor

private members to show

order of constructor,
destructor function calls.

}; // end class CreateAndDestroy

#endif

imranihsan.com

OOP 02 - Classes - I

28

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// create.cpp
// Member-function definitions for class CreateAndDestroy
#include <iostream>
using std::cout;
using std::endl;
// include CreateAndDestroy class definition from create.h
#include "create.h"
// constructor
CreateAndDestroy::CreateAndDestroy(
int objectNumber, char *messagePtr )
{
objectID = objectNumber;
message = messagePtr;
cout << "Object " << objectID << "
<< message << endl;

Output message to
demonstrate timing of
constructor function calls.
constructor runs

"

} // end CreateAndDestroy constructor

OOP 02 - Classes - I

imranihsan.com

23
24
25
26
27
28
29
30
31
32

// destructor
CreateAndDestroy::~CreateAndDestroy()
{
// the following line is for pedagogic purposes only
cout << ( objectID == 1 || objectID == 6 ? "\n" : "" );
cout << "Object " << objectID << "
<< message << endl;
} // end ~CreateAndDestroy destructor

imranihsan.com

destructor runs

"

Output message to
demonstrate timing of
destructor function calls.

OOP 02 - Classes - I

29

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// code.cpp
// Demonstrating the order in which constructors and
// destructors are called.
#include <iostream>
using std::cout;
using std::endl;
// include CreateAndDestroy class definition from create.h
#include "create.h"
void create( void );

Create variable with global

scope.

// prototype

// global object
CreateAndDestroy first( 1, "(global before main)" );
int main()
Create local automatic object.
{
cout << "\nMAIN FUNCTION: EXECUTION BEGINS" << endl;
CreateAndDestroy second( 2, "(local automatic in main)" );

Create static local object.

static CreateAndDestroy third(

3, "(local static in main)" );

OOP 02 - Classes - I

imranihsan.com

Create local automatic objects.

26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

create();

// call function to create objects

cout << "\nMAIN FUNCTION: EXECUTION RESUMES" << endl;

CreateAndDestroy fourth( 4, "(local automatic in main)" );
cout << "\nMAIN FUNCTION: EXECUTION ENDS" << endl;
return 0;
} // end main

Create local automatic object.

Create local automatic object

// function to create objects

in function.
void create( void )
{
cout << "\nCREATE FUNCTION: EXECUTION BEGINS" << endl;
CreateAndDestroy fifth( 5, "(local automatic in create)" );
static CreateAndDestroy sixth(
6, "(local static in create)" );
CreateAndDestroy seventh(
7, "(local automatic in create)" );

Create static local object in

function.
Create local automatic object
in function.

cout << "\nCREATE FUNCTION: EXECUTION ENDS\" << endl;

} // end function create

imranihsan.com

OOP 02 - Classes - I

30

5/14/2014

Object 1

constructor runs

(global before main)

MAIN FUNCTION: EXECUTION BEGINS

Object 2
constructor runs
(local automatic in main)
Object 3
constructor runs
(local static in main)
CREATE
Object
Object
Object

FUNCTION: EXECUTION BEGINS

5
constructor runs
(local automatic in create)
6
constructor runs
(local static in create)
7
constructor runs
(local automatic in create)

CREATE FUNCTION: EXECUTION ENDS

Object 7
destructor runs
(local automatic in create)
Object 5
destructor runs
(local automatic in create)
MAIN FUNCTION: EXECUTION RESUMES
Object 4
constructor runs
(local automatic in main)
MAIN FUNCTION: EXECUTION ENDS
Object 4
destructor runs
Object 2
destructor runs
Object 6
destructor runs
Object 3
destructor runs

(local
(local
(local
(local

Object 1

(global before main)

destructor runs

automatic
automatic
static in
static in

in main)
in main)
create)
main)

Global object
constructed before
main execution
and destroyed last.

Destructors for local

automatic objects in main
called in reverse order of
constructors.
Local automatic objects
destroyed after function
execution ends in reverse
order of construction.
Local static object exists
until program termination.

Local static object

constructed on first function
call and destroyed after
main execution ends.
imranihsan.com

+ 2.14

Using Set and Get Functions

Set functions

OOP 02 - Classes - I

Perform validity checks before modifying private data

Notify if invalid values
Indicate with return values

Get functions

Query functions
Control format of data returned

imranihsan.com

OOP 02 - Classes - I

31

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// time3.h
// Declaration of class Time.
// Member functions defined in time3.cpp
// prevent multiple inclusions of header file
#ifndef TIME3_H
#define TIME3_H
class Time {
public:
Time( int = 0, int = 0, int = 0 );

// default constructor

Set functions.

// set functions
void setTime( int, int, int ); // set hour, minute, second
void setHour( int );
// set hour
void setMinute( int ); // set minute
void setSecond( int ); // set second
// get functions
int getHour();
int getMinute();
int getSecond();

Get functions.
// return hour
// return minute
// return second

OOP 02 - Classes - I

imranihsan.com

25
26
27
28
29
30
31
32
33
34
35

void printUniversal(); // output universal-time format

void printStandard(); // output standard-time format
private:
int hour;
int minute;
int second;

// 0 - 23 (24-hour clock format)

// 0 - 59
// 0 - 59

}; // end clas Time

#endif

imranihsan.com

OOP 02 - Classes - I

32

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// time3.cpp
// Member-function definitions for Time class.
#include <iostream>
using std::cout;
#include <iomanip>
using std::setfill;
using std::setw;
// include definition of class Time from time3.h
#include "time3.h"
// constructor function to initialize private data;
// calls member function setTime to set variables;
// default values are 0 (see class definition)
Time::Time( int hr, int min, int sec )
{
setTime( hr, min, sec );
} // end Time constructor

OOP 02 - Classes - I

imranihsan.com

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// set hour, minute and second values

void Time::setTime( int h, int m, int s )
{
setHour( h );
setMinute( m );
setSecond( s );

Call set functions to

perform validity checking.

} // end function setTime

// set hour value
void Time::setHour( int h )
{
hour = ( h >= 0 && h < 24 ) ? h : 0;
} // end function setHour
// set minute value
void Time::setMinute( int m )
{
minute = ( m >= 0 && m < 60 ) ? m : 0;

Set functions perform

validity checks before
modifying data.

} // end function setMinute

imranihsan.com

OOP 02 - Classes - I

33

5/14/2014

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// set second value

void Time::setSecond( int s )
{
second = ( s >= 0 && s < 60 ) ? s : 0;

Set function performs

validity checks before
modifying data.

} // end function setSecond

// return hour value
int Time::getHour()
{
return hour;
} // end function getHour

Get functions allow client to

read data.

// return minute value

int Time::getMinute()
{
return minute;
} // end function getMinute

OOP 02 - Classes - I

imranihsan.com

68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

// return second value

int Time::getSecond()
{
return second;
} // end function getSecond

Get function allows client to

read data.

// print Time in universal format

void Time::printUniversal()
{
cout << setfill( '0' ) << setw( 2 ) << hour << ":"
<< setw( 2 ) << minute << ":"
<< setw( 2 ) << second;
} // end function printUniversal
// print Time in standard format
void Time::printStandard()
{
cout << ( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 )
<< ":" << setfill( '0' ) << setw( 2 ) << minute
<< ":" << setw( 2 ) << second
<< ( hour < 12 ? " AM" : " PM" );
} // end function printStandard

imranihsan.com

OOP 02 - Classes - I

34

5/14/2014

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// code.cpp
// Demonstrating the Time class set and get functions
#include <iostream>
using std::cout;
using std::endl;
// include definition of class Time from time3.h
#include "time3.h"
void incrementMinutes( Time &, const int );
int main()
{
Time t;

// prototype

Invoke set functions to set

valid values.
// create Time object

// set time using individual set functions

t.setHour( 17 );
// set hour to valid value
t.setMinute( 34 );
// set minute to valid value
t.setSecond( 25 );
// set second to valid value

OOP 02 - Classes - I

imranihsan.com

22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// use get functions to obtain hour, minute and second

cout << "Result of setting all valid values:\n"
<< " Hour: " << t.getHour()
Attempt to set invalid values
<< " Minute: " << t.getMinute()
using set functions.
<< " Second: " << t.getSecond();
// set time using individual set functions
t.setHour( 234 );
// invalid hour set to 0
t.setMinute( 43 );
// set minute to valid value
t.setSecond( 6373 ); // invalid second set to 0

Invalid values result in

setting data members to 0.

// display hour, minute and second after setting

// invalid hour and second values
cout << "\n\nResult of attempting to set invalid hour and"
<< " second:\n Hour: " << t.getHour()
Modify data members using
<< " Minute: " << t.getMinute()
function setTime.
<< " Second: " << t.getSecond() << "\n\n";
t.setTime( 11, 58, 0 );
incrementMinutes( t, 3 );

// set time
// increment t's minute by 3

return 0;
} // end main

imranihsan.com

OOP 02 - Classes - I

35

5/14/2014

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// add specified number of minutes to a Time object

void incrementMinutes( Time &tt, const int count )
{
cout << "Incrementing minute " << count
<< " times:\nStart time: ";
tt.printStandard();

Using get functions to read

data and set functions to
modify data.

for ( int i = 0; i < count; i++ ) {

tt.setMinute( ( tt.getMinute() + 1 ) % 60 );
if ( tt.getMinute() == 0 )
tt.setHour( ( tt.getHour() + 1 ) % 24);
cout << "\nminute + 1: ";
tt.printStandard();
} // end for
cout << endl;
} // end function incrementMinutes

OOP 02 - Classes - I

imranihsan.com

Result of setting all valid values:

Hour: 17 Minute: 34 Second: 25
Result of attempting to set invalid hour and second:
Hour: 0 Minute: 43 Second: 0
Incrementing minute 3 times:
Start time: 11:58:00 AM
minute + 1: 11:59:00 AM
minute + 1: 12:00:00 PM
minute + 1: 12:01:00 PM

imranihsan.com

Attempting to set data

members with invalid
values results in error
message and members set
to 0.

OOP 02 - Classes - I

36

5/14/2014

+ 2.15

Assigning objects

Default Memberwise Assignment

Assignment operator (=)

Can assign one object to another of same type
Default: memberwise assignment
Each right member assigned individually to left member

Passing, returning objects

Objects passed as function arguments

Objects returned from functions
Default: pass-by-value
Copy of object passed, returned
Copy constructor
Copy original values into new object

imranihsan.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

OOP 02 - Classes - I

// progtam.cpp
// Demonstrating that class objects can be assigned
// to each other using default memberwise assignment.
#include <iostream>
using std::cout;
using std::endl;
// class Date definition
class Date {
public:
Date( int = 1, int = 1, int = 1990 ); // default constructor
void print();
private:
int month;
int day;
int year;
}; // end class Date

imranihsan.com

OOP 02 - Classes - I

37

5/14/2014

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

// Date constructor with no range checking

Date::Date( int m, int d, int y )
{
month = m;
day = d;
year = y;
} // end Date constructor
// print Date in the format mm-dd-yyyy
void Date::print()
{
cout << month << '-' << day << '-' << year;
} // end function print
int main()
{
Date date1( 7, 4, 2002 );
Date date2; // date2 defaults to 1/1/1990

OOP 02 - Classes - I

imranihsan.com

44
45
46
47
48
49
50
51
52
53
54
55
56
57

cout << "date1 = ";

date1.print();
cout << "\ndate2 = ";
date2.print();
date2 = date1;

Default memberwise
assignment assigns each
member of date1
individually to each
member of date2.

// default memberwise assignment

cout << "\n\nAfter default memberwise assignment, date2 = ";

date2.print();
cout << endl;
return 0;
} // end main

date1 = 7-4-2002
date2 = 1-1-1990
After default memberwise assignment, date2 = 7-4-2002
imranihsan.com

OOP 02 - Classes - I

38

5/14/2014

+ 2.16

Software Reusability

Software reusability

Class libraries
Well-defined
Carefully tested
Well-documented
Portable
Widely available
Speeds development of powerful, high-quality software
Rapid applications development (RAD)
Resulting problems
Cataloging schemes
Licensing schemes
Protection mechanisms

imranihsan.com

OOP 02 - Classes - I

39