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
鄂公網(wǎng)安備 42010302001612號(hào) 