Ruminations on C++: A decade of programming insight and experience

Copyright
@=10
Contents xi
Preface Vll

@=16
0 Prelude 1
.  0.1 First try 1
.  0.2 Doing it without classes 4
.  0.3 Why was it easier in C++? 5
.  0.4 A bigger example 6
.  0.5 Conclusion 6

Part I Motivation 9
@>

1 Why I use C++ 11
.  1.1 The problem 11
.  1.2 History and context 12
.  1.3 Automatic software distribution 12
.  1.4 Enter C++ 15
.  1.5 Recycled software 20
.  1.6 Postscript 21
2 Why I work on C++ 23
.  2.1 The success of small projects 23
.  2.2 Abstraction 25
.  2.3 Machines should work for people 28
3 Living in the real world 29

@<
Part II Classes and inheritance 35
@>

4 Checklist for class authors 37
5 Surrogate classes 47
.  5.1 The problem 47
.  5.2 The classical solution 48
.  5.3 Virtual copy functions 49
.  5.4 Defining a surrogate class 50
.  5.5 Summary 53
6 Handles: Part 1 55
.  6.1 The problem 55
.  6.2 A simple class 56
.  6.3 Attaching a handle 58
.  6.4 Getting at the object 58
.  6.5 Simple implementation 59
.  6.6 Use-counted handles 60
.  6.7 Copy on write 62
.  6.8 Discussion 63
7 Handles: Part 2 67
.  7.1 Review 68
.  7.2 Separating the use count 69
.  7.3 Abstraction of use counts 70
.  7.4 Access functions and copy on write 73
.  7.5 Discussion 73
8 An object-oriented program 75
.  8.1 The problem 75
.  8.2 An object-oriented solution 76
.  8.3 Handle classes 79
.  8.4 Extension 1: New operations 82
.  8.5 Extension 2: New node types 85
.  8.6 Reflections 86
9 Analysis of a classroom exercise: Part 1 89
.  9.1 The problem 89
.  9.2 Designing the interface 91
.  9.3 A few loose ends 93
.  9.4 Testing the interface 94
.  9.5 Strategy 95
.  9.6 Tactics 96
.  9.7 Combining pictures 99
.  9.8 Conclusion 102
10 Analysis of a classroom exercise: Part 2 103
.  10.1 Strategy 103
.  10.2 Exploiting the structure 116
.  10.3 Conclusion 119
11 When not to use virtual functions 121
.  11.1 The case for 121
.  11.2 The case against 122
.  11.3 Destructors are special 127
.  11.4 Summary 129
.  
@<
Part III Templates 131
@>

12 Designing a container class 133
.  12.1 What does it contain? 133
.  12.2 What does copying the container mean? 134
.  12.3 How do you get at container elements? 137
.  12.4 How do you distinguish reading from writing? 138
.  12.5 How do you handle container growth? 139
.  12.6 What operations does the container provide? 141
.  12.7 What do you assume about the container element type? 141
.  12.8 Containers and inheritance 143
.  12.9 Designing an array like class 144
13 Accessing container elements 151
.  13.1 Imitating a pointer 151
.  13.2 Getting at the data 153
.  13.3 Remaining problems 155
.  13.4 Pointer to const Array 159
.  13.5 Useful additions 161
14 Iterators 167
.  14.1 Completing the Pointer class 167
.  14.2 What is an iterator? 170
.  14.3 Deleting an element 171
.  14.4 Deleting the container 172
.  14.5 Other design considerations 173
.  14.6 Discussion 174
15 Sequences 175
.  15.1 The state of the art 175
.  15.2 A radical old idea 176
.  15.3 Well, maybe a few extras... 181
.  15.4 Example of use 184
.  15.5 Maybe a few more... 188
.  15.6 Food for thought 190
16 Templates as interfaces 191
.  16.1 The problem 191
.  16.2 The first example 192
.  16.3 Separating the iteration 192
.  16.4 Iterating over arbitrary types 195
.  16.5 Adding other types 196
.  16.6 Abstracting the storage technique 196
.  16.7 The proof of the pudding 199
.  16.8 Summary 200
17 Templates and generic algorithms 203
.  17.1 A specific example 204
.  17.2 Generalizing the element type 205
.  17.3 Postponing the count 205
.  17.4 Address independence 207
.  17.5 Searching a nonarray 208
.  17.6 Discussion 210
18 Generic iterators 213
.  18.1 A different algorithm 213
.  18.2 Categories of requirements 215
.  18.3 Input iterators 216
.  18.4 Output iterators 216
.  18.5 Forward iterators 217
.  18.6 Bidirectional iterators 218
.  18.7 Random-access iterators 218
.  18.8 Inheritance? 220
.  18.9 Performance 220
.  18.10 Summary 221
19 Using generic iterators 223
.  19.1 I tera tor types 224
.  19.2 Virtual sequences 224
.  19.3 An output-stream iterator 227
.  19.4 An input-stream iterator 229
.  19.5 Discussion 232
20 Iterator adaptors 233
.  20.1 An example 233
.  20.2 Directional asymmetry 235
.  20.3 Consistency and asymmetry 236
.  20.4 Automatic reversal 237
.  20.5 Discussion 240
21 Function objects 241
.  21.1 An example 241
.  21.2 Function pointers 244
.  21.3 Function objects 246
.  21.4 Function-object templates 248
.  21.5 Hiding intermediate types 249
.  21.6 One type covers many 250
.  21.7 Implementation 251
.  21.8 Discussion 253
22 Function adaptors 255
.  22.1 Why function objects? 255
.  22.2 Function objects for built-in operators 256
.  22.3 Binders 257
.  22.4 A closer look 258
.  22.5 Interface inheritance 259
.  22.6 U sing these classes 260
.  22.7 Discussion 261
.  
@<
Part IV Libraries 263
@>

23 Libraries in everyday use 265
.  23.1 The problem 265
.  23.2 Understanding the problem-part 1 267
.  23.3 Implementation-part 1 267
.  23.4 Understanding the problem-part 2 270
.  23.5 Implementation-part 2 270
.  23.6 Discussion 272
24 An object lesson in library-interface design 275
.  24.1 Complications 276
.  24.2 Improving the interface 277
.  24.3 Taking stock 279
.  24.4 Writing the code 280
.  24.5 Conclusion 282
25 Library design is language design 283
.  25.1 Character strings 283
.  25.2 Memory exhaustion 284
.  25.3 Copying 287
.  25.4 Hiding the implementation 290
.  25.5 Default constructor 292
.  25.6 Other operations 293
.  25.7 Substrings 295
.  25.8 Conclusion 296
26 Language design is library design 297
.  26.1 Abstract data types 297
.  26.2 Libraries and abstract data types 299
.  26.3 Memory allocation 302
.  26.4 Memberwise assignment and initialization 303
.  26.5 Exception handling 305
.  26.6 Summary 306
.  
@<
Part V Technique 307
@>

27 Classes that keep track of themselves 309
.  27.1 Design of a trace class 309
.  27.2 Creating dead code 312
.  27.3 Generating audit trails for objects 313
.  27.4 Verifying container behavior 315
.  27.5 Summary 320
28 Allocating objects in clusters 321
.  28.1 The problem 321
.  28.2 Designing the solution 321
.  28.3 Implementation 324
.  28.4 Enter inheritance 326
.  28.5 Summary 327
29 Applicators, manipulators, and function objects 329
.  29.1 The problem 329
.  29.2 A solution 332
.  29.3 A different solution 332
.  29.4 Multiple arguments 334
.  29.5 An example 335
.  29.6 Abbreviations 337
.  29.7 Musings 338
.  29.8 Historical notes, references, and acknowledgments 339
30 Decoupling application libraries from input-output 341
.  30.1 The problem 341
.  30.2 Solution 1: Trickery and brute force 342
.  30.3 Solution 2: Abstract output 343
.  30.4 Solution 3: Trickery without brute force 345
.  30.5 Remarks 348
.  
@<
Part VI Wrapup 349
@>

31 Simplicity through complexity 351
.  31.1 The world is complicated 351
.  31.2 Complexity becomes hidden 352
.  31.3 Computers are no different 353
.  31.4 Computers solve real problems 354
.  31.5 Class libraries and language semantics 355
.  31.6 Making things easy is hard 357
.  31.7 Abstraction and interface 357
.  31.8 Conservation of complexity 358
32 What do you do after you say Bello world? 361
.  32.1 Find the local experts 361
.  32.2 Pick a tool kit and become comfortable with it 362
.  32.3 Some parts of C are essential... 362
.  32.4 ...but others are not 364
.  32.5 Set yourself a series of problems 366
.  32.6 Conclusion 368
.  
@<
Index 371