Programming 版 (精华区)

发信人: JJason (UFO), 信区: Programming
标  题: C++ 沉思录：目录
发信站: 哈工大紫丁香 (2002年11月15日18:33:46 星期五), 站内信件

        Ruminations on C++

by Andrew Koenig 
Addison-Wesley, 1997 
ISBN 0-201-42339-1 

Contents

Preface 

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 specific example 
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 Hello 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 
--

     人生，就是一团欲望：
     欲望没有满足的时候就是痛苦，
     欲望被满足的时候就是无聊；
     人生就是在痛苦与无聊之间徘徊。

※ 来源:·哈工大紫丁香 bbs.hit.edu.cn·[FROM: 202.118.229.69]