1. C++ Classes and Data Structures Jeffrey S. Childs
Chapter 1
Structs and Classes
Jeffrey S. Childs
Clarion University of PA
© 2008, Prentice Hall

2. Structs A struct holds data, like an array
Each unit of data in a struct is called a data member (or member)
they are called “elements” in arrays
In a struct, each data member can have a different data type
in arrays, the data type of each element is the same

3. Example Using a Struct 1 #include <iostream>
2 #include <iomanip>
3 #include <string> 4
5 using namespace std; 6
7 struct CarType {
8 string maker;
9 int year;
10 float price;
11 }; 12
13 void getYourCar( CarType & car ); 14
Don’t forget this semicolon.

4. Example Using a Struct (cont.)
15 int main( )
16 {
CarType myCar, yourCar; 18
myCar.maker = "Mercedes"; // I wish
myCar.year = 2005;
myCar.price = ; 22

5. Example Using a Struct (cont.)
getYourCar( yourCar ); 24
cout << "Your car is a: " << yourCar.maker << endl;
cout << fixed << showpoint << setprecision( 2 ) <<
"I'll offer $" << yourCar.price <<
" for your car." << endl; 29
return 0;
31 } 32

6. Example Using a Struct (cont.)
33 void getYourCar( CarType & car )
34 {
35 cout << "Enter your maker: ";
36 cin >> car.maker;
37 cout << "Enter the year: ";
38 cin >> car.year;
39 cout << "Enter the price: $";
40 cin >> car.price;
41 }

7. Object Assignment
An object of a struct can be assigned to another object of the same struct type:
myCar = yourCar;
This assigns each data member in yourCar to the corresponding data member of myCar
Also assigns any array data members

8. Classes A class is similar to a struct
A class contains data members, but it also contains function members
Objects are made from classes, similarly to the way that objects are made from structs
The main program communicates with the objects
data is passed from main program to object and from object back to the main program

9. Main Program Using Objects
Object A
Main
Program
Object C
Object B

10. Main Program Using Objects
Object A
Main
Program
Object C
Object B

11. Main Program Using Objects
Object A
Main
Program
Object C
Object B

12. Main Program Using Objects
Object A
Main
Program
Object C
Object B

13. Main Program Using Objects
Object A
Main
Program
Object C
Object B

14. Main Program Using Objects
Object A
Main
Program
Object C
Object B

15. Main Program Using Objects
Object A
Main
Program
Object C
Object B

16. Main Program Using Objects
Object A
Main
Program
Object C
Object B

17. Main Program Using Objects
Object A
Main
Program
Object C
Object B

18. How the Main Program Uses A Class Object
The main program does not access the data within a class object
The main program only accesses the functions of a class object
communication occurs by passing data as parameters into the object’s function
the object passes data to the main program through its return type

19. Main Program and Object
public:
functions
private:
data
Main
Program

20. Main Program Calls a Function in the Object
public:
functions
private:
data
Main
Program

21. The Function Accesses Data
Object
public:
functions
private:
data
Main
Program

22. Function Returns a Value Back to the Main Program
Object
public:
functions
private:
data
Main
Program

23. Main Program Calls a Different Function
Object
public:
functions
private:
data
Main
Program

24. Function Calls Another Function
Object
public:
functions
private:
data
Main
Program

25. Second Function Accesses Data
Object
public:
functions
private:
data
Main
Program

26. Second Function Returns Back to First Function
Object
public:
functions
private:
data
Main
Program

27. First Function Accesses Data
Object
public:
functions
private:
data
Main
Program

28. Function Returns Back to Main Program
Object
public:
functions
private:
data
Main
Program

29. Example of a Class 1 class Checkbook 2 { 3 public:
2 {
3 public:
void setBalance( float amount );
bool writeCheck( float amount );
void deposit( float amount );
float getBalance( );
float getLastCheck( );
float getLastDeposit( );
10 private:
float balance;
12 float lastCheck;
float lastDeposit;
14 };
This class definition is placed into its own file, called the class specification file, named checkbook.h (by convention)

30. Example of a Class (cont.)
1 class Checkbook
2 {
3 public:
void setBalance( float amount );
bool writeCheck( float amount );
void deposit( float amount );
float getBalance( );
float getLastCheck( );
float getLastDeposit( );
10 private:
float balance;
12 float lastCheck;
float lastDeposit;
14 };
The writeCheck function returns false if the amount of the check is greater than the balance; returns true otherwise.

31. Example of a Class (cont.)
1 class Checkbook
2 {
3 public:
void setBalance( float amount );
bool writeCheck( float amount );
void deposit( float amount );
float getBalance( );
float getLastCheck( );
float getLastDeposit( );
10 private:
float balance;
12 float lastCheck;
float lastDeposit;
14 };
Don’t forget the semicolon.

32. Example of a Class (cont.)
15 #include “checkbook.h” 16
17 void Checkbook::setBalance( float amount )
18 {
19 balance = amount;
20 }
The function definitions are placed into a separate file called the class implementation file. This file would be called checkbook.cpp (by convention).

33. Example of a Class (cont.)
15 #include “checkbook.h” 16
17 void Checkbook::setBalance( float amount )
18 {
19 balance = amount;
20 }
The balance variable is declared in the private section of the class definition.

34. Example of a Class (cont.)
15 #include “checkbook.h” 16
17 void Checkbook::setBalance( float amount )
18 {
19 balance = amount;
20 }
Special notation for class function definitions

35. Example of a Class (cont.)
21 bool Checkbook::writeCheck( float amount )
22 {
23 if ( amount > balance )
24 return false;
25 balance -= amount;
26 lastCheck = amount;
27 return true;
28 }

36. Example of a Class (cont.)
29 void Checkbook::deposit( float amount )
30 {
31 balance += amount;
32 lastDeposit = amount;
33 }

37. Example of a Class (cont.)
34 float Checkbook::getBalance( )
35 {
36 return balance;
37 } 38
39 float Checkbook::getLastCheck( )
40 {
41 return lastCheck;
42 }
end of checkbook.cpp

38. A Program that Uses the Checkbook Class
1 #include <iostream>
2 #include <iomanip>
3 #include "checkbook.h" 4
5 using namespace std; 6
7 int menu( ); 8
9 const int CHECK = 1, DEPOSIT = 2, BALANCE = 3, QUIT = 4; 10
11 int main( )
12 {
13 Checkbook cb;
14 float balance, amount;
15 int choice;
A main program that uses the Checkbook class is placed into a separate .cpp file

39. A Program that Uses the Checkbook Class (cont.)
16 cout << "Enter the initial balance: $";
17 cin >> balance;
18 cb.setBalance( balance ); 19
20 cout << fixed << showpoint << setprecision( 2 );

40. A Program that Uses the Checkbook Class (cont.)
21 choice = menu( );
22 while ( choice != QUIT ) {
23 if ( choice == CHECK ) {
cout << "Enter check amount: $";
cin >> amount;
if ( cb.writeCheck( amount ) )
27 cout << "Check accepted." << endl;
else {
29 cout << "Your balance is not high ";
30 cout << "enough for that check." << endl;
31 } }
body of the while loop continues

41. A Program that Uses the Checkbook Class (cont.)
33 else if ( choice == DEPOSIT ) {
34 cout << "Enter deposit amount: $";
35 cin >> amount;
36 cb.deposit( amount );
37 cout << "Deposit accepted." << endl;
38 }
body of the while loop continues

42. A Program that Uses the Checkbook Class (cont.)
else { // must be a balance request
amount = cb.getBalance( );
cout << "Your balance is: $" << amount << endl; } 43
choice = menu( );
45 } 46
47 return 0;
48 } 49
end of while loop

43. A Program that Uses the Checkbook Class (cont.)
50 int menu( )
51 {
52 int choice; 53
54 cout << endl;
55 cout << "1 Write a check" << endl;
56 cout << "2 Make a deposit" << endl;
57 cout << "3 Get the balance" << endl;
58 cout << "4 Quit" << endl << endl;
59 cout << "Enter a number between 1 and 4: ";
60 cin >> choice;
61 return choice;
62 }

44. Keep In Mind
The data members of a class cannot be accessed by a main program.
The object always retains the current values of its data members, even when object code is no longer executing.
Each function of a class can use the data members of the class as though they have been declared within the function.

45. Maintenance
Maintenance refers to any work done on a program after it is put into operation
The world constantly changes
Programs have to be maintained (modified) to keep up with the changes
When programs are maintained, the data members sometimes have to change
Private data members make it easier to maintain a program

46. If Data Members were Accessed Directly…
Class
Main
Program
int a;
int b;
int c; .
Suppose the variables of a class were accessed by 100 places in a program

47. If Data Members were Accessed Directly… (cont.)
Class
Main
Program
int arr[10] .
Then we need to change the way the data is repre-sented (for maintenance)

48. If Data Members were Accessed Directly… (cont.)
Class
Main
Program
int arr[10] .
We need to change 100 lines of code in the main program!

49. Data Members Should Be Private
Class
Main
Program
int foo( int x )
private:
int a;
int b;
int c; .
Here, the main program calls foo from 100 places.

50. Data Members Should Be Private (cont.)
Class
Main
Program
int foo( int x )
private:
int a;
int b;
int c; .
Then foo accesses the private data members.

51. Data Members Should Be Private (cont.)
Class
Main
Program
int foo( int x )
private:
int arr[10] .
If the data needs to change, the body of foo will need to be rewritten.

52. Data Members Should Be Private (cont.)
Class
Main
Program
int foo( int x )
private:
int arr[10] .
However, the function call of foo and return type will stay the same.

53. Data Members Should Be Private (cont.)
Class
Main
Program
int foo( int x )
private:
int arr[10] .
No changes need to be made in the main program!

54. Data Members Should Be Private (cont.)
Class
Main
Program
int foo( int x )
private:
int arr[10] .
Program maintenance is easier this way…

55. Data Members Should Be Private (cont.)
Class
Main
Program
int foo( int x )
private:
int arr[10] .
especially if there is more than one program using the class.

56. When Writing a Class
Your class may be used by hundreds or even thousands of clients (main programmers)
Write your class for clients, not for computer users
Do not put code in your class which gives messages to users or asks users for information – let clients handle this the way they want

57. Debugging a Program with Classes
First technique – make the classes and the main program and test everything all at once
inefficient: takes a long time to track down each bug
Second technique – test each class as it is made by writing a main program just to test it (called a test driver or driver)

58. First Technique Class 1 bugs in the classes Class 2 Main Program
Let’s assume it takes 2 hours, on average, to fix each problem.
Class 4

59. First Technique (cont.)
Class 1
Runtime Errors: 20
Time: 0:00
Class 2
Main
Program
Class 3
Class 4

60. First Technique (cont.)
Class 1
Runtime Errors: 19
Time: 2:00
Class 2
Main
Program
Class 3
Class 4

61. First Technique (cont.)
Class 1
Runtime Errors: 18
Time: 4:00
Class 2
Main
Program
Class 3
Class 4

62. First Technique (cont.)
Class 1
Runtime Errors: 17
Time: 6:00
Class 2
Main
Program
Class 3
Class 4

63. First Technique (cont.)
Class 1
Runtime Errors: 16
Time: 8:00
Class 2
Main
Program
Class 3
Class 4

64. First Technique (cont.)
Class 1
Runtime Errors: 15
Time: :00
Class 2
Main
Program
Class 3
Class 4

65. First Technique (cont.)
Class 1
Runtime Errors: 14
Time: :00
Class 2
Main
Program
Class 3
Class 4

66. First Technique (cont.)
Class 1
Runtime Errors: 13
Time: :00
Class 2
Main
Program
Class 3
Class 4

67. First Technique (cont.)
Class 1
Runtime Errors: 12
Time: :00
Class 2
Main
Program
Class 3
Class 4

68. First Technique (cont.)
Class 1
Runtime Errors: 11
Time: :00
Class 2
Main
Program
Class 3
Class 4

69. First Technique (cont.)
Class 1
Runtime Errors: 10
Time: :00
Class 2
Main
Program
Class 3
Class 4

70. First Technique (cont.)
Class 1
Runtime Errors: 9
Time: :00
Class 2
Main
Program
Class 3
Class 4

71. First Technique (cont.)
Class 1
Runtime Errors: 8
Time: :00
Class 2
Main
Program
Class 3
Class 4

72. First Technique (cont.)
Class 1
Runtime Errors: 7
Time: :00
Class 2
Main
Program
Class 3
Class 4

73. First Technique (cont.)
Class 1
Runtime Errors: 6
Time: :00
Class 2
Main
Program
Class 3
Class 4

74. First Technique (cont.)
Class 1
Runtime Errors: 5
Time: :00
Class 2
Main
Program
Class 3
Class 4

75. First Technique (cont.)
Class 1
Runtime Errors: 4
Time: :00
Class 2
Main
Program
Class 3
Class 4

76. First Technique (cont.)
Class 1
Runtime Errors: 3
Time: :00
Class 2
Main
Program
Class 3
Class 4

77. First Technique (cont.)
Class 1
Runtime Errors: 2
Time: :00
Class 2
Main
Program
Class 3
Class 4

78. First Technique (cont.)
Class 1
Runtime Errors: 1
Time: :00
Class 2
Main
Program
Class 3
Class 4

79. First Technique (cont.)
Class 1
Runtime Errors: 0
Time: :00
Class 2
Main
Program
Class 3
Class 4

80. Using Drivers
Class 1
We’ll try the second technique – write a driver to test each class.
Assume it takes one hour to write a driver.
Fixing a runtime error will be faster – let’s say it takes a half an hour.
Class 2
Class 3
Class 4
Time for first technique: 40:00

81. Using Drivers (cont.) Class 1 Runtime Errors: 20 Time: 0:00 Class 2
Time for first technique: 40:00

82. Using Drivers (cont.) Class 1 Runtime Errors: 20 Write a Driver
Time for first technique: 40:00

83. Using Drivers (cont.) Class 1 Runtime Errors: 20 Driver Time: 1:00
Time for first technique: 40:00

84. Using Drivers (cont.) Class 1 Runtime Errors: 19 Driver Time: 1:30
Time for first technique: 40:00

85. Using Drivers (cont.) Class 1 Runtime Errors: 18 Driver Time: 2:00
Time for first technique: 40:00

86. Using Drivers (cont.) Class 1 Runtime Errors: 17 Driver Time: 2:30
Time for first technique: 40:00

87. Using Drivers (cont.) Class 1 Runtime Errors: 16 Driver Time: 3:00
Time for first technique: 40:00

88. Using Drivers (cont.) Class 1 Runtime Errors: 15 Driver Time: 3:30
Time for first technique: 40:00

89. Using Drivers (cont.) Class 1 Class 2 Runtime Errors: 15 Time: 3:30
Time for first technique: 40:00

90. Using Drivers (cont.) Class 1 Class 2 Runtime Errors: 15 Time: 3:30
Write a Driver
Class 3
Class 4
Time for first technique: 40:00

91. Using Drivers (cont.) Class 1 Class 2 Runtime Errors: 15 Time: 4:30
Time for first technique: 40:00

92. Using Drivers (cont.) Class 1 Class 2 Runtime Errors: 14 Time: 5:00
Time for first technique: 40:00

93. Using Drivers (cont.) Class 1 Class 2 Runtime Errors: 13 Time: 5:30
Time for first technique: 40:00

94. Using Drivers (cont.) Class 1 Class 2 Runtime Errors: 12 Time: 6:00
Time for first technique: 40:00

95. Using Drivers (cont.) Class 1 Class 2 Runtime Errors: 11 Time: 6:30
Time for first technique: 40:00

96. Using Drivers (cont.) Class 1 Class 2 Runtime Errors: 10 Time: 7:00
Time for first technique: 40:00

97. Using Drivers (cont.) Class 1 Class 2 Class 3 Runtime Errors: 10
Time for first technique: 40:00

98. Using Drivers (cont.) Class 1 Class 2 Class 3 Runtime Errors: 10
Write a Driver
Class 4
Time for first technique: 40:00

99. Using Drivers (cont.) Class 1 Class 2 Class 3 Runtime Errors: 10
Time for first technique: 40:00

100. Using Drivers (cont.) Class 1 Class 2 Class 3 Runtime Errors: 9
Time for first technique: 40:00

101. Using Drivers (cont.) Class 1 Class 2 Class 3 Runtime Errors: 8
Time for first technique: 40:00

102. Using Drivers (cont.) Class 1 Class 2 Class 3 Runtime Errors: 7
Time for first technique: 40:00

103. Using Drivers (cont.) Class 1 Class 2 Class 3 Runtime Errors: 6
Time for first technique: 40:00

104. Using Drivers (cont.) Class 1 Class 2 Class 3 Runtime Errors: 5
Time for first technique: 40:00

105. Using Drivers (cont.) Class 1 Time for first technique: 40:00 Class 2
Runtime Errors: 5
Time: 10:30
Class 4

106. Using Drivers (cont.) Class 1 Time for first technique: 40:00 Class 2
Runtime Errors: 5
Time: 10:30
Class 4
Write a Driver

107. Using Drivers (cont.) Class 1 Time for first technique: 40:00 Class 2
Runtime Errors: 5
Time: 11:30
Class 4
Driver

108. Using Drivers (cont.) Class 1 Time for first technique: 40:00 Class 2
Runtime Errors: 4
Time: 12:00
Class 4
Driver

109. Using Drivers (cont.) Class 1 Time for first technique: 40:00 Class 2
Runtime Errors: 3
Time: 12:30
Class 4
Driver

110. Using Drivers (cont.) Class 1 Time for first technique: 40:00 Class 2
Runtime Errors: 2
Time: 13:00
Class 4
Driver

111. Using Drivers (cont.) Class 1 Time for first technique: 40:00 Class 2
Runtime Errors: 1
Time: 13:30
Class 4
Driver

112. Using Drivers (cont.) Class 1 Time for first technique: 40:00 Class 2
Runtime Errors: 0
Time: 14:00
Class 4
Driver

113. Using Drivers (cont.) Class 1 Time for first technique: 40:00 Class 2
Runtime Errors: 0
Time: 14:00
Class 4
Driver

114. Function Definitions in the Class Specification
The following slides show that function definitions can be placed into the class specification.
In general, we should avoid doing this because it is a hindrance to program maintenance.
It is shown here because you will see code written this way during your career.

115. Function Definitions in the Class Specification (cont.)
1 // checkbook.h – A class for a checkbook
2 class Checkbook
3 {
4 public:
5 void setBalance( float amount )
6 { balance = amount; }
7 bool writeCheck( float amount ); // returns false if
// amount is greater than balance;
// otherwise returns true
void deposit( float amount ) { balance += amount;
lastDeposit = amount; }

116. Function Definitions in the Class Specification (cont.)
float getBalance( ) { return balance; }
float getLastCheck( ) { return lastCheck; }
float getLastDeposit( ) { return lastDeposit; }
15 private:
16 float balance;
17 float lastCheck;
18 float lastDeposit;
19 };

117. Function Definitions in the Class Specification (cont.)
20 // checkbook.cpp – function definitions for the
21 // Checkbook class
22 #include “checkbook.h” 23
24 bool Checkbook::writeCheck( float amount )
25 {
26 if ( amount > balance )
27 return false;
28 balance -= amount;
29 lastCheck = amount;
30 return true;
31 }

118. Struct vs. Class
Functions can be placed in a struct, but only when necessary
The public and private keywords can be left out of a class (rare).
The public and private keywords can be placed into a struct (rare).
So what is the difference between a struct and a class?

119. Struct vs. Class (cont.)
If public and private are not used in a struct, all data members are public by default.
If public and private are not used in a class, all data members are private by default.

120. Conventions
By convention, we use structs when we want all data members to be public
structs are typically defined and used within the client’s program, not in a separate file
typically used for records of information
By convention, we use classes when we want all data members to be private (for maintenance purposes)