Object-oriented software in Ada 95.

446 Pages·1995·1.41 MB·English

by  Michael A. Smith

R e p r o d u c t i o n p r o h i b i t e d w i t h o u t p e r m i s s i o n o f t h e a u t h o r
(cid:214) r
Note: This is an example of comments, the more experienced programmer would probably miss out many of
the above comments as the effect of the code is easily understandable.
Comments that do not add to a reader’s understanding of the program code should be avoided. In some
circumstances the choice of meaning full names for memory locations is all that is required. As
begin
Deposit( My_Account, 100.00 );
Other_Account := My_Account; --Copy and
(cid:211) M A Smith - May not be reproduced without permission

Object-oriented Software in Ada 95 Second Edition
Object-oriented Software in Ada 95 Second Edition
Michael A. Smith
School of Computing
University of Brighton
(cid:211) M A Smith - May not be reproduced without permission
Contents
CONTENTS...............................................................................................................................................................IV
1.1 GLOSSARY OF TERMS USED..........................................................................................................................XV
1 INTRODUCTION TO PROGRAMMING.................................................................................................1
1.1 COMPUTER PROGRAMMING..............................................................................................................................1
1.2 PROGRAMMING LANGUAGES............................................................................................................................1
1.3 RANGE OF PROGRAMMING LANGUAGES.......................................................................................................2
1.3.1 Computer programming languages............................................................................................................2
1.3.2 The role of a compiler...................................................................................................................................2
1.4 A SMALL PROBLEM..............................................................................................................................................3
1.5 SOLVING THE PROBLEM USING A CALCULATOR........................................................................................3
1.5.1 Making the solution more general..............................................................................................................4
1.6 SOLVING THE PROBLEM USING THE ADA 95 LANGUAGE.........................................................................4
1.6.1 Running the program.....................................................................................................................................6
1.7 THE DECLARE BLOCK............................................................................................................................................6
1.8 THE ROLE OF COMMENTS..................................................................................................................................7
1.9 SUMMARY...............................................................................................................................................................8
1.10 A MORE DESCRIPTIVE PROGRAM....................................................................................................................8
1.10.1 Running the new program............................................................................................................................9
1.11 TYPES OF MEMORY LOCATION.........................................................................................................................9
1.11.1 Warning........................................................................................................................................................10
1.12 REPETITION..........................................................................................................................................................10
1.13 INTRODUCTION TO THE WHILE STATEMENT..............................................................................................11
1.13.1 Conditions....................................................................................................................................................12
1.13.2 A while statement in Ada 95..................................................................................................................12
1.13.3 Using the while statement......................................................................................................................13
1.14 SELECTION............................................................................................................................................................14
1.14.1 Using the if statement..............................................................................................................................15
1.15 SELF-ASSESSMENT.............................................................................................................................................16
1.16 PAPER EXERCISES...............................................................................................................................................17
2 SOFTWARE DESIGN...................................................................................................................................18
2.1 THE SOFTWARE CRISIS......................................................................................................................................18
2.2 A PROBLEM, THE MODEL AND THE SOLUTION..........................................................................................18
2.2.1 Responsibilities............................................................................................................................................19
2.3 OBJECTS.................................................................................................................................................................19
2.3.1 The car as an object....................................................................................................................................20
2.4 THE CLASS............................................................................................................................................................21
2.5 METHODS AND MESSAGES..............................................................................................................................21
2.6 CLASS OBJECTS...................................................................................................................................................21
2.7 INHERITANCE.......................................................................................................................................................22
2.8 POLYMORPHISM..................................................................................................................................................23
2.9 SELF-ASSESSMENT.............................................................................................................................................23
3 ADA INTRODUCTION: PART 1...............................................................................................................25
3.1 A FIRST ADA PROGRAM....................................................................................................................................25
3.2 THE CASE OF IDENTIFIERS IN A PROGRAM.................................................................................................26
3.3 FORMAT OF AN ADA PROGRAM.....................................................................................................................26
3.3.1 Variable names............................................................................................................................................26
3.3.2 Comments.....................................................................................................................................................27
3.4 A LARGER ADA PROGRAM..............................................................................................................................27
3.5 REPETITION: WHILE.............................................................................................................................................28
3.6 SELECTION: IF.....................................................................................................................................................28
3.7 OTHER REPETITION CONSTRUCTS.................................................................................................................29
(cid:211) M A Smith - May not be reproduced without permission
Contents v
3.7.1 for...................................................................................................................................................................29
3.7.2 loop................................................................................................................................................................30
3.8 OTHER SELECTION CONSTRUCTS..................................................................................................................31
3.8.1 case................................................................................................................................................................31
3.9 INPUT AND OUTPUT...........................................................................................................................................32
3.10 ACCESS TO COMMAND LINE ARGUMENTS..................................................................................................33
3.10.1 Putting it all together.................................................................................................................................34
3.11 A BETTER CAT PROGRAM.................................................................................................................................34
3.11.1 Putting it all together.................................................................................................................................35
3.12 CHARACTERS IN ADA........................................................................................................................................35
3.13 SELF-ASSESSMENT.............................................................................................................................................36
3.14 EXERCISES.............................................................................................................................................................37
4 ADA INTRODUCTION: PART 2...............................................................................................................38
4.1 INTRODUCTION...................................................................................................................................................38
4.2 THE TYPE FLOAT..................................................................................................................................................38
4.2.1 Other Integer and Float data types..........................................................................................................39
4.3 NEW DATA TYPES...............................................................................................................................................39
4.3.1 Type conversions.........................................................................................................................................40
4.3.2 Universal integer........................................................................................................................................40
4.3.3 Constant declarations................................................................................................................................40
4.4 MODIFIED COUNTDOWN PROGRAM..............................................................................................................41
4.5 INPUT AND OUTPUT IN ADA............................................................................................................................41
4.6 THE PACKAGE ADA.FLOAT_TEXT_IO...........................................................................................................41
4.6.1 Output of floating point numbers.............................................................................................................42
4.6.2 Input of floating point numbers................................................................................................................42
4.7 THE PACKAGE ADA.INTEGER_TEXT_IO......................................................................................................42
4.7.1 Output of integer numbers.........................................................................................................................42
4.7.2 Input of integer numbers............................................................................................................................43
4.8 CONVERSION BETWEEN FLOAT AND INTEGER TYPES..............................................................................43
4.9 TYPE SAFETY IN A PROGRAM.........................................................................................................................44
4.10 SUBTYPES..............................................................................................................................................................44
4.10.1 Types vs. subtypes.......................................................................................................................................45
4.11 MORE ON TYPES AND SUBTYPES...................................................................................................................45
4.11.1 Root_Integer and Root_Real.....................................................................................................................46
4.11.2 Type declarations: root type of type........................................................................................................46
4.11.3 Arithmetic with types and subtypes..........................................................................................................47
4.11.4 Warning........................................................................................................................................................47
4.11.5 Constrained and unconstrained types.....................................................................................................48
4.11.6 Implementation optimizations...................................................................................................................48
4.12 COMPILE-TIME AND RUN-TIME CHECKS.....................................................................................................49
4.12.1 Subtypes Natural and Positive......................................................................................................50
4.13 ENUMERATIONS..................................................................................................................................................50
4.13.1 Enumeration values....................................................................................................................................51
4.13.2 The attributes 'Val and 'Pos................................................................................................................51
4.14 THE SCALAR TYPE HIERARCHY......................................................................................................................52
4.14.1 The inbuilt types..........................................................................................................................................53
4.15 ARITHMETIC OPERATORS................................................................................................................................53
4.15.1 Exponentiation............................................................................................................................................54
4.15.2 Monadic arithmetic operators..................................................................................................................54
4.16 MEMBERSHIP OPERATORS...............................................................................................................................54
4.17 USE OF TYPES AND SUBTYPES WITH MEMBERSHIP OPERATOR...........................................................55
4.18 RELATIONAL OPERATORS................................................................................................................................56
4.18.1 Boolean operators..............................................................................................................................56
4.18.2 Monadic Boolean operators..................................................................................................................57
4.19 BITWISE OPERATORS.........................................................................................................................................57
4.20 SELF-ASSESSMENT.............................................................................................................................................58
vi Contents
4.21 EXERCISES.............................................................................................................................................................59
5 PROCEDURES AND FUNCTIONS..........................................................................................................60
5.1 INTRODUCTION...................................................................................................................................................60
5.2 FUNCTIONS...........................................................................................................................................................60
5.2.1 Local variables............................................................................................................................................61
5.2.2 Separate compilation of functions............................................................................................................61
5.3 PROCEDURES........................................................................................................................................................62
5.3.1 Separate compilation of procedures........................................................................................................63
5.4 FORMAL AND ACTUAL PARAMETERS..........................................................................................................64
5.5 MODES OF A PARAMETER TO A FUNCTION OR PROCEDURE.................................................................64
5.5.1 Example of mode in out........................................................................................................................65
5.5.2 Putting it all together.................................................................................................................................65
5.5.3 Summary of access to formal parameters...............................................................................................66
5.6 RECURSION...........................................................................................................................................................66
5.6.1 The procedure Write_Natural..........................................................................................................67
5.6.2 Putting it all together.................................................................................................................................67
5.7 OVERLOADING OF FUNCTIONS.......................................................................................................................67
5.8 DIFFERENT NUMBER OF PARAMETERS........................................................................................................69
5.9 DEFAULT VALUES AND NAMED PARAMETERS..........................................................................................69
5.9.1 Putting it all together.................................................................................................................................70
5.10 SELF-ASSESSMENT.............................................................................................................................................71
5.11 EXERCISES.............................................................................................................................................................71
6 PACKAGES AS CLASSES..........................................................................................................................73
6.1 INTRODUCTION...................................................................................................................................................73
6.2 OBJECTS, MESSAGES AND METHODS...........................................................................................................74
6.3 OBJECTS, MESSAGES AND METHODS IN ADA............................................................................................74
6.3.1 An object for a bank account....................................................................................................................75
6.3.2 The procedure Statement.....................................................................................................................76
6.3.3 Putting it all together.................................................................................................................................76
6.3.4 Components of a package..........................................................................................................................76
6.3.5 Specification of the package.....................................................................................................................76
6.3.6 A class diagram showing a class..............................................................................................................78
6.3.7 Representation of the balance of the account........................................................................................78
6.3.8 Implementation of the package.................................................................................................................78
6.3.9 Terminology.................................................................................................................................................79
6.4 THE PACKAGE AS SEEN BY A USER...............................................................................................................79
6.5 THE PACKAGE AS SEEN BY AN IMPLEMENTOR.........................................................................................79
6.6 THE CLASS............................................................................................................................................................80
6.7 CLAUSES WITH AND USE..................................................................................................................................80
6.7.1 To use or not to use the use clause........................................................................................................81
6.7.2 The package Standard...........................................................................................................................81
6.7.3 Positioning of with and use in a package declaration....................................................................81
6.7.4 Conflict in names in a package................................................................................................................82
6.8 MUTATORS AND INSPECTORS.........................................................................................................................82
6.9 TYPE PRIVATE......................................................................................................................................................83
6.9.1 Type limited private......................................................................................................................83
6.10 INITIALIZING AN OBJECT AT DECLARATION TIME...................................................................................84
6.10.1 By discriminant...........................................................................................................................................84
6.10.2 Restrictions..................................................................................................................................................85
6.10.3 By assignment..............................................................................................................................................85
6.10.4 Restrictions..................................................................................................................................................86
6.11 A PERSONAL ACCOUNT MANAGER...............................................................................................................86
6.12 CLASS TUI............................................................................................................................................................89
6.13 SELF-ASSESSMENT.............................................................................................................................................91
6.14 EXERCISES.............................................................................................................................................................92
(cid:211) M A Smith - May not be reproduced without permission
Contents vii
7 DATA STRUCTURES...................................................................................................................................94
7.1 THE RECORD STRUCTURE..................................................................................................................................94
7.2 OPERATIONS ON A DATA STRUCTURE.........................................................................................................94
7.2.1 Other operations allowed on data structures.........................................................................................95
7.3 NESTED RECORD STRUCTURES........................................................................................................................96
7.4 DISCRIMINANTS TO RECORDS........................................................................................................................96
7.5 DEFAULT VALUES TO A DISCRIMINANT......................................................................................................97
7.5.1 Constrained vs. unconstrained discriminants........................................................................................98
7.5.2 Restrictions on a discriminant..................................................................................................................98
7.6 VARIANT RECORDS............................................................................................................................................98
7.7 LIMITED RECORDS...........................................................................................................................................100
7.8 DATA STRUCTURE VS. CLASS.......................................................................................................................100
7.9 SELF-ASSESSMENT...........................................................................................................................................100
7.10 EXERCISES...........................................................................................................................................................101
8 ARRAYS.........................................................................................................................................................102
8.1 ARRAYS AS CONTAINER OBJECTS...............................................................................................................102
8.2 ATTRIBUTES OF AN ARRAY...........................................................................................................................104
8.3 A HISTOGRAM...................................................................................................................................................104
8.3.1 Putting it all together...............................................................................................................................107
8.4 THE GAME OF NOUGHTS AND CROSSES.....................................................................................................108
8.4.1 The class Board.........................................................................................................................................109
8.4.2 Implementation of the game....................................................................................................................109
8.4.3 Displaying the Board.............................................................................................................................110
8.4.4 The class Board.........................................................................................................................................111
8.4.5 Putting it all together...............................................................................................................................113
8.5 MULTIDIMENSIONAL ARRAYS......................................................................................................................113
8.5.1 An alternative way of declaring multidimensional arrays.................................................................114
8.5.2 Attributes of multidimensional arrays...................................................................................................115
8.6 INITIALIZING AN ARRAY................................................................................................................................115
8.6.1 Multidimensional initializations.............................................................................................................116
8.7 UNCONSTRAINED ARRAYS............................................................................................................................117
8.7.1 Slices of an array......................................................................................................................................117
8.7.2 Putting it all together...............................................................................................................................118
8.8 STRINGS...............................................................................................................................................................118
8.9 DYNAMIC ARRAYS...........................................................................................................................................119
8.9.1 Putting it all together...............................................................................................................................119
8.10 A NAME AND ADDRESS CLASS.....................................................................................................................120
8.10.1 Putting it all together...............................................................................................................................122
8.11 AN ELECTRONIC PIGGY BANK......................................................................................................................122
8.12 SELF-ASSESSMENT...........................................................................................................................................125
8.13 EXERCISES...........................................................................................................................................................126
9 CASE STUDY: DESIGN OF A GAME..................................................................................................127
9.1 REVERSI...............................................................................................................................................................127
9.1.1 A program to play reversi........................................................................................................................128
9.2 ANALYSIS AND DESIGN OF THE PROBLEM ...............................................................................................128
9.3 CLASS DIAGRAM...............................................................................................................................................130
9.4 SPECIFICATION OF THE ADA CLASSES.......................................................................................................130
9.5 IMPLEMENTATION OF THE MAIN CLASS GAME.........................................................................................132
9.5.1 Running the program................................................................................................................................133
9.5.2 Example of a typical game......................................................................................................................133
9.6 IMPLEMENTATION OF THE OTHER CLASSES............................................................................................135
9.7 SELF-ASSESSMENT...........................................................................................................................................146
9.8 EXERCISES...........................................................................................................................................................146
10 INHERITANCE........................................................................................................................................147
viii Contents
10.1 INTRODUCTION.................................................................................................................................................147
10.2 TAGGED TYPES..................................................................................................................................................148
10.2.1 Terminology...............................................................................................................................................148
10.3 THE CLASS INTEREST_ACCOUNT...................................................................................................................148
10.3.1 Terminology...............................................................................................................................................152
10.4 VISIBILITY RULES (NORMAL INHERITANCE)............................................................................................152
10.5 CONVERTING A DERIVED CLASS TO A BASE CLASS...............................................................................152
10.6 ABSTRACT CLASS.............................................................................................................................................153
10.6.1 Putting it all together...............................................................................................................................155
10.6.2 Visibility of base class methods..............................................................................................................156
10.7 MULTIPLE INHERITANCE................................................................................................................................156
10.7.1 Putting it all together...............................................................................................................................159
10.8 INITIALIZATION AND FINALIZATION..........................................................................................................159
10.8.1 Implementation..........................................................................................................................................161
10.8.2 Putting it all together...............................................................................................................................162
10.8.3 Warning......................................................................................................................................................162
10.9 HIDING THE BASE CLASS METHODS...........................................................................................................163
10.9.1 Visibility rules (Hidden base class) .......................................................................................................164
10.9.2 Putting it all together...............................................................................................................................164
10.10 SELF-ASSESSMENT......................................................................................................................................164
10.11 EXERCISES......................................................................................................................................................165
11 CHILD LIBRARIES................................................................................................................................166
11.1 INTRODUCTION.................................................................................................................................................166
11.1.1 Putting it all together...............................................................................................................................167
11.1.2 Warning......................................................................................................................................................167
11.2 VISIBILITY RULES OF A CHILD PACKAGE..................................................................................................168
11.3 PRIVATE CHILD.................................................................................................................................................169
11.3.1 Visibility rules of a private child package............................................................................................169
11.4 CHILD PACKAGES VS. INHERITANCE..........................................................................................................169
11.5 SELF-ASSESSMENT...........................................................................................................................................170
11.6 EXERCISES...........................................................................................................................................................170
12 DEFINING NEW OPERATORS.........................................................................................................171
12.1 DEFINING OPERATORS IN ADA.....................................................................................................................171
12.2 A RATIONAL ARITHMETIC PACKAGE..........................................................................................................172
12.2.1 Ada specification of the package............................................................................................................172
12.2.2 Ada implementation of the package.......................................................................................................173
12.3 A BOUNDED STRING CLASS...........................................................................................................................176
12.3.1 Overloading = and /=.............................................................................................................................177
12.3.2 Specification of the class Bounded_String...................................................................................177
12.3.3 Putting it all together...............................................................................................................................180
12.3.4 Ada.Strings.Bounded a standard library.............................................................................180
12.3.5 use type............................................................................................................................................181
12.4 SELF-ASSESSMENT...........................................................................................................................................181
12.5 EXERCISES...........................................................................................................................................................181
13 EXCEPTIONS...........................................................................................................................................183
13.1 THE EXCEPTION MECHANISM.......................................................................................................................183
13.2 RAISING AN EXCEPTION.................................................................................................................................184
13.3 HANDLING ANY EXCEPTION.........................................................................................................................184
13.4 THE CAT PROGRAM REVISITED.....................................................................................................................186
13.5 A STACK..............................................................................................................................................................186
13.5.1 Putting it all together...............................................................................................................................188
13.5.2 Implementation of the stack....................................................................................................................188
13.6 SELF-ASSESSMENT...........................................................................................................................................189
13.7 EXERCISES...........................................................................................................................................................190
(cid:211) M A Smith - May not be reproduced without permission
Contents ix
14 GENERICS................................................................................................................................................191
14.1 GENERIC FUNCTIONS AND PROCEDURES..................................................................................................191
14.1.1 Advantages and disadvantages of generic units..................................................................................193
14.2 SPECIFICATION OF GENERIC COMPONENT...............................................................................................194
14.3 GENERIC STACK................................................................................................................................................195
14.3.1 Putting it all together...............................................................................................................................197
14.3.2 Implementation techniques for a generic package..............................................................................198
14.4 GENERIC FORMAL SUBPROGRAMS..............................................................................................................198
14.4.1 Example of the use of the generic procedure G_3Order.................................................................200
14.4.2 Summary.....................................................................................................................................................200
14.5 SORTING..............................................................................................................................................................201
14.5.1 Efficiency....................................................................................................................................................201
14.6 A GENERIC PROCEDURE TO SORT DATA...................................................................................................202
14.6.1 Putting it all together...............................................................................................................................203
14.6.2 Sorting records..........................................................................................................................................203
14.7 GENERIC CHILD LIBRARY...............................................................................................................................204
14.7.1 Putting it all together...............................................................................................................................206
14.8 INHERITING FROM A GENERIC CLASS........................................................................................................206
14.8.1 Putting it all together...............................................................................................................................207
14.9 SELF-ASSESSMENT...........................................................................................................................................208
14.10 EXERCISES......................................................................................................................................................208
15 DYNAMIC MEMORY ALLOCATION............................................................................................209
15.1 ACCESS VALUES...............................................................................................................................................209
15.1.1 Access to an object via its access value................................................................................................210
15.1.2 Lvalues and rvalues..................................................................................................................................210
15.1.3 Read only access.......................................................................................................................................211
15.2 DYNAMIC ALLOCATION OF STORAGE........................................................................................................212
15.2.1 Problems with dynamically allocated storage.....................................................................................215
15.3 RETURNING DYNAMICALLY ALLOCATED STORAGE.............................................................................215
15.3.1 Summary: access all, access constant, access............................................................216
15.4 USE OF DYNAMIC STORAGE..........................................................................................................................216
15.4.1 Putting it all together...............................................................................................................................219
15.5 HIDING THE STRUCTURE OF AN OBJECT (OPAQUE TYPE).....................................................................220
15.5.1 Putting it all together...............................................................................................................................222
15.5.2 Hidden vs. visible storage in a class......................................................................................................223
15.6 ACCESS VALUE OF A FUNCTION..................................................................................................................223
15.6.1 Putting it all together...............................................................................................................................224
15.7 ATTRIBUTES 'ACCESS AND 'UNCHECKED_ACCESS...................................................................................225
15.8 SELF-ASSESSMENT...........................................................................................................................................226
15.9 EXERCISES...........................................................................................................................................................226
16 POLYMORPHISM..................................................................................................................................227
16.1 ROOMS IN A BUILDING....................................................................................................................................227
16.1.1 Dynamic binding.......................................................................................................................................228
16.2 A PROGRAM TO MAINTAIN DETAILS ABOUT A BUILDING....................................................................228
16.2.1 Putting it all together...............................................................................................................................231
16.3 RUN-TIME DISPATCH.......................................................................................................................................232
16.4 HETEROGENEOUS COLLECTIONS OF OBJECTS.........................................................................................232
16.4.1 An array as a heterogeneous collection................................................................................................233
16.4.2 Additions to the class Office and Room...........................................................................................233
16.5 A BUILDING INFORMATION PROGRAM......................................................................................................235
16.5.1 Putting it all together...............................................................................................................................236
16.6 FULLY QUALIFIED NAMES AND POLYMORPHISM...................................................................................237
16.7 PROGRAM MAINTENANCE AND POLYMORPHISM...................................................................................238
16.8 DOWNCASTING..................................................................................................................................................238
x Contents
16.8.1 Converting a base class to a derived class...........................................................................................239
16.9 THE OBSERVE-OBSERVER PATTERN...........................................................................................................240
16.9.1 The Observer’s responsibilities..............................................................................................................241
16.9.2 The responsibilities of the observable object.......................................................................................241
16.9.3 Putting it all together...............................................................................................................................242
16.10 USING THE OBSERVE-OBSERVER PATTERN.........................................................................................244
16.10.1 The observed board object..................................................................................................................244
16.10.2 An observer for the class Board.......................................................................................................246
16.10.3 The driver code for the program of nought and crosses................................................................246
16.11 SELF-ASSESSMENT......................................................................................................................................247
16.12 EXERCISES......................................................................................................................................................248
17 CONTAINERS..........................................................................................................................................249
17.1 LIST OBJECT.......................................................................................................................................................249
17.1.1 List vs. array...............................................................................................................................................251
17.2 METHODS IMPLEMENTED IN A LIST............................................................................................................251
17.2.1 Example of use...........................................................................................................................................251
17.3 SPECIFICATION AND IMPLEMENTATION OF THE LIST CONTAINER...................................................253
17.3.1 The list iterator..........................................................................................................................................256
17.3.2 Relationship between a list and its iterator..........................................................................................260
17.4 LIMITATIONS OF THE LIST IMPLEMENTATION........................................................................................260
17.5 REFERENCE COUNTING...................................................................................................................................262
17.6 IMPLEMENTATION OF A REFERENCE COUNTING SCHEME...................................................................264
17.6.1 Ada specification.......................................................................................................................................265
17.6.2 Ada implementation..................................................................................................................................266
17.6.3 Putting it all together...............................................................................................................................268
17.7 A SET....................................................................................................................................................................269
17.7.1 Putting it all together...............................................................................................................................271
17.8 SELF-ASSESSMENT...........................................................................................................................................271
17.9 EXERCISES...........................................................................................................................................................272
18 INPUT AND OUTPUT............................................................................................................................273
18.1 THE INPUT AND OUTPUT MECHANISM.......................................................................................................273
18.1.1 Putting it all together...............................................................................................................................274
18.2 READING AND WRITING TO FILES...............................................................................................................275
18.3 READING AND WRITING BINARY DATA.....................................................................................................276
18.4 SWITCHING THE DEFAULT INPUT AND OUTPUT STREAMS..................................................................278
18.4.1 Putting it all together...............................................................................................................................278
18.5 SELF-ASSESSMENT...........................................................................................................................................279
18.6 EXERCISES...........................................................................................................................................................279
19 PERSISTENCE.........................................................................................................................................280
19.1 A PERSISTENT INDEXED COLLECTION.......................................................................................................280
19.1.1 Putting it all together...............................................................................................................................282
19.1.2 Setting up the persistent object...............................................................................................................282
19.2 THE CLASS PIC.................................................................................................................................................282
20 TASKS.........................................................................................................................................................289
20.1 THE TASK MECHANISM...................................................................................................................................289
20.1.1 Putting it all together...............................................................................................................................290
20.1.2 Task rendezvous........................................................................................................................................291
20.1.3 The task’s implementation.......................................................................................................................292
20.2 PARAMETERS TO A TASK TYPE.....................................................................................................................293
20.2.1 Putting it all together...............................................................................................................................294
20.3 MUTUAL EXCLUSION AND CRITICAL SECTIONS.....................................................................................294
20.4 PROTECTED TYPE..............................................................................................................................................295
20.5 IMPLEMENTATION............................................................................................................................................295
(cid:211) M A Smith - May not be reproduced without permission