C++沉思录 英文版【2025|PDF|Epub|mobi|kindle电子书版本百度云盘下载】

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

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

Chapter 0 Prelude1

0.1 Firsttry1

0.2 Doing it without classes4

0.3 Whywasit easierinC++?5

0.4 A bigger example6

0.5 Conclusion6

Part Ⅰ Motivation9

Chapter1 WhyIuseC++11

1.1 The problem11

1.2 History and context12

1.3 Automatic software distribution12

1.4 EnterC++15

1.5 Recycled software20

1.6 Postscript21

Chapter2 Why I work onC++23

2.1 The success of small projects23

2.2 Abstraction25

2.3 Machines should work for people28

Chapter 3 Living in the real world29

Part Ⅱ Classes and inheritance35

Chapter 4 Checklist for class authors37

Chapter 5 Surrogate classes47

5.1 The problem47

5.2 The classical solution48

5.3 Virtual copy functions49

5.4 Defining a surrogate class50

5.5 Summary53

Chapter 6 Handles：Part 155

6.1 The problem55

6.2 A simple class56

6.3 Attaching a handle58

6.4 Getting at the object58

6.5 Simple implementation59

6.6 Use-counted handles60

6.7 Copy on write62

6.8 Discussion63

Chapter 7 Handles:Part 267

7.1 Review68

7.2 Separating the use count69

7.3 Abstraction of use counts70

7.4 Access functions and copy on write73

7.5 Discussion73

Chapter 8 An object-oriented program75

8.1 The problem75

8.2 An object-oriented solution76

8.3 Handle classes79

8.4 Extension 1:New operations82

8.5 Extension 2:New node types85

8.6 Reflections86

Chapter 9 Analysis of a classroom exercise:Part 189

9.1 The problem89

9.2 Designing the interface91

9.3 A few loose ends93

9.4 Testing the interface94

9.5 Strategy95

9.6 Tactics96

9.7 Combining pictures99

9.8 Conclusion102

Chapter 10 Analysis of a classroom exercise:Part 2103

10.1 Strategy103

10.2 Exploiting the structure116

10.3 Conclusion119

Chapter 11 When not to use virtual functions121

11.1 The case for121

11.2 The case against122

11.3 Destructors are special127

11.4 Summary129

Part Ⅲ Templates131

Chapter 12 Designing a container class133

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 inheritance143

12.9 Designing an arraylike class144

Chapter 13 Accessing container elements151

13.1 Imitating a pointer151

13.2 Getting at the data153

13.3 Remaining problems155

13.4 Pointer to const Array159

13.5 Useful additions161

Chapter 14 Iterators167

14.1 Completing the Pointer class167

14.2 What is an iterator?170

14.3 Deleting an element171

14.4 Deleting the container172

14.5 Other design considerations173

14.6 Discussion174

Chapter 15 Sequences175

15.1 The state of the art175

15.2 A radical old idea176

15.3 Well.maybe a few extras181

15.4 Example of use184

15.5 Maybe a few more188

15.6 Food for thought190

Chapter 16 Templates as interfaces191

16.1 The problem191

16.2 The first example192

16.3 Separating the iteration192

16.4 Iterating over arbitrary types195

16.5 Adding other types196

16.6 Abstracting the storage technique196

16.7 The proof of the pudding199

16.8 Summary200

Chapter 17 Templates and generic algorithms203

17.1 A specific example204

17.2 Generalizing the element type205

17.3 Postponing the count205

17.4 Address independence207

17.5 Searching a nonarray208

17.6 Discussion210

Chapter 18 Generic iterators213

18.1 A different algorithm213

18.2 Categories of requirements215

18.3 Input iterators216

18.4 Output iterators216

18.5 Forward iterators217

18.6 Bidirectional iterators218

18.7 Random-access iterators218

18.8 Inheritance?220

18.9 Performance220

18.10 Summary221

Chapter 19 Using generic iterators223

19.1 Iterator types224

19.2 Virtual sequences224

19.3 An output-stream iterator227

19.4 An input-stream iterator229

19.5 Discussion232

Chapter 20 Iterator adaptors233

20.1 An example233

20.2 Directional asymmetry235

20.3 Consistency and asymmetry236

20.4 Automatic reversal237

20.5 Discussion240

Chapter 21 Function objects241

21.1 An example241

21.2 Function pointers244

21.3 Function objects246

21.4 Function-object templates248

21.5 Hiding intermedlate types249

21.6 One type covers many250

21.7 Implementation251

21.8 Discussion253

Chapter 22 Function adaptors255

22.1 Why function objects?255

22.2 Function objects for built-in operators256

22.3 Binders257

22.4 A closer look258

22.5 Interface inheritance259

22.6 Using these classes260

22.7 Discussion261

Part Ⅳ Libraries263

Chapter 23 Libraries in everyday use265

23.1 The problem265

23.2 Understanding the problem—part 1267

23.3 Implementation—part 1267

23.4 Understanding the problem—part 2270

23.5 Implementation—part 2270

23.6 Discussion272

Chapter 24 An object lesson in library-interface design275

24.1 Complications276

24.2 Improving the interface277

24.3 Taking stock279

24.4 Writing the code280

24.5 Conclusion282

Chapter 25 Library design is language design283

25.1 Character strings283

25.2 Memory exhaustion284

25.3 Copying287

25.4 Hiding the implementation290

25.5 Default constructor292

25.6 Other operations293

25.7 Substrings295

25.8 Conclusion296

Chapter 26 Language design is library design297

26.1 Abstract data types297

26.2 Libraries and abstract data types299

26.3 Memory allocation302

26.4 Memberwise assignment and initialization303

26.5 Exception handling305

26.6 Summary306

Part Ⅴ Technique307

Chapter 27 Classes that keep track of themselves309

27.1 Design of a trace class309

27.2 Creating dead code312

27.3 Generating audit trails for objects313

27.4 Verifying container behavior315

27.5 Summary320

Chapter 28 Allocating objects in clusters321

28.1 The problem321

28.2 Designing the solution321

28.3 Implementation324

28.4 Enter inheritance326

28.5 Summary327

Chapter 29 Applicators,manipulators,and function objects329

29.1 The problem329

29.2 A solution332

29.4 Multiple arguments334

29.5 An example335

29.6 Abbreviations337

29.7 Musings338

29.8 Historical notes,references,and acknowledgments339

Chapter30 Decoupling application libraries from input-output341

30.1 The problem341

30.2 Solution 1:Trickery and brute force342

30.3 Solution 2:Abstract output343

30.4 Solution 3:Trickery without brute force345

30.5 Remarks348