Classes and Objects

const (Constant) Objects and const

Member Functions
Principle of least privilege
Only give objects permissions they need, no more

Keyword const
Specify that an object is not modifiable
Any attempt to modify the object is a syntax error
Example
const Time noon( 12, 0, 0 );
Declares a const object noon of class Time and
initializes it to 12

const (Constant) Objects and const

Member Functions

const objects require const functions

Member functions declared const cannot modify their object
const must be specified in function prototype and definition
Prototype:
ReturnType FunctionName(param1,param2) const;
Definition:
ReturnType FunctionName(param1,param2) const { }
Example:
int A::getValue() const { return
privateDataMember };
Returns the value of a data member but doesnt modify anything so is
declared const
Constructors / Destructors cannot be const
They need to initialize variables, therefore modifying them

1 // Fig. 7.1: time5.h

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// Declaration of the class Time.

// Member functions defined in time5.cpp
#ifndef TIME5_H
#define TIME5_H
class Time {
public:
Time( int = 0, int = 0, int = 0 );

// default constructor

// set functions
void setTime( int, int, int ); // set time
void setHour( int );
// set hour
void setMinute( int );
// set minute
void setSecond( int );
// set second
// get functions (normally declared const)
int getHour() const;
// return hour
int getMinute() const;
// return minute
int getSecond() const;
// return second
// print functions (normally declared const)
void printMilitary() const; // print military time
void printStandard();
// print standard time
private:
int hour;
// 0 - 23
int minute;
// 0 - 59
int second;
// 0 - 59
};
#endif

32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

// Fig. 7.1: time5.cpp

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

The constructor is non-const but it can be

called for const objects.

#include "time5.h"
// Constructor function to initialize private data.
// Default values are 0 (see class definition).
Time::Time( int hr, int min, int sec )
{ setTime( hr, min, sec ); }
// Set the values of hour, minute, and second.
void Time::setTime( int h, int m, int s )
{
setHour( h );
setMinute( m );
setSecond( s );
}
// Set the hour value
void Time::setHour( int h )
{ hour = ( h >= 0 && h < 24 ) ? h : 0; }
// Set the minute value
void Time::setMinute( int m )
{ minute = ( m >= 0 && m < 60 ) ? m : 0; }
// Set the second value
void Time::setSecond( int s )
{ second = ( s >= 0 && s < 60 ) ? s : 0; }

64
65 // Get the hour value
66 int Time::getHour() const { return hour; }
67
68 // Get the minute value
69 int Time::getMinute() const { return minute; }
70
71 // Get the second value
72 int Time::getSecond() const { return second; }
73
74 // Display military format time: HH:MM
75 void Time::printMilitary() const
76 {
77

cout << ( hour < 10 ? "0" : "" )

78

<< ( minute < 10 ? "0" : ""

Non-const functions cannot use

const objects, even if they dont
<< hour << ":"
modify them (such as
) << minute;printStandard).

79 }
80
81 // Display standard format time: HH:MM:SS AM (or PM)
82 void Time::printStandard()

// should be const

83 {
84

cout << ( ( hour == 12 ) ? 12 : hour % 12 ) << ":"

85

<< ( minute < 10 ? "0" : "" ) << minute << ":"

86

<< ( second < 10 ? "0" : "" ) << second

87

<< ( hour < 12 ? " AM" : " PM" );

88 }

89 // Fig. 7.1: fig07_01.cpp

90 // Attempting to access a const object with
91 // non-const member functions.
92 #include "time5.h"
93
94 int main()
95 {
96
Time wakeUp( 6, 45, 0 );
// non-constant object
97
const Time noon( 12, 0, 0 );
// constant object
98
99
// MEMBER FUNCTION
OBJECT
100
wakeUp.setHour( 18 ); // non-const
non-const
101
102
noon.setHour( 12 );
// non-const
const
103
104
wakeUp.getHour();
// const
non-const
105
106
noon.getMinute();
// const
const
107
noon.printMilitary(); // const
const
108
noon.printStandard(); // non-const
const
109
return 0;
110 }
Compiling...
Fig07_01.cpp
d:fig07_01.cpp(14) : error C2662: 'setHour' : cannot convert 'this'
pointer from 'const class Time' to 'class Time &'
Conversion loses qualifiers
d:\fig07_01.cpp(20) : error C2662: 'printStandard' : cannot convert
'this' pointer from 'const class Time' to 'class Time &'
Conversion loses qualifiers
Time5.cpp
Error executing cl.exe.
test.exe - 2 error(s), 0 warning(s)

const (Constant) Objects and const

Member Functions
Member initializer syntax
Data member increment in class Increment
constructor for Increment is modified as follows:
Increment::Increment( int c, int i )
: increment( i )
{ count = c; }

: increment( i ) initializes increment to i

All data members can be initialized using member
initializer syntax
consts and references must be initialized using
member initializer syntax
Multiple member initializers
Use comma-separated list after the colon

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
26
27
28
29
30
31
32
33

// Fig. 7.2: fig07_02.cpp

// Using a member initializer to initialize a
// constant of a built-in data type.
#include <iostream>
using std::cout;
using std::endl;
class Increment {
public:
Increment( int c = 0, int i = 1 );
void addIncrement() { count += increment; }
void print() const;
private:
int count;
const int increment;
};

// const data member

// Constructor for class Increment

Increment::Increment( int c, int i )
: increment( i )
// initializer for const member
{ count = c; }
// Print the data
void Increment::print() const
{
cout << "count = " << count
<< ", increment = " << increment << endl;
}
int main()
{

If we try to initialize increment

with an assignment statement
(such as increment = i )
instead of a member initializer we
get an error.

34

Increment value( 10, 5 );

35
36

cout << "Before incrementing: ";

37

value.print();

38
39

for ( int j = 0; j < 3; j++ ) {

40

value.addIncrement();

41

cout << "After increment " << j + 1 << ": ";

42

value.print();

43

44
45

return 0;

46 }

Before incrementing: count

After increment 1: count =
After increment 2: count =
After increment 3: count =

= 10, increment
15, increment =
20, increment =
25, increment =

= 5
5
5
5

Objects as Members of Classes

Composition
Class has objects of other classes as members

Construction of objects
Member objects constructed in order declared
Not in order of constructors member initializer list

Constructed before their enclosing class objects

(host objects)

// Fig. 7.4: date1.h

// Declaration of the Date class.

// Member functions defined in date1.cpp

#ifndef DATE1_H

#define DATE1_H

6
7

class Date {

public:

Date( int = 1, int = 1, int = 1900 ); // default constructor

10

void print() const;

11

~Date();

// print date in month/day/year format

// provided to confirm destruction order

12 private:
13

int month;

// 1-12

14

int day;

// 1-31 based on month

15

int year;

// any year

16
17

// utility function to test proper day for month and year

18

int checkDay( int );

19 };
20
21 #endif

22 // Fig. 7.4: date1.cpp

23 // Member function definitions for Date class.
24 #include <iostream>
25
26 using std::cout;
27 using std::endl;
28
29 #include "date1.h"
30
31 // Constructor: Confirm proper value for month;
32 // call utility function checkDay to confirm proper
33 // value for day.
34 Date::Date( int mn, int dy, int yr )
35 {
36

if ( mn > 0 && mn <= 12 )

37
38

// validate the month

month = mn;
else {

39

month = 1;

40

cout << "Month " << mn << " invalid. Set to month 1.\n";

41

42
43

year = yr;

// should validate yr

44

day = checkDay( dy );

// validate the day

45
46

cout << "Date object constructor for date ";

47

print();

48

cout << endl;

49 }
50

// interesting: a print with no arguments

Constructor will print

a line when called.

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// Print Date object in form month/day/year

void Date::print() const
{ cout << month << '/' << day << '/' << year; }
// Destructor: provided to confirm destruction order
Date::~Date()
{
cout << "Date object destructor for date ";
print();
cout << endl;
}
// Utility function to confirm proper day value
// based on month and year.
// Is the year 2000 a leap year?
int Date::checkDay( int testDay )
{
static const int daysPerMonth[ 13 ] =
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if ( testDay > 0 && testDay <= daysPerMonth[ month ] )
return testDay;
if ( month == 2 &&
// February: Check for leap year
testDay == 29 &&
( year % 400 == 0 ||
( year % 4 == 0 && year % 100 != 0 ) ) )
return testDay;
cout << "Day " << testDay << " invalid. Set to day 1.\n";
return 1;
}

// leave object in consistent state if bad value

84 // Fig. 7.4: emply1.h

85 // Declaration of the Employee class.
86 // Member functions defined in emply1.cpp
87 #ifndef EMPLY1_H
88 #define EMPLY1_H
89
90 #include "date1.h"
91
92 class Employee {
93 public:
94

Employee( char *, char *, int, int, int, int, int, int );

95

void print() const;

96

~Employee();

// provided to confirm destruction order

97 private:
98

char firstName[ 25 ];

99

char lastName[ 25 ];

100

const Date birthDate;

101

const Date hireDate;

102 };
103
104 #endif

Composition - including
objects of other classes.

105 // Fig. 7.4: emply1.cpp

106 // Member function definitions for Employee class.
107 #include <iostream>
108
109 using std::cout;
110 using std::endl;
111
112 #include <cstring>
113 #include "emply1.h"
114 #include "date1.h"
115
116 Employee::Employee( char *fname, char *lname,
117
int bmonth, int bday, int byear,
118
int hmonth, int hday, int hyear )
119
: birthDate( bmonth, bday, byear ),
120
hireDate( hmonth, hday, hyear )
121 {
122
// copy fname into firstName and be sure that it fits
123
int length = strlen( fname );
124
length = ( length < 25 ? length : 24 );
125
strncpy( firstName, fname, length );
126
firstName[ length ] = '\0';
127
128
// copy lname into lastName and be sure that it fits
129
length = strlen( lname );
130
length = ( length < 25 ? length : 24 );
Constructor will
131
strncpy( lastName, lname, length );
print a line when
132
lastName[ length ] = '\0';
called.
133
134
cout << "Employee object constructor: "
135
<< firstName << ' ' << lastName << endl;
136 }

137
138 void Employee::print() const
139 {
140

cout << lastName << ", " << firstName << "\nHired: ";

141

hireDate.print();

142

cout << "

143

birthDate.print();

144

cout << endl;

Birth date: ";

145 }
146

The print function is const and will

print whenever a Date object is created
or destroyed. It can print const
objects because it is a const function.
Print requires no arguments, it is
linked implicitly to the object that calls
it.

147 // Destructor: provided to confirm destruction order

148 Employee::~Employee()
149 {
150
151
152 }

cout << "Employee object destructor: "

<< lastName << ", " << firstName << endl;

Destructor will
print a line when
called.

153 // Fig. 7.4: fig07_04.cpp

154 // Demonstrating composition: an object with member objects.
155 #include <iostream>
156
157 using std::cout;
158 using std::endl;
159
160 #include "emply1.h"
161
162 int main()

Only emply.h has to be loaded;

that file has the command to load
date.h.

163 {
164

Employee e( "Bob", "Jones", 7, 24, 1949, 3, 12, 1988 );

165
166

cout << '\n';

167

e.print();

168
169

cout << "\nTest Date constructor with invalid values:\n";

170

Date d( 14, 35, 1994 );

171

cout << endl;

172

return 0;

173 }

// invalid Date values

Date object constructor for date 7/24/1949

Date object constructor for date 3/12/1988
Employee object constructor: Bob Jones
Jones, Bob
Hired: 3/12/1988

Birth date: 7/24/1949

Test Date constructor with invalid values:

Month 14 invalid. Set to month 1.
Day 35 invalid. Set to day 1.
Date object constructor for date 1/1/1994
Date object destructor for date 1/1/1994
Employee object destructor: Jones, Bob
Date object destructor for date 3/12/1988
Date object destructor for date 7/24/1949

Notice how inner objects are created first and

destroyed last.

Program Output

friend Functions and friend Classes

friend function and friend classes
Can access private and protected members of
another class
friend functions are not member functions of class
Defined outside of class scope

Properties of friendship
Friendship is granted, not taken
Not symmetric (if B a friend of A, A not necessarily
a friend of B)
Not transitive (if A a friend of B, B a friend of C,
A not necessarily a friend of C)

friend Functions and friend Classes

friend declarations
To declare a friend function
Type friend before the function prototype in the class that is
giving friendship
friend int myFunction( int x );

should appear in the class giving friendship

To declare a friend class

Type friend class Classname in the class that is
giving friendship
if ClassOne is granting friendship to ClassTwo,
friend class ClassTwo;

should appear in ClassOne's definition

1
2
3

// Fig. 7.5: fig07_05.cpp

// Friends can access private members of a class.
#include <iostream>

4
5
6
7

using std::cout;
using std::endl;

8 // Modified Count class

9 class Count {
10
friend void setX( Count &, int ); // friend declaration
11 public:
12
Count() { x = 0; }
// constructor
13
void print() const { cout << x << endl; } // output
14 private:
15
int x; // data member
16
17
18
19
20

};
// Can modify private data of Count because
// setX is declared as a friend function of Count
void setX( Count &c, int val )

21 {
22
23 }
24

Changing private variables allowed.

c.x = val;

// legal: setX is a friend of Count

25 int main()
26 {
27
Count counter;
28
29
30

cout << "counter.x after instantiation: ";

counter.print();

31

cout << "counter.x after call to setX friend function: ";

32

setX( counter, 8 );

33

counter.print();

34

return 0;

// set x with a friend

35 }

counter.x after instantiation: 0

counter.x after call to setX friend function: 8

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
26
27
28
29
30
31

// Fig. 7.6: fig07_06.cpp

// Non-friend/non-member functions cannot access
// private data of a class.
#include <iostream>
using std::cout;
using std::endl;
// Modified Count class
class Count {
public:
Count() { x = 0; }
// constructor
void print() const { cout << x << endl; } // output
private:
int x; // data member
};
// Function tries to modify private data of Count,
// but cannot because it is not a friend of Count.
void cannotSetX( Count &c, int val )
{
c.x = val; // ERROR: 'Count::x' is not accessible
}
int main()
{
Count counter;
cannotSetX( counter, 3 ); // cannotSetX is not a friend
return 0;
}

Compiling...
Fig07_06.cpp
D:\books\2000\cpphtp3\examples\Ch07\Fig07_06\Fig07_06.cpp(22) :
error C2248: 'x' : cannot access private member declared in
class 'Count'
D:\books\2000\cpphtp3\examples\Ch07\Fig07_06\
Fig07_06.cpp(15) : see declaration of 'x'
Error executing cl.exe.
test.exe - 1 error(s), 0 warning(s)

Program Output

Using the this Pointer

this pointer
Allows objects to access their own address
Not part of the object itself
Implicit first argument on non-static member function call to the object
Implicitly reference member data and functions
The type of the this pointer depends upon the type of the object and
whether the member function using this is const
In a non-const member function of Employee, this has type
Employee * const
Constant pointer to an Employee object
In a const member function of Employee, this has type
const Employee * const
Constant pointer to a constant Employee object

Using the this Pointer

Examples using this
For a member function print data member x, either
this->x
or
( *this ).x

Cascaded member function calls

Function returns a reference pointer to the same object
{ return *this; }

Other functions can operate on that pointer

Functions that do not return references must be called last

Using the this Pointer

Example of cascaded member function calls
Member functions setHour, setMinute, and
setSecond all return *this (reference to an object)
For object t, consider
t.setHour(1).setMinute(2).setSecond(3);

Executes t.setHour(1), returns *this (reference to

object) and the expression becomes
t.setMinute(2).setSecond(3);

Executes t.setMinute(2), returns reference and

becomes
t.setSecond(3);

Executes t.setSecond(3), returns reference and

becomes
t;

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
26
27
28
29
30
31
32

// Fig. 7.7: fig07_07.cpp

// Using the this pointer to refer to object members.
#include <iostream>
using std::cout;
using std::endl;
class Test {
public:
Test( int = 0 );
void print() const;
private:
int x;
};
Test::Test( int a ) { x = a; }

// default constructor

// constructor

void Test::print() const

// ( ) around *this required
{
cout << "
x = " << x
<< "\n this->x = " << this->x
<< "\n(*this).x = " << ( *this ).x << endl;
}
int main()
{
Test testObject( 12 );
testObject.print();
return 0;
}

x = 12
this->x = 12
(*this).x = 12

All three methods have

the same result.

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
26
27
28
29
30
31
32
33

// Fig. 7.8: time6.h

// Cascading member function calls.
// Declaration of class Time.
// Member functions defined in time6.cpp
#ifndef TIME6_H
#define TIME6_H
class Time {
public:
Time( int = 0, int = 0, int = 0 );
// set functions
Time &setTime( int, int,
Time &setHour( int );
Time &setMinute( int );
Time &setSecond( int );

int );
// set
// set
// set

// default constructor

// set hour, minute, second

hour
minute
second

// get functions (normally declared const)

int getHour() const;
// return hour
int getMinute() const;
// return minute
int getSecond() const;
// return second
// print functions (normally declared const)
void printMilitary() const; // print military time
void printStandard() const; // print standard time
private:
int hour;
// 0 - 23
int minute;
// 0 - 59
int second;
// 0 - 59
};
#endif

Notice the Time & - function

returns a reference to a Time
object. Specify object in
function definition.

34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

// Fig. 7.8: time.cpp

// Member function definitions for Time class.
#include <iostream>
using std::cout;
#include "time6.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 ); }
// Set the values of hour, minute, and second.
Time &Time::setTime( int h, int m, int s )
Returning *this enables
{
cascading function calls
setHour( h );
setMinute( m );
setSecond( s );
return *this;
// enables cascading
}
// Set the hour value
Time &Time::setHour( int h )
{
hour = ( h >= 0 && h < 24 ) ? h : 0;
return *this;
}

// enables cascading

65 // Set the minute value

66 Time &Time::setMinute( int m )
67 {
68
69
70
71 }

minute = ( m >= 0 && m < 60 ) ? m : 0;

return *this;

// enables cascading

72
73 // Set the second value
74 Time &Time::setSecond( int s )
75 {
76
77
78
79 }

second = ( s >= 0 && s < 60 ) ? s : 0;

return *this;

// enables cascading

80
81 // Get the hour value
82 int Time::getHour() const { return hour; }
83
84 // Get the minute value
85 int Time::getMinute() const { return minute; }
86
87 // Get the second value
88 int Time::getSecond() const { return second; }
89
90 // Display military format time: HH:MM
91 void Time::printMilitary() const
92 {
93
94

cout << ( hour < 10 ? "0" : "" ) << hour << ":"
<< ( minute < 10 ? "0" : "" ) << minute;

Returning *this enables

cascading function calls

95 }
96
97 // Display standard format time: HH:MM:SS AM (or PM)
98 void Time::printStandard() const
99 {
100
cout << ( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 )
101
<< ":" << ( minute < 10 ? "0" : "" ) << minute
102
<< ":" << ( second < 10 ? "0" : "" ) << second
103
<< ( hour < 12 ? " AM" : " PM" );
104 }
105 // Fig. 7.8: fig07_08.cpp
106 // Cascading member function calls together
107 // with the this pointer
108 #include <iostream>
109
110 using std::cout;
111 using std::endl;
112
Notice cascading
113 #include "time6.h"
114
115 int main()
116 {
117
Time t;
118
119
t.setHour( 18 ).setMinute( 30 ).setSecond( 22 );
120
cout << "Military time: ";
121
t.printMilitary();
122
cout << "\nStandard time: ";
123
t.printStandard();
124
125
cout << "\n\nNew standard time: ";
126
t.setTime( 20, 20, 20 ).printStandard();

function calls.

127

cout << endl;

128
129

return 0;

130 }

Military time: 18:30

Standard time: 6:30:22 PM
New standard time: 8:20:20 PM

Dynamic Memory Allocation with

Operators new and delete
new and delete
Used for dynamic memory allocation
Superior to Cs malloc and free

new
Creates an object of the proper size, calls its constructor and returns a
pointer of the correct type

delete
Destroys object and frees space

Examples of new
TypeName *typeNamePtr;

Creates pointer to a TypeName object

typeNamePtr = new TypeName;

new creates TypeName object, returns pointer (which

typeNamePtr is set equal to)

Dynamic Memory Allocation with

Operators new and delete
Examples of delete
delete typeNamePtr;

Calls destructor for TypeName object and frees memory

Delete [] arrayPtr;

Used to dynamically delete an array

Initializing objects
double *thingPtr = new double( 3.14159 );

Initializes object of type double to 3.14159

int *arrayPtr = new int[ 10 ];

Creates a ten element int array and assigns it to

arrayPtr

static Class Members

static class members
Shared by all objects of a class
Normally, each object gets its own copy of each variable

Efficient when a single copy of data is enough

Only the static variable has to be updated

May seem like global variables, but have class scope

only accessible to objects of same class

Initialized at file scope

Exist even if no instances (objects) of the class exist
Both variables and functions can be static
Can be public, private or protected

static Class Members

static variables
Static variables are accessible through any object
of the class
public static variables
Can also be accessed using scope resolution
operator(::)
Employee::count

private static variables

When no class member objects exist, can only be
accessed via a public static member function
To call a public static member function combine the
class name, the :: operator and the function name
Employee::getCount()

static Class Members

Static functions
static member functions cannot access nonstatic data or functions
There is no this pointer for static
functions, they exist independent of objects

1 // Fig. 7.9: employ1.h

2 // An employee class
3 #ifndef EMPLOY1_H
4 #define EMPLOY1_H
5
6 class Employee {
7 public:
8

Employee( const char*, const char* );

// constructor

~Employee();

// destructor

10

const char *getFirstName() const;

// return first name

11

const char *getLastName() const;

// return last name

12
13

// static member function

14

static int getCount();

// return # objects instantiated

15
16 private:
17

char *firstName;

18

char *lastName;

19
20

// static data member

21

static int count;

22 };
23
24 #endif

// number of objects instantiated

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
51
52
53
54
55
56

// Fig. 7.9: employ1.cpp

// Member function definitions for class Employee
#include <iostream>
using std::cout;
using std::endl;
#include <cstring>
#include <cassert>
#include "employ1.h"

static data member count and

function getCount( )
initialized at file scope (required).

// Initialize the static data member

int Employee::count = 0;
// Define the static member function that
// returns the number of employee objects instantiated.
int Employee::getCount() { return count; }
// Constructor dynamically allocates space for the
// first and last name and uses strcpy to copy
// the first and last names into the object
Employee::Employee( const char *first, const char *last )
{
firstName = new char[ strlen( first ) + 1 ];
assert( firstName != 0 );
// ensure memory allocated
strcpy( firstName, first );
static

data member count changed

when a constructor/destructor called.

lastName = new char[ strlen( last ) + 1 ];

assert( lastName != 0 );
// ensure memory allocated
strcpy( lastName, last );
++count;

// increment static count of employees

57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

cout << "Employee constructor for " << firstName

<< ' ' << lastName << " called." << endl;
}
// Destructor deallocates dynamically allocated memory
Employee::~Employee()
{
cout << "~Employee() called for " << firstName
<< ' ' << lastName << endl;
delete [] firstName; // recapture memory
delete [] lastName;
// recapture memory
--count; // decrement static count of employees
}
// Return first name of employee
const char *Employee::getFirstName() const
{
// Const before return type prevents client from modifying
// private data. Client should copy returned string before
// destructor deletes storage to prevent undefined pointer.
return firstName;
}
// Return last name of employee
const char *Employee::getLastName() const
{
// Const before return type prevents client from modifying
// private data. Client should copy returned string before
// destructor deletes storage to prevent undefined pointer.
return lastName;
}

88 // Fig. 7.9: fig07_09.cpp

89 // Driver to test the employee class
90 #include <iostream>
91
92 using std::cout;
93 using std::endl;
94
95 #include "employ1.h"
96
97 int main()
98 {
99
cout << "Number of employees before instantiation is "
100
<< Employee::getCount() << endl;
// use class name
101
102
Employee *e1Ptr = new Employee( "Susan", "Baker" );
103
Employee *e2Ptr = new Employee( "Robert", "Jones"
);of employees after instantiation is 2
Number
104
105
cout << "Number of employees after instantiation is "
106
<< e1Ptr->getCount();
107
108
cout << "\n\nEmployee 1: "
109
<< e1Ptr->getFirstName()
110
<< " " << e1Ptr->getLastName()
111
<< "\nEmployee 2: "
112
<< e2Ptr->getFirstName()
113
<< " " << e2Ptr->getLastName() << "\n\n";
114
115
delete e1Ptr;
// recapture memory
116
e1Ptr = 0;
117
delete e2Ptr;
// recapture memory
118
e2Ptr = 0;

119
120
121

cout << "Number of employees after deletion is "

<< Employee::getCount() << endl;

122
123

return 0;

124 }

count back to zero.

Number of employees before instantiation is 0

Employee constructor for Susan Baker called.
Employee constructor for Robert Jones called.
Number of employees after instantiation is 2
Employee 1: Susan Baker
Employee 2: Robert Jones
~Employee() called for Susan Baker
~Employee() called for Robert Jones
Number of employees after deletion is 0

Example: Array Abstract Data Type

Programmer can make an ADT array
Could include
Subscript range checking
An arbitrary range of subscripts instead of having to
start with 0
Array assignment
Array comparison
Array input/output
Arrays that know their sizes
Arrays that expand dynamically to accommodate more
elements

Example: String Abstract Data Type

Strings in C++
C++ does not provide a built in string data type
Maximizes performance

Provides mechanisms for creating and

implementing a string abstract data type
string class available in ANSI/ISO standard

Container Classes and Iterators

Container classes (collection classes)
Classes designed to hold collections of objects
Provide services such as insertion, deletion, searching, sorting, or
testing an item
Examples:
Arrays, stacks, queues, trees and linked lists

Iterator objects (iterators)

Object that returns the next item of a collection (or performs
some action on the next item)
Can have several iterators per container
Book with multiple bookmarks

Each iterator maintains its own position information

Proxy Classes
Proxy class
Used to hide implementation details of a class
Class that knows only the public interface of the class
being hidden
Enables clients to use classs services without giving access
to classs implementation

Forward class declaration

Used when class definition only uses a pointer to another
class
Prevents the need for including the header file
Declares a class before it is referenced
Format:
class ClassToLoad;

1 // Fig. 7.10: implementation.h

2 // Header file for class Implementation
3
4 class Implementation {
5

public:

Implementation( int v ) { value = v; }

void setValue( int v ) { value = v; }

int getValue() const { return value; }

9
10
11

private:

Forward class declaration.

int value;

12 };
13 // Fig. 7.10: interface.h
14 // Header file for interface.cpp
15 class Implementation;

// forward class declaration

16
17 class Interface {
18

public:

19

Interface( int );

20

void setValue( int );

// same public interface as

21

int getValue() const;

// class Implementation

22

~Interface();

23
24
25
26 };

private:
Implementation *ptr;

// requires previous
// forward declaration

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
54
55
56
57
58
59
60

// Fig. 7.10: interface.cpp

// Definition of class Interface
#include "interface.h"
#include "implementation.h"
Interface::Interface( int v )
: ptr ( new Implementation( v ) ) { }
// call Implementation's setValue function
void Interface::setValue( int v ) { ptr->setValue( v ); }
// call Implementation's getValue function
int Interface::getValue() const { return ptr->getValue(); }
Interface::~Interface() { delete ptr; }
// Fig. 7.10: fig07_10.cpp
// Hiding a classs private data with a proxy class.
#include <iostream>
using std::cout;
using std::endl;
#include "interface.h"
int main()
{
Interface i( 5 );
cout << "Interface contains: " << i.getValue()
<< " before setValue" << endl;
i.setValue( 10 );
cout << "Interface contains: " << i.getValue()
<< " after setValue" << endl;
return 0;

Interface contains: 5 before setVal

Interface contains: 10 after setVal

Program Output