1 of 50

Classes and Objects

By Santosh Tawde

2 of 50

Introduction

Object-oriented programming (OOP)

Encapsulation: encapsulates data (attributes) and functions (behavior) into packages called classes
Information hiding : implementation details are hidden within the classes themselves

Classes

Classes are the standard unit of programming
A class is like a blueprint – reusable
Objects are instantiated (created) from the class
For example, a house is an instance of a “blueprint class”

3 of 50

Structure Definitions

Structures

Aggregate data types built using elements of other types�

struct Time {

int hour;

int minute;

int second;

};

Members of the same structure must have unique names
Two different structures may contain members of the same name
Each structure definition must end with a semicolon

Structure tag

Structure members

4 of 50

Structure Definitions

Self-referential structure

Contains a member that is a pointer to the same structure type
Used for linked lists, queues, stacks and trees

struct

Creates a new data type that is used to declare variables
Structure variables are declared like variables of other types
Example:

Time timeObject, timeArray[ 10 ], � *timePtr, &timeRef = timeObject;

5 of 50

Accessing Members of Structures

Member access operators:

Dot operator (.) for structures and objects
Arrow operator (->) for pointers
Print member hour of timeObject:

cout << timeObject.hour;

OR

timePtr = &timeObject;� cout << timePtr->hour;

timePtr->hour is the same as ( *timePtr ).hour
Parentheses required: * has lower precedence than .

6 of 50

1 // Fig. 6.1: fig06_01.cpp

2 // Create a structure, set its members, and print it.

3 #include <iostream>

4

5 using std::cout;

6 using std::endl;

7

8 struct Time { // structure definition

9 int hour; // 0-23

10 int minute; // 0-59

11 int second; // 0-59

12 };

13

14 void printMilitary( const Time & ); // prototype

15 void printStandard( const Time & ); // prototype

16

17 int main()

18 {

19 Time dinnerTime; // variable of new type Time

20

21 // set members to valid values

22 dinnerTime.hour = 18;

23 dinnerTime.minute = 30;

24 dinnerTime.second = 0;

25

26 cout << "Dinner will be held at ";

27 printMilitary( dinnerTime );

28 cout << " military time,\nwhich is ";

29 printStandard( dinnerTime );

30 cout << " standard time.\n";

31

Dinner will be held at 18:30 military time,

which is 6:30:00 PM standard time.

7 of 50

32 // set members to invalid values

33 dinnerTime.hour = 29;

34 dinnerTime.minute = 73;

35

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

37 printMilitary( dinnerTime );

38 cout << endl;

39 return 0;

40 }

41

42 // Print the time in military format

43 void printMilitary( const Time &t )

44 {

45 cout << ( t.hour < 10 ? "0" : "" ) << t.hour << ":"

46 << ( t.minute < 10 ? "0" : "" ) << t.minute;

47 }

48

49 // Print the time in standard format

50 void printStandard( const Time &t )

51 {

52 cout << ( ( t.hour == 0 || t.hour == 12 ) ?

53 12 : t.hour % 12 )

54 << ":" << ( t.minute < 10 ? "0" : "" ) << t.minute

55 << ":" << ( t.second < 10 ? "0" : "" ) << t.second

56 << ( t.hour < 12 ? " AM" : " PM" );

57 }

Time with invalid values: 29:73

8 of 50

Program Output

Dinner will be held at 18:30 military time,

which is 6:30:00 PM standard time.

Time with invalid values: 29:73

9 of 50

Implementing a Time Abstract Data Type with a Class

Classes

Model objects that have attributes (data members) and behaviors (member functions)
Defined using keyword class
Have a body delineated with braces ({ and })
Class definitions terminate with a semicolon
Example:

10 of 50

1 class Time {

2 public:

3 Time();

4 void setTime( int, int, int );

5 void printMilitary();

6 void printStandard();

7 private:

8 int hour; // 0 - 23

9 int minute; // 0 - 59

10 int second; // 0 - 59

11 };

Public: and Private: are member-access specifiers.

setTime, printMilitary, and printStandard are member functions.�Time is the constructor.

hour, minute, and second are data members.

11 of 50

Implementing a Time Abstract Data Type with a Class

Member access specifiers

Classes can limit the access to their member functions and data
The three types of access a class can grant are:

Public — Accessible wherever the program has access to an object of the class
private — Accessible only to member functions of the class
Protected — Similar to private and discussed later

Constructor

Special member function that initializes the data members of a class object
Cannot return values
Have the same name as the class

12 of 50

Objects

Class definition and declaration

Once a class has been defined, it can be used as a type in object, array and pointer declarations
Example:

Time sunset, // object of type Time� arrayOfTimes[ 5 ], // array of Time objects� *pointerToTime, // pointer to a Time object� &dinnerTime = sunset; // reference to a Time object

Note: The class name becomes the new type specifier.

13 of 50

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

21 // Time constructor initializes each data member to zero.

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 }

Note the :: preceding the function names.

14 of 50

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

50 // Driver to test simple class Time

51 int main()

52 {

53 Time t; // instantiate object t of class Time

54

55 cout << "The initial military time is ";

56 t.printMilitary();

57 cout << "\nThe initial standard time is ";

58 t.printStandard();

59

15 of 50

60 t.setTime( 13, 27, 6 );

61 cout << "\n\nMilitary time after setTime is ";

62 t.printMilitary();

63 cout << "\nStandard time after setTime is ";

64 t.printStandard();

65

66 t.setTime( 99, 99, 99 ); // attempt invalid settings

67 cout << "\n\nAfter attempting invalid settings:"

68 << "\nMilitary time: ";

69 t.printMilitary();

70 cout << "\nStandard time: ";

71 t.printStandard();

72 cout << endl;

73 return 0;

74 }

The initial military time is 00:00

The initial standard time is 12:00:00 AM

Military time after setTime is 13:27

Standard time after setTime is 1:27:06 PM

After attempting invalid settings:

Military time: 00:00

Standard time: 12:00:00 AM

16 of 50

Implementing a Time ADT with a Class

Destructors

Functions with the same name as the class but preceded with a tilde character (~)
Cannot take arguments and cannot be overloaded
Performs “termination housekeeping”

Binary scope resolution operator (::)

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

Format for defining member functions

ReturnType ClassName::MemberFunctionName( ){

…

}

17 of 50

Implementing a Time ADT with a Class

If a member function is defined inside the class

Scope resolution operator and class name are not needed
Defining a function outside a class does not change it being public or private

Classes encourage software reuse

Inheritance allows new classes to be derived from old ones

18 of 50

Class Scope and Accessing Class Members

Class scope

Data members and member functions

File scope

Nonmember functions

Inside a scope

Members accessible by all member functions

Referenced by name

Outside a scope

Members are referenced through handles

An object name, a reference to an object or a pointer to an object

19 of 50

Class Scope and Accessing Class Members

Function scope

Variables only known to function they are defined in
Variables are destroyed after function completion

Accessing class members

Same as structs
Dot (.) for objects and arrow (->) for pointers
Example:

t.hour is the hour element of t
TimePtr->hour is the hour element

20 of 50

1 // Fig. 6.4: fig06_04.cpp

2 // Demonstrating the class member access operators . and ->

3 //

4 // CAUTION: IN FUTURE EXAMPLES WE AVOID PUBLIC DATA!

5 #include <iostream>

6

7 using std::cout;

8 using std::endl;

9

10 // Simple class Count

11 class Count {

12 public:

13 int x;

14 void print() { cout << x << endl; }

15 };

16

17 int main()

18 {

19 Count counter, // create counter object

20 *counterPtr = &counter, // pointer to counter

21 &counterRef = counter; // reference to counter

22

23 cout << "Assign 7 to x and print using the object's name: ";

24 counter.x = 7; // assign 7 to data member x

25 counter.print(); // call member function print

26

27 cout << "Assign 8 to x and print using a reference: ";

28 counterRef.x = 8; // assign 8 to data member x

29 counterRef.print(); // call member function print

30

21 of 50

31 cout << "Assign 10 to x and print using a pointer: ";

32 counterPtr->x = 10; // assign 10 to data member x

33 counterPtr->print(); // call member function print

34 return 0;

35 }

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

Assign 8 to x and print using a reference: 8

Assign 10 to x and print using a pointer: 10

22 of 50

Separating Interface from 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

23 of 50

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

6 #ifndef TIME1_H

7 #define TIME1_H

8

9 // Time abstract data type definition

10 class Time {

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

24 of 50

23 // Fig. 6.5: time1.cpp

24 // Member function definitions for Time class.

25 #include <iostream>

26

27 using std::cout;

28

29 #include "time1.h"

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;

42 }

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 }

Source file uses #include to load the header file

Source file contains function definitions

25 of 50

Controlling Access to Members

public

Presents clients with a view of the services the class provides (interface)
Data and member functions are accessible

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

26 of 50

1 // Fig. 6.6: fig06_06.cpp

2 // Demonstrate errors resulting from attempts

3 // to access private class members.

4 #include <iostream>

5

6 using std::cout;

7

8 #include "time1.h"

9

10 int main()

11 {

12 Time t;

13

14 // Error: 'Time::hour' is not accessible

15 t.hour = 7;

16

17 // Error: 'Time::minute' is not accessible

18 cout << "minute = " << t.minute;

19

20 return 0;

21 }

Compiling...

Fig06_06.cpp

D:\Fig06_06.cpp(15) : error C2248: 'hour' : cannot access private

member declared in class 'Time'

D:\Fig6_06\time1.h(18) : see declaration of 'hour'

D:\Fig06_06.cpp(18) : error C2248: 'minute' : cannot access private

member declared in class 'Time'

D:\time1.h(19) : see declaration of 'minute'

Error executing cl.exe.

test.exe - 2 error(s), 0 warning(s)

Attempt to access private member variable minute.

Attempt to modify private member variable hour.

27 of 50

Access Functions and Utility Functions

Utility functions

private functions that support the operation of public functions
Not intended to be used directly by clients

Access functions

public functions that read/display data or check conditions
Allow public functions to check private data

Following example

Program to take in monthly sales and output the total
Implementation not shown, only access functions

28 of 50

87 // Fig. 6.7: fig06_07.cpp

88 // Demonstrating a utility function

89 // Compile with salesp.cpp

90 #include "salesp.h"

91

92 int main()

93 {

94 SalesPerson s; // create SalesPerson object s

95

96 s.getSalesFromUser(); // note simple sequential code

97 s.printAnnualSales(); // no control structures in main

98 return 0;

99 }

OUTPUT

Enter sales amount for month 1: 5314.76

Enter sales amount for month 2: 4292.38

Enter sales amount for month 3: 4589.83

Enter sales amount for month 4: 5534.03

Enter sales amount for month 5: 4376.34

Enter sales amount for month 6: 5698.45

Enter sales amount for month 7: 4439.22

Enter sales amount for month 8: 5893.57

Enter sales amount for month 9: 4909.67

Enter sales amount for month 10: 5123.45

Enter sales amount for month 11: 4024.97

Enter sales amount for month 12: 5923.92

The total annual sales are: $60120.59

Create object s, an instance of class SalesPerson

29 of 50

Class definition

class class_name {

public:

constructor and destructor

member functions

private:

data members

};

30 of 50

Initializing Class Objects: Constructors

Constructors

Initialize class members
Same name as the class
No return type
Member variables can be initialized by the constructor or set afterwards

Passing arguments to a constructor

When an object of a class is declared, initializers can be provided
Format of declaration with initializers:

Class-type ObjectName( value1,value2,…);

Default arguments may also be specified in the constructor prototype

31 of 50

1 // Fig. 6.8: time2.h

2 // Declaration of the Time class.

3 // Member functions are defined in time2.cpp

4

5 // preprocessor directives that

6 // prevent multiple inclusions of header file

7 #ifndef TIME2_H

8 #define TIME2_H

9

10 // Time abstract data type definition

11 class Time {

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

32 of 50

61 // Fig. 6.8: fig06_08.cpp

62 // Demonstrating a default constructor

63 // function for class Time.

64 #include <iostream>

65

66 using std::cout;

67 using std::endl;

68

69 #include "time2.h"

70

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();

33 of 50

OUTPUT

Constructed with:

all arguments defaulted: