C++沉思录（英文版）

chapter 0 prelude

0.1 first try

0.2 doing it without classes

0.3 why was it easier in c++?

0.4 a bigger example

0.5 conclusion

part i motivation

chapter 1 why i use c++

1.1 the problem

1.2 history and context

1.3 automatic software distribution

1.4 enter c++

1.5 recycled software

1.6 postscript

chapter 2 why i work on c++

2.1 the success of small projects

2.2 abstraction

2.3 machines should work for people

chapter 3 living in the real world

part ii classes and inheritance

chapter 4 checklist for class authors

chapter 5 surrogate classes

5.1 the problem

5.2 the classical solution

5.3 virtual copy functions

5.4 defining a surrogate class

5.5 summary

chapter 6 handles: part 1

6.1 the problem

6.2 a simple class

6.3 attaching a handle

6.4 getting at the object

6.5 simple implementation

6.6 use-counted handles

6.7 copy on write

6.8 discussion

chapter 7 handles: part 2

7.1 review

7.2 separating the use count

7.3 abstraction of use counts

7.4 access functions and copy on write

7.5 discussion

chapter 8 an object-oriented program

8.1 the problem

8.2 an object-oriented solution

8.3 handle classes

8.4 extension 1: new operations

8.5 extension 2: new node types

8.6 reflections

chapter 9 analysis of a classroom exercise: part 1

9.1 the problem

9.2 designing the interface

9.3 a few loose ends

9.4 testing the interface

9.5 strategy

9.6 tactics

9.7 combining pictures

9.8 conclusion

chapter 10 analysis of a classroom exercise: part 2

10.1 strategy

10.2 exploiting the structure

10.3 conclusion

chapter 11 when not to use virtual functions

11.1 the case for

11.2 the case against

11.3 destructors are special ,

11.4 summary

part iii templates

chapter 12 designing a container class

12.1 what does it contain?

12.2 what does copying the container mean?

12.3 how do you get at container elements?

12.4 how do you distinguish reading from writing?

12.5 how do you handle container growth?

12.6 what operations does the container provide?

12.7 what do you assume about the container element type?

12.8 containers and inheritance

12.9 designing an arraylike class

chapter 13 accessing container elements

13.1 imitating a pointer

13.2 getting at the data

13.3 remaining problems

13.4 pointer to const array

13.5 useful additions

chapter 14 iterators

14.1 completing the pointer class

14.2 what is an iterator?

14.3 deleting an element

14.4 deleting the container

14.5 other design considerations

14.6 discussion

chapter 15 sequences

15.1 the state of the art

15.2 a radical old idea

15.3 well, maybe a few extras...

15.4 example of use

15.5 maybe a few more...

15.6 food for thought

chapter 16 templates as interfaces

16.1 the problem

16.2 the first example

16.3 separating the iteration

16.4 iterating over arbitrary types

16.5 adding other types

16.6 abstracting the storage technique

16.7 the proof of the pudding

16.8 summary

chapter 17 templates and generic algorithms

17.1 a specificexample

17.2 generalizing the element type

17.3 postponing the count

17.4 address independence

17.5 searching a nonarray

17.6 discussion

chapter 18 generic iterators

18.1 a different algorithm

18.2 categories of requirements

18.3 input iterators

18.4 output iterators

18.5 forward iterators

18.6 bidirectional iterators

18.7 random-access iterators

18.8 inheritance?

18.9 performance

18.10 summary

chapter 19 using generic iterators

19.1 iterator types

19.2 virtual sequences

19.3 an output-stream iterator

19.4 an input-stream iterator

19.5 discussion

chapter 20 iterator adaptors

20.1 an example

20.2 directional asymmetry

20.3 consistency and asymmetry

20.4 automatic reversal

20.5 discussion

chapter 21 function objects

21.1 an example

21.2 function pointers

21.3 function objects

21.4 function-object templates

21.5 hiding intermediate types

21.6 one type covers many

21.7 implementation

21.8 discussion

chapter 22 function adaptors

22.1 why function objects?

22.2 function objects for built-in operators

22.3 binders

22.4 a closer look

22.5 interface inheritance

22.6 using these classes

22.7 discussion

part iv libraries

chapter 23 libraries in everyday use

23.1 the problem

23.2 understanding the problem--part 1

23.3 implementation—part 1

23.4 understanding the problem--part 2

23.5 implementation--part 2

23.6 discussion

chapter 24 an object lesson in library-interface design

24.1 complications

24.2 improving the interface

24.3 taking stock

24.4 writing the code

24.5 conclusion

chapter 25 library design is language design

25.1 character strings

25.2 memory exhaustion

25.3 copying

25.4 hiding the implementation

25.5 default constructor

25.6 other operations

25.7 substrings

25.8 conclusion

chapter 26 language design is library design

26.1 abstract data types

26.2 libraries and abstract data types

26.3 memory allocation

26.4 memberwise assignment and initialization

26.5 exception handling

26.6 summary

part v technique

chapter 27 classes that keep track of themselves

27.1 design of a trace class

27.2 creating dead code

27.3 generating audit trails for objects

27.4 verifying container behavior

27.5 summary

chapter 28 allocating objects in clusters

28.1 the problem

28.2 designing the solution

28.3 implementation

28.4 enter inheritance

28.5 summary

chapter 29 applicators, manipulators, and function objects

29.1 the problem

29.2 a solution

29.3 a different solution

29.4 multiple arguments

29.5 an example

29.6 abbreviations

29.7 musings

29.8 historical notes, references, and acknowledgments

chapter 30 decoupling application libraries from input-output

30.1 the problem

30.2 solution 1: trickery and brute force

30.3 solution 2: abstract output

30.4 solution 3: trickery without brute force

30.5 remarks

part vi wrapup

chapter 31 simplicity through complexity

31.1 the world is complicated

31.2 complexity becomes hidden

31.3 computers are no different

31.4 computers solve real problems

31.5 class libraries and language semantics

31.6 making things easy is hard

31.7 abstraction and interface

31.8 conservation of complexity

chapter 32 what do you do after you say rello world?

32.1 find the local experts

32.2 pick a tool kit and become comfortable with it

32.3 some parts of c are essential...

32.4 ... but others are not

32.5 set yourself a series of problems

32.6 conclusion

index