Thinking in C Volume 2 Practical Programming 1st Edition by Bruce Eckel ISBN ‎ 978-0130353139 0130353132

1. Preface

2. What’s new in the second edition

3. What’s in Volume 2 of this book

4. How to get Volume 2

5. Prerequisites

6. Learning C++

7. Goals

8. Chapters

9. Exercises

10. Exercise solutions

11. Source code

12. Language standards

13. Language support

14. The book’s CD ROM

15. Seminars, CD Roms & consulting

16. Errors

17. Acknowledgements

Part 1: The Standard C++ Library
18. Library overview
19. 1: Strings
20. What’s in a string
21. Creating and initializing C++ strings
22. Initialization limitations
23. Operating on strings
24. Appending, inserting and concatenating strings
25. Replacing string characters
26. Simple character replacement using the STL replace(€) algorithm
27. Concatenation using non-member overloaded operators
28. Searching in strings
29. Finding in reverse
30. Finding first/last of a set
31. Removing characters from strings
32. Stripping HTML tags
33. Comparing strings
34. Indexing with [ ] vs. at(€)
35. Using iterators
36. Iterating in reverse
37. Strings and character traits
38. A string application
39. Summary
40. Exercises
41. 2: Iostreams
42. Why iostreams?
43. True wrapping
44. Iostreams to the rescue
45. Sneak preview of operator overloading
46. Inserters and extractors
47. Manipulators
48. Common usage
49. Line-oriented input
50. Overloaded versions of get( )
51. Reading raw bytes
52. Error handling
53. File iostreams
54. Open modes
55. Iostream buffering
56. Using get(€) with a streambuf
57. Seeking in iostreams
58. Creating read/write files
59. stringstreams
60. strstreams
61. User-allocated storage
62. Output strstreams
63. Automatic storage allocation
64. Proving movement
65. A better way
66. Output stream formatting
67. Internal formatting data
68. Format fields
69. Width, fill and precision
70. An exhaustive example
71. Formatting manipulators
72. Manipulators with arguments
73. Creating manipulators
74. Effectors
75. Iostream examples
76. Code generation
77. Maintaining class library source
78. Detecting compiler errors
79. A simple datalogger
80. Generating test data
81. Verifying & viewing the data
82. Counting editor
83. Breaking up big files
84. Summary
85. Exercises
86. 3: Templates in depth
87. Nontype template arguments
88. Default template arguments
89. The typename keyword
90. Typedefing a typename
91. Using typename instead of class
92. Function templates
93. A string conversion system
94. A memory allocation system
95. Type induction in function templates
96. Taking the address of a generated function template
97. Local classes in templates
98. Applying a function to an STL sequence
99. Template-templates
100. Member function templates
101. Why virtual member template functions are disallowed
102. Nested template classes
103. Template specializations
104. Full specialization
105. Partial Specialization
106. A practical example
107. Pointer specialization
108. Partial ordering of function templates
109. Design & efficiency
110. Preventing template bloat
111. Explicit instantiation
112. Explicit specification of template functions
113. Controlling template instantiation
114. The inclusion vs. separation models
115. The export keyword
116. Template programming idioms
117. The “curiously-recurring template”
118. Traits
119. Summary

4: STL Containers & Iterators
120. Containers and iterators
121. STL reference documentation
122. The Standard Template Library
123. The basic concepts
124. Containers of strings
125. Inheriting from STL containers
126. A plethora of iterators
127. Iterators in reversible containers
128. Iterator categories
129. Input: read-only, one pass
130. Output: write-only, one pass
131. Forward: multiple read/write
132. Bidirectional: operator–
133. Random-access: like a pointer
134. Is this really important?
135. Predefined iterators
136. IO stream iterators
137. Manipulating raw storage
138. Basic sequences: vector, list & deque
139. Basic sequence operations
140. vector
141. Cost of overflowing allocated storage
142. Inserting and erasing elements
143. deque
144. Converting between sequences
145. Cost of overflowing allocated storage
146. Checked random-access
147. list
148. Special list operations
149. list vs. set
150. Swapping all basic sequences
151. Robustness of lists
152. Performance comparison
153. set
154. Eliminating strtok(€)
155. StreamTokenizer: a more flexible solution
156. A completely reusable tokenizer
157. stack
158. queue
159. Priority queues
160. Holding bits
161. bitset
162. vector
163. Associative containers
164. Generators and fillers for associative containers
165. The magic of maps
166. A command-line argument tool
167. Multimaps and duplicate keys
168. Multisets
169. Combining STL containers
170. Cleaning up containers of pointers
171. Creating your own containers
172. Freely-available STL extensions
173. Summary
174. Exercises

5: STL Algorithms
175. Function objects
176. Classification of function objects
177. Automatic creation of function objects
178. Binders
179. Function pointer adapters
180. SGI extensions
181. A catalog of STL algorithms
182. Support tools for example creation
183. Filling & generating
184. Example
185. Counting
186. Example
187. Manipulating sequences
188. Example
189. Searching & replacing
190. Example
191. Comparing ranges
192. Example
193. Removing elements
194. Example
195. Sorting and operations on sorted ranges
196. Sorting
197. Example
198. Locating elements in sorted ranges
199. Example
200. Merging sorted ranges
201. Example
202. Set operations on sorted ranges
203. Example
204. Heap operations
205. Applying an operation to each element in a range
206. Examples
207. Numeric algorithms
208. Example
209. General utilities
210. Creating your own STL-style algorithms
211. Summary
212. Exercises

Part 2: Advanced Topics
213. 6: Multiple inheritance
214. Perspective
215. Duplicate subobjects
216. Ambiguous upcasting
217. virtual base classes
218. The “most derived” class and virtual base initialization
219. “Tying off” virtual bases with a default constructor
220. Overhead
221. Upcasting
222. Persistence
223. MI-based persistence
224. Improved persistence
225. Avoiding MI
226. Mixin types
227. Repairing an interface
228. Summary
229. Exercises

230. 7: Exception handling

231. Error handling in C

232. Throwing an exception

233. Catching an exception

234. The try block

235. Exception handlers

236. Termination vs. resumption

237. The exception specification

238. unexpected(€)

239. **set_unexpected