C++沉思录 英文版PDF电子书下载

Chapter 0 Prelude 1

0.1 Firsttry 1

0.2 Doing it without classes 4

0.3 Whywasit easierinC++? 5

0.4 A bigger example 6

0.5 Conclusion 6

Part Ⅰ Motivation 9

Chapter1 WhyIuseC++ 11

1.1 The problem 11

1.2 History and context 12

1.3 Automatic software distribution 12

1.4 EnterC++ 15

1.5 Recycled software 20

1.6 Postscript 21

Chapter2 Why I work onC++ 23

2.1 The success of small projects 23

2.2 Abstraction 25

2.3 Machines should work for people 28

Chapter 3 Living in the real world 29

Part Ⅱ Classes and inheritance 35

Chapter 4 Checklist for class authors 37

Chapter 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

Chapter 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

Chapter 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

Chapter 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

Chapter 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

Chapter 10 Analysis of a classroom exercise:Part 2 103

10.1 Strategy 103

10.2 Exploiting the structure 116

10.3 Conclusion 119

Chapter 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 Ⅲ Templates 131

Chapter 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 po you assume about the container element type? 141

12.8 Containers and inheritance 143

12.9 Designing an arraylike class 144

Chapter 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

Chapter 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

Chapter 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

Chapter 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

Chapter 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

Chapter 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

Chapter 19 Using generic iterators 223

19.1 Iterator 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

Chapter 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

Chapter 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 intermedlate types 249

21.6 One type covers many 250

21.7 Implementation 251

21.8 Discussion 253

Chapter 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 Using these classes 260

22.7 Discussion 261

Part Ⅳ Libraries 263

Chapter 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

Chapter 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

Chapter 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

Chapter 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 Ⅴ Technique 307

Chapter 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

Chapter 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

Chapter 29 Applicators,manipulators,and function objects 329

29.1 The problem 329

29.2 A 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

Chapter30 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