Introduction to Classes

(CS 217)

Dr. Muhammad Aleem,

Department of Computer Science,

National University of Computer & Emerging Sciences,
Islamabad Campus
Why Objects?
But binary is hard (for humans) to work with…
Procedural VS. Object-Oriented Programming
 Object-oriented Programming (OOP)
• Object-oriented programming approach organizes
programs in a way that mirrors the real world, in
which all objects are associated with both attributes
and behaviors

• Object-oriented programming involves thinking in

terms of objects

• An OOP program can be viewed as a collection of

cooperating objects
Classes
 Classes in OOP
 Classes are constructs/templates that define
objects of the same type.

 A class uses Variables (data fields) to define state

 A class uses Functions to define behaviors.

 Additionally, a class provides a special type of

function, known as constructors:
 Invoked to construct objects from the class.
 Objects in OOP
 An object has a unique identity, state, and behaviors.

 The state of an object consists of a set of data fields

(also known as properties) with their current values.

 The behavior of an object is defined by a set of

functions.
 UML Diagram for Class and Object
Circle Class name

radius: double Data fields

Circle() Constructors and Methods

Circle(newRadius: double)
getArea(): double

circle1: Circle circle2: Circle circle3: Circle

radius: 10 radius: 25 radius: 125

Class in C++ - Example
 Class in C++ - Example
class Circle
{
public:
// The radius of this circle
Note:
double radius; Data field the special syntax
for constructor
// Construct a circle object
Circle() (no return type!)
{
radius = 1;
Constructors
}

// Construct a circle object

Circle(double newRadius)
{
radius = newRadius;
}

// Return the area of this circle

double getArea() Function
{
return radius * radius * 3.14159;
}
};
 Class is a Type
• You can use primitive data types to define
variables.

• You can also use class names to declare object

names.

• In this sense, a class is an abstract data-type or

user-defined data type.
Class Data Members and Member Functions

• The data items within a class are

called data members or data fields
or instance variables

• Member functions are functions that

are included within a class. Also
known as instance functions.
 Object Creation - Instantiation
• In C++, you can assign a name when creating an object.

• A constructor is invoked when an object is created.

• The syntax to create an object using the no-arg

constructor is:

ClassName objectName;

• Defining objects in this way means creating them. This is

also called instantiating them.
 Object Member Access Operator
• After object creation, its data and functions can be
accessed (invoked) using:
– The . operator, also known as the object member
access operator.

• objectName.dataField references a data field in the

object

• objectName.function( ) invokes a function on the object

 A Simple Program – Object Creation
class Circle
{ C1 Object Instance
private:
double radius;
public: : C1
Circle()
{ radius = 5.0; } radius: 5.0
double getArea( )
{ return radius * radius * 3.14159; }
Allocate memory
}; for radius

void main()
{
Circle C1;
//C1.radius = 10; can’t access private member outside the class
cout<<“Area of circle = “<<C1.getArea( );
}
 Local Classes
• Local classes: A local class is declared within a
function definition.

• A local class cannot have static data members.

 Inline/Out-of-Line Member Functions
• Inline functions:
– are defined within the body of the class definition.

• Out-of-line functions:
– are declared within the body of the class definition
and defined outside.
 Inline/Out-of-Line Member Functions
• If a member function is defined outside the class
– Scope resolution operator (::) and class name are needed
– Defining a function outside a class does not change it being
public or private

• Binary scope resolution operator (::)

– Combines the class name with the member function name
– Different classes can have member functions with the same
name

returnType ClassName::MemberFunctionName( ){
…
}
 Member Functions
Separating Declaration from Implementation
class Circle
{
private: Class must define a
double radius; no-argument
public: constructor too….
Circle(double radius)
{ this->radius = radius; }
double getArea( ); // Not implemented yet
};
double Circle::getArea()
{ return this->radius * radius * 3.14159; }
void main()
{
Circle C1(99.0);
cout<<“Area of circle = “<<C1.getArea();
}
 1 // Fig. 6.3: fig06_03.cpp
2 // Time class.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 // Time abstract data type (ADT) definition
9 class Time {
10 public:
11 Time(); // constructor
12 void setTime( int, int, int ); // set hour, minute, second
13 void printMilitary(); // print military time format
14 void printStandard(); // print standard time format
15 private:
16 int hour; // 0 – 23
17 int minute; // 0 – 59
18 int second; // 0 – 59
19 };
20 Note the :: preceding
21 // Time constructor initializes each data member to zero. the function names.
22 // Ensures all Time objects start in a consistent state.
23 Time::Time() { hour = minute = second = 0; }
24
25 // Set a new Time value using military time. Perform validity
26 // checks on the data values. Set invalid values to zero.
27 void Time::setTime( int h, int m, int s )
28 {
29 hour = ( h >= 0 && h < 24 ) ? h : 0;
30 minute = ( m >= 0 && m < 60 ) ? m : 0;
31 second = ( s >= 0 && s < 60 ) ? s : 0;
32 }
33
34 // Print Time in military format
35 void Time::printMilitary()
36 {
37 cout << ( hour < 10 ? "0" : "" ) << hour << ":"
38 << ( minute < 10 ? "0" : "" ) << minute;
39 }
40
41 // Print Time in standard format
42 void Time::printStandard()
43 {
44 cout << ( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 )
45 << ":" << ( minute < 10 ? "0" : "" ) << minute
46 << ":" << ( second < 10 ? "0" : "" ) << second
47 << ( hour < 12 ? " AM" : " PM" );
48 }
49
 Private Member Functions
• Private Member Functions:
– Only accessible (callable) from member functions of
the class

– No direct access possible (with object instance of the

class)

– Can be: inline / out-of-line

Private Member
Functions
(out-of-line)
 Access Modifiers/Specifier
• Access modifiers are used to set access levels for
variables, methods, and constructors
• private, public, and protected
• In C++, default accessibility is private
• The default constructor (provided by compiler) is always public.
Member Access Specifiers
• Programmer can specify a constructor to be private (no use) or public
• public
– Presents clients with a view of the services the class
provides (i.e., interface)
– Data and member functions are accessible (outside class)

• private
– Default access mode
– Data only accessible to member functions and friends
– private members only accessible through the public
class interface using public member functions
 Data Hiding - Data Field Encapsulation
• A key feature of OOP is data hiding
– data is concealed within a class so that it cannot be
accessed mistakenly by functions outside the class.

• To prevent direct modification of class attributes

(outside the class), the primary mechanism for hiding
data is to put it in a class and make it private using
private keyword. This is also known as data field
encapsulation.
 Hidden from Whom?
• Data hiding means hiding data from parts of the
program that don’t need to access it. More
specifically, one class’s data is hidden from other
classes.

• Data hiding is designed to protect well-intentioned

programmers from mistakes.
 A Simple Program – Accessing Member Function
class Circle
{ C1 Object Instance
private:
double radius;
public: : C1
Circle()
{ radius = 5.0; } radius: 5.0
double getArea()
{ return radius * radius * 3.14159; }
Allocate memory
}; for radius

void main()
{
Circle C1;
//C1.radius = 10; can’t access private member outside the class
cout<<“Area of circle = “<<C1.getArea();
}
 A Simple Program – Default Constructor
class Circle
{ C1 Object Instance
private:
double radius;
public:
//Default Constructor : C1
Circle()
//
{ No Constructor
} Here
radius: Any Value
double getArea()
{ return radius * radius * 3.14159; }
};
Allocate memory
for radius

void main()
{
Circle C1;
//C1.radius = 10; can’t access private member outside the class
cout<<“Area of circle = “<<C1.getArea();
}
 Object Construction with Arguments
 The syntax to declare an object using a constructor with
arguments is:

ClassName objectName(arguments);

 For example, the following declaration creates an object

named circle1 by invoking the Circle class’s constructor
with a specified radius 5.5.

Circle circle1(5.5);
 A Simple Program – Constructor with Arguments
class Circle
{ C1 Object Instance
private:
double radius;
public:
Circle( ) {} : C1
Circle(double rad)
{ radius = rad; } radius: 9.0
double getArea()
{ return radius * radius * 3.14159; }
}; Allocate memory
for radius

void main()
{
Circle C1(9.0);
//C1.radius = 10; can’t access private member outside the class
cout<<“Area of circle = “<<C1.getArea();
}
 Output of the following Program?
class Circle
{
private:
double radius;
public:
Circle( ) { }

Circle(double rad)
{ radius = rad; }
double getArea()
{ return radius * radius * 3.14159; }
};

void main()
{
Circle C1;
cout<<“Area of circle = “<<C1.getArea();
}
 const Member Functions
• const Member Functions: Read-only functions cannot
modify object’s data members
 Constant Functions
class Circle
{
private:
double radius;
public:
Circle ()
{ radius = 1; }
Circle(double rad)
{ radius = rad; } const member
double getArea() const function cannot
{ return radius * radius * 3.14159; }
update/change
};
object’s data
void main()
{
Circle C2(8.0);
Circle C1;
cout<<“Area of circle = “<<C1.getArea();
}
 Accessors and Mutators(Getters & Setters)
• Accessors: member function only reads/gets value
from a class’s member variable but does not change it.
• Mutators: member function that stores a value in
member variable
 const Objects
• const Object: Read-only objects

– Object data members can only be read, NO

write/update of data member allowed

– Requires all member functions be const (except

constructors and destructors)

– const object must be initialized (using constructors) at the

time of object creation
 const Objects
• const property of an object goes into
effect after the constructor finishes executing and
ends before the class's destructor executes
– So the constructor and destructor can modify
the object
 Pointers to Objects
• You can also define pointers to class objects

• You can use * and . operators OR -> to access members:

 Pointers to Objects
• Dynamic Object Creation
 Reference to Objects
• Reference is an alias to an existing object
Reference to Objects
Reference and Pointers to Objects
Constructors and Destructors
 Interface vs Implementation
• Separating interface from implementation
– Makes it easier to modify programs

– Header files
• Contains class definitions and function prototypes

– Source-code files
• Contains member function definitions
1 // Fig. 6.5: time1.h
2 // Declaration of the Time class.
3 // Member functions are defined in time1.cpp
4
5 // prevent multiple inclusions of header file Dot ( . ) replaced with underscore ( _ ) in file name.
6 #ifndef TIME1_H
7 #define TIME1_H
If time1.h (TIME1_H) is not defined (#ifndef)
8 then it is loaded (#define TIME1_H). If TIME1_H
9 // Time abstract data type definition is already defined, then everything up to #endif is
ignored.
10 class Time { This prevents loading a header file multiple times.
11 public:
12 Time(); // constructor
13 void setTime( int, int, int ); // set hour, minute, second
14 void printMilitary(); // print military time format
15 void printStandard(); // print standard time format
16 private:
17 int hour; // 0 - 23
18 int minute; // 0 - 59
19 int second; // 0 - 59
20 };
21
22 #endif
23 // Fig. 6.5: time1.cpp
24 // Member function definitions for Time class.
25 #include <iostream>
26
27 using std::cout;
28 Source file uses #include to load the
29 #include "time1.h" header file
30
31 // Time constructor initializes each data member to zero.
32 // Ensures all Time objects start in a consistent state.
33 Time::Time() { hour = minute = second = 0; }
34
35 // Set a new Time value using military time. Perform validity
36 // checks on the data values. Set invalid values to zero.
37 void Time::setTime( int h, int m, int s )
38 {
39 hour = ( h >= 0 && h < 24 ) ? h : 0;
40 minute = ( m >= 0 && m < 60 ) ? m : 0;
41 second = ( s >= 0 && s < 60 ) ? s : 0; Source file contains
42 } function definitions
43
44 // Print Time in military format
45 void Time::printMilitary()
46 {
47 cout << ( hour < 10 ? "0" : "" ) << hour << ":"
48 << ( minute < 10 ? "0" : "" ) << minute;
49 }
50
51 // Print time in standard format
52 void Time::printStandard()
53 {
54 cout << ( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 )
55 << ":" << ( minute < 10 ? "0" : "" ) << minute
56 << ":" << ( second < 10 ? "0" : "" ) << second
57 << ( hour < 12 ? " AM" : " PM" );
58 }
 Constructors
 A constructor is a special function used to create an object.
Constructor has exactly the same name as the defining class

 Constructors can be overloaded (i.e., multiple constructors

with different signatures) [Purpose: making it easy to
construct objects with different initial data values).

 A class may be declared without constructors. In this case, a

no-argument constructor with an empty body is implicitly
declared in the class known as default constructor

 Note: Default constructor is provided automatically only if no

constructors are explicitly declared in the class.
 Constructors’ Properties

 must have the same name as the class itself.

 do not have a return type—not even void.

 play the role of initializing objects.

 Constructors and Destructors
– Constructor is a function in every class which is
called when class creates its object
• Basically it helps in initializing data members of the
class
• A class may have multiple constructors

– Destructors is a function in every class which is

called when the object of a class is destroyed
• The main purpose of destructor is to remove
dynamic memories etc.
Initializing Objects Notice that default settings for the three
member variables are set in constructor
prototype. No names are needed; the
10 // Time abstract data type definition defaults are applied in the order the
11 class Time { variables are declared.
12 public:
13 Time( int = 0, int = 0, int = 0 ); // default constructor
14 void setTime( int, int, int ); // set hour, minute, second
15 void printMilitary(); // print military time format
16 void printStandard(); // print standard time format
17 private:
18 int hour; // 0 - 23
19 int minute; // 0 - 59
20 int second; // 0 - 59
21 };
22
23 #endif

Default Parameters in Constructor

70 Same constructor, used in overloaded style
71 int main()
72 {
73 Time t1, // all arguments defaulted
74 t2(2), // minute and second defaulted
75 t3(21, 34), // second defaulted
76 t4(12, 25, 42), // all values specified
77 t5(27, 74, 99); // all bad values specified
78
79 cout << "Constructed with:\n"
80 << "all arguments defaulted:\n ";
81 t1.printMilitary();
82 cout << "\n ";
83 t1.printStandard();
84
85 cout << "\nhour specified; minute and second defaulted:"
86 << "\n ";
87 t2.printMilitary();
88 cout << "\n ";
89 t2.printStandard();
90
91 cout << "\nhour and minute specified; second defaulted:"
92 << "\n ";
93 t3.printMilitary();
94 cout << "\n ";
95 t3.printStandard();
96
97 cout << "\nhour, minute, and second specified:"
98 << "\n ";
99 t4.printMilitary();
100 cout << "\n ";
101 t4.printStandard();
102
103 cout << "\nall invalid values specified:"
104 << "\n ";
105 t5.printMilitary();
106 cout << "\n ";
107 t5.printStandard();
108 cout << endl;
109
110 return 0;
111 }
OUTPUT When only hour is
Constructed with: specified, minute and
all arguments defaulted:
second are set to their
00:00
12:00:00 AM
default values of 0.
hour specified; minute and second defaulted:
02:00
2:00:00 AM
hour and minute specified; second defaulted:
21:34
9:34:00 PM
hour, minute, and second specified:
12:25
12:25:42 PM
all invalid values specified:
00:00
12:00:00 AM
 Using Destructors
• Destructors
– Are member function of class
– Perform termination housekeeping before the system
reclaims the object’s memory
– Name is tilde (~) followed by the class name (i.e.,
~Time)
– Receives no parameters, returns no value
– One destructor per class (no overloading)
– Destructors cannot be declared const, static
– A destructor can be declared virtual or pure virtual
When Constructors and Destructors Are Called
Constructors and destructors called automatically
– Order depends on scope of objects
1. Global scope objects
– Constructors called before any other function (including main)
– Destructors called when main terminates (or exit function
called)
– Destructors not called if program terminates with abort

2. Automatic local objects

– Constructors called when objects are defined
– Destructors called when objects leave scope
– Destructors not called if the program ends with exit or
abort
7 class CreateAndDestroy {
8 public:
9 CreateAndDestroy( int ); // constructor
10 ~CreateAndDestroy(); // destructor
11 private:
12 int data;
13 };
14
15 #endif
24
25 CreateAndDestroy::CreateAndDestroy( int value )
26 { Constructor and Destructor
changed to print when they are
27 data = value; called.
28 cout << "Object " << data << " constructor";
29 }
30
31 CreateAndDestroy::~CreateAndDestroy()
32 { cout << "Object " << data << " destructor " << endl; }
 63
64 // Function to create objects
65 void create( void )
66 {
67 CreateAndDestroy fifth( 5 );
68 cout << " (local automatic in create)" << endl;
69
70 static CreateAndDestroy sixth( 6 );
71 cout << " (local static in create)" << endl;
72
42 73 CreateAndDestroy seventh( 7 );
43 void create( void ); // prototype 74 cout << " (local automatic in create)" << endl;
44 75 }
45 CreateAndDestroy first( 1 ); // global object
46
47 int main()
48 {
49 cout << " (global created before main)" << endl;
50
51 CreateAndDestroy second( 2 ); // local object
52 cout << " (local automatic in main)" << endl;
53
54 static CreateAndDestroy third( 3 ); // local object
55 cout << " (local static in main)" << endl;
56
57 create(); // call function to create objects
58
59 CreateAndDestroy fourth( 4 ); // local object
60 cout << " (local automatic in main)" << endl;
61 return 0;
62 }
OUTPUT
Object 1 constructor (global created before main)
Object 2 constructor (local automatic in main)
Object 3 constructor (local static in main)
Object 5 constructor (local automatic in create)
Object 6 constructor (local static in create)
Object 7 constructor (local automatic in create)
Object 7 destructor Notice how the order of the
Object 5 destructor
constructor and destructor call
Object 4 constructor (local automatic in main)
Object 4 destructor depends on the types of variables
Object 2 destructor (automatic, global and static)
Object 6 destructor they are associated with.
Object 3 destructor
Object 1 destructor
 Destructor Example
void f1()
{
Employee *c = new Employee[3];
c[0].var1 = 322;
c[1].var1 = 5
c[2].var1 = 9;lete [] c; //destructor will
call here
}
 When do Constructors Get Called?
• Class object creation time

• Dynamically allocated object

• Class argument passed by value

• Class object returned by value

• Object Array element (created)

 What Constructors Do
• Help in initializing: class data members
Employee( ) { id = 0; }

• Allocate memory for dynamic members

Employee() { char* nameptr = new char[20];}

• Allocate any needed resources

– Such as to open files, etc.
 Constructing Arrays of Objects
Complex c_arr[10];
Date date_arr[20];

Issue: There is no way to call argument-based

constructors (non-default) for array members
 Arrays of Objects and Non-Default Constructors

• Trick: declare an array of pointer to objects

• Allocate and initialize each object in a loop

Date *dates[31];

for (int day = 0; day < 31; ++day)

{
dates[day] = new Date(3, day, 2020);
}
 Default Member-wise Assignment
• Assignment operator (=) can be used to assign an
object to another object of the same type.

• Member-wise assignment: each data member of the

object on the right of the assignment operator is
assigned individually to the same data member in
the object on the left

 Default copy constructor
A type of constructor that is used to initialize an
object with another object of the same type is
known as default copy constructor.

 It is by default available in all classes

 syntax is ClassName(ClassName &Variable)

 Copy Constructor for Class Date
Date::Date(Date &date)
{
// no need to check passed date arg
month = date.month;
day = date.day;
year = date.year;
}
 Uses of the Copy Constructor
• Implicitly called in 3 situations:
1. defining a new object from an existing object
2. passing an object by value
3. returning an object by value
Copy Constructor: Defining a New Object

Date d1(02,28,2020);

// init 2 local objects from d1

Date d2(d1);// pass by value
Date d3 = d1;// return value

// init a dynamic object from d1

Date* pdate = new Date(d1);
Copy Constructor:Passing Objects by Value

//copy constructor called for each value arg

unsigned dateDiff(Date d1, Date d2);
...
Date today;
Date d3(02, 21, 2000);
cout << dateDiff(d3, today);
User-defined Copy Constructor, when required?
• Default-copy Constructor do only “Shallow Copy”
• We need user-defined copy-constructor,
– When we need “Deep Copy” (for Dynamic Memory)
static, const, and this Pointer
 static Class Members
• static class members
– Shared by all objects of a class
– Efficient, when a single copy of data is enough
• Only the static variable has to be updated
– May seems 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 Variables
• Two-Step Procedure:
1. Declare (Inside Class): static int radius;
2. Define (Outside Class): int Circle::radius=2;

• static Variables
– Default Initialization: 0 or Null (for pointers)
– Initialization: user defined value
– Initialization is made just once, at compile time.
– Accessibility: Private or Public
 Public static Class Variables
– Can be accessed using Class name:
cout<<Employee::count;

– Can be accessed via any class’ object:

cout<<e1.count;

– Can be accessed via Non-Static member functions:

cout<<e1.getCount();

– Can be accessed via Static member functions:

cout<<Employee::Stat_getCount();
cout<<e1.Stat_getCount(); //public static
 Private static Class Variables
– Cannot be accessed using Class name:
// ERROR  cout<<Employee::count;

– Cannot be accessed via class' object:

// ERROR  cout<<e1.count;

– Can be accessed via Non-Static member functions:

cout<<e1.getCount();

– Can be accessed via Static member functions:

cout<<Employee::Stat_getCount();
cout<<e1.Stat_getCount(); //public static
 static Class Functions
• Non-static function:
– Can access: static/non-static data members
and static/non-static methods

• Static functions:
– Can access: static data and static functions
– Cannot access: non-static data, non-static functions,
and this pointer
 Public static Class Functions
–Can be invoked using class’s any object:
cout<<e1.getCount();

–Can be invoked using Class name:

cout<<Employee::getCount();
 Private static Class Functions
–Cannot be invoked using class’s object
//ERROR  cout<<e1.getCount();

–Cannot be invoked using Class name

//ERROR  cout<<Employee::getCount();

–Can be invoked within Class:

• Static member functions
• Non-Static member functions
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
9 ~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:
static member function and
variable declared.
17 char *firstName;
18 char *lastName;
19
20 // static data member
21 static int count; // number of objects instantiated
22 };
23
24 #endif
25 // Fig. 7.9: employ1.cpp
26 // Member function definitions for class Employee
27 #include <iostream>
28
29 using std::cout;
30 using std::endl; static data member count and
31 function getCount( ) initialized at file
32 #include <cstring> scope (required).
33 #include <cassert>
34 #include "employ1.h"
35
36 // Initialize the static data member
37 int Employee::count = 0;
38
39 // Define the static member function that
40 // returns the number of employee objects instantiated.
41 int Employee::getCount() { return count; } Note the use of
42 assert to test for
43 // Constructor dynamically allocates space for the
memory allocation.
44 // first and last name and uses strcpy to copy
45 // the first and last names into the object
46 Employee::Employee( const char *first, const char *last )
47 {
48 firstName = new char[ strlen( first ) + 1 ];
49 assert( firstName != 0 ); // ensure memory allocated
50 strcpy( firstName, first ); static data member
51 count changed when a
52 lastName = new char[ strlen( last ) + 1 ];
53 assert( lastName != 0 ); // ensure memory allocated
constructor/destructor
54 strcpy( lastName, last ); called.
55
56 ++count; // increment static count of employees
57 cout << "Employee constructor for " << firstName
58 << ' ' << lastName << " called." << endl;
59 }
60
61 // Destructor deallocates dynamically allocated memory
62 Employee::~Employee() static data member count
63 { changed when a
64 cout << "~Employee() called for " << firstName constructor/destructor called.
65 << ' ' << lastName << endl;
66 delete [] firstName; // recapture memory
67 delete [] lastName; // recapture memory Count decremented
68 --count; // decrement static count of employees because of
69 } destructor calls from
70 delete.
71 // Return first name of employee
72 const char *Employee::getFirstName() const
73 {
74 // Const before return type prevents client from modifying
75 // private data. Client should copy returned string before
76 // destructor deletes storage to prevent undefined pointer.
77 return firstName;
78 }
79
80 // Return last name of employee
81 const char *Employee::getLastName() const
82 {
83 // Const before return type prevents client from modifying
84 // private data. Client should copy returned string before
85 // destructor deletes storage to prevent undefined pointer.
86 return lastName;
87 }
88 // Fig. 7.9: fig07_09.cpp
89 // Driver to test the employee class
90 #include <iostream> If no Employee objects exist
91 count incremented because of getCount must be accessed
92 using std::cout; constructor calls from new. using the class name and (::).
93 using std::endl;
94
95 #include "employ1.h"
96 Number of employees before instantiation is 0
97 int main()
98 {
99 cout << "Number of employees before instantiation is "
100 << Employee::getCount() << endl; // e2Ptr->getCount()
use class name or Employee::getCount() would
101 also work.
102 Employee *e1Ptr = new Employee( "Susan", "Baker" );
103 Employee *e2Ptr = new Employee( "Robert", "Jones" );
104 Number of employees after instantiation is 2
105 cout << "Number of employees after instantiation is "
106 << e1Ptr->getCount();
107 Employee constructor for Susan Baker called.
108 cout << "\n\nEmployee 1: " Employee constructor for Robert Jones called.
109 << e1Ptr->getFirstName()
110 << " " << e1Ptr->getLastName() Employee 1: Susan Baker
111 << "\nEmployee 2: " Employee 2: Robert Jones
112 << e2Ptr->getFirstName()
113 << " " << e2Ptr->getLastName() << "\n\n";
114
115 delete e1Ptr; // recapture memory ~Employee() called for Susan Baker
116 e1Ptr = 0; ~Employee() called for Robert Jones
117 delete e2Ptr; // recapture memory
118 e2Ptr = 0;
119

120 cout << "Number of employees after deletion is "

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

122

123 return 0;
count back to zero.
124 }

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
 const Class Members
• As with member functions, data members can also
be const

• Member Initializer List:

– Can be used to initialize both const and non-const
data members
– consts and references must be initialized using
member initializer
Member Initializer List (Non-const Members)
Member Initializer List (non-static const)
Member Initializer List (References)
Member Initializer List (member object, no default constructor)
 Member Initializer List
(parameter name same as data member)
 Member Initializer List
(base class members)

Will be discussed in chapters

after midterm
 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
 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; (Has no effect)
 1 // Fig. 7.7: fig07_07.cpp
2 // Using the this pointer to refer to object members.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 class Test {
9 public:
10 Test( int = 0 ); // default constructor
11 void print() const;
12 private:
13 int x; Printing x directly.
14 };
15
16 Test::Test( int a ) { x = a; } // constructor
17
18 void Test::print() const // ( ) around *this required Print x using the arrow ->
19 { operator off the this pointer.
20 cout << " x = " << x
21 << "\n this->x = " << this->x
22 << "\n(*this).x = " << ( *this ).x << endl;
23 }
24
25 int main()
26 {
27 Test testObject( 12 );
28 Printing x using the dot (.) operator. Parenthesis
29 testObject.print(); required because dot operator has higher
30 precedence than *. Without, interpreted
31 return 0; incorrectly as *(this.x).
32 }
 x = 12
this->x = 12
(*this).x = 12

All three methods

have the same result.
 1 // Fig. 7.8: time6.h
2 // Cascading member function calls.
3
4 // Declaration of class Time.
5 // Member functions defined in time6.cpp
6 #ifndef TIME6_H
7 #define TIME6_H
8
9 class Time {
10 public:
11 Time( int = 0, int = 0, int = 0 ); // default constructor
12
13 // set functions
14 Time &setTime( int, int, int ); // set hour, minute, second
15 Time &setHour( int ); // set hour
16 Time &setMinute( int ); // set minute
17 Time &setSecond( int ); // set second Noticethe Time & - function
18
returns a reference to a Time
19 // get functions (normally declared const)
20 int getHour() const; // return hour object.
21 int getMinute() const; // return minute Specify object in function definition.
22 int getSecond() const; // return second
23
24 // print functions (normally declared const)
25 void printMilitary() const; // print military time
26 void printStandard() const; // print standard time
27 private:
28 int hour; // 0 - 23
29 int minute; // 0 - 59
30 int second; // 0 - 59
31 };
32
33 #endif
34 // Fig. 7.8: time.cpp
35 // Member function definitions for Time class.
36 #include <iostream>
37
38 using std::cout;
39
40 #include "time6.h"
41
42 // Constructor function to initialize private data.
43 // Calls member function setTime to set variables.
44 // Default values are 0 (see class definition).
45 Time::Time( int hr, int min, int sec )
46 { setTime( hr, min, sec ); }
47
48 // Set the values of hour, minute, and second.
49 Time &Time::setTime( int h, int m, int s )
Returning *this enables
50 { cascading function calls
51 setHour( h );
52 setMinute( m );
53 setSecond( s );
54 return *this; // enables cascading
55 }
56
57 // Set the hour value
58 Time &Time::setHour( int h )
59 {
60 hour = ( h >= 0 && h < 24 ) ? h : 0;
61
62 return *this; // enables cascading
63 }
64
65 // Set the minute value
66 Time &Time::setMinute( int m )
67 {
68 minute = ( m >= 0 && m < 60 ) ? m : 0;
69
70 return *this; // enables cascading
71 }
72
73 // Set the second value
Returning *this enables
74 Time &Time::setSecond( int s )
cascading function calls
75 {
76 second = ( s >= 0 && s < 60 ) ? s : 0;
77
78 return *this; // enables cascading
79 }
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 cout << ( hour < 10 ? "0" : "" ) << hour << ":"
94 << ( minute < 10 ? "0" : "" ) << minute;
95 }
96
97 // Display standard format time: HH:MM:SS AM (or PM) printStandard does not
98 void Time::printStandard() const return a reference to an object.
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> Notice cascading function calls.
109
110 using std::cout;
111 using std::endl;
112
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: "; Cascading function calls. printStandard must be called
121 t.printMilitary(); after setTime because printStandard does not return a
122 cout << "\nStandard time: "; reference to an object.
123 t.printStandard(); t.printStandard().setTime(); would cause an
124 error.
125 cout << "\n\nNew standard time: ";
126 t.setTime( 20, 20, 20 ).printStandard();
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

 What is the Singleton Pattern?
• Software design pattern is a general, reusable
solution to a commonly occurring problem within
a given context in software design.

• The Singleton pattern ensures that a class is only

instantiated once and provides a global access
point for this instance
 Why use the Singleton Pattern?
• It is important for some classes to only have one
instance

• It is also important that this single instance is

easily accessible

• Why not use a global object?

– Global variables make objects accessible, but they
don't prevent the instantiation of multiple objects.
 Solution
• Make the class responsible for keeping track of its
only instance:
– The class can ensure that no other instances are
created
– This is the Singleton pattern
 Examples of Singleton Patterns

• HR Manager
• Head of Department
• Print spooler
• Window Managers
• Digital Filters
• Accounting Systems
• …
 Design Solution
• Defines a getInstance( ) operation that lets clients
access its unique instance
• Responsible for creating its own unique instance

Singleton

-static uniqueinstance
Singleton data
… -Singleton()
return uniqueinstance; +static getInstance()
Singleton methods…
 Implementation
• Declare all of class’s constructors private
– prevent other classes from directly creating an
instance of this class

• Hide the operation that creates the instance

behind a class operation (getInstance)

• Variation: Since creation policy is encapsulated in

getInstance, it is possible to vary the creation
policy
 Singleton Example (C++)
class Database
{
private:
static Database *DB;
...
//private constructor
In application code…
Database() { ... }
Database *db = Database.getDB();
public:
db->someMethod();
//static method
static Database *getDB()
{
if (DB == NULL)
DB = new Database());

return DB;
}
...
};
Database* Database::DB=NULL;
 Singleton Consequences
• Ensures only one (e.g., Database) instance exists in the
system

• Can maintain a pointer (need to create object on first get

call) or an actual object

• Can also use this pattern to control fixed multiple

instances

• Much better than the alternative: global variables