"Thinking In C++. Volume 2: Practical Programming" - читать интересную книгу автора (Eckel Bruce, Allison Chuck)
Thinking In C++. Volume 2: Practical Programming Preface Goals Chapters Exercises Exercise solutions Source code Language standards Language support Seminars, CD-ROMs amp; consulting Errors About the cover Acknowledgements Part 1.Building Stable Systems 1: Exception handling Traditional error handling Throwing an exception Catching an exception The try block Exception handlers Exception matching Catching any exception Re-throwing an exception Uncaught exceptions The terminate( ) function The set_terminate( ) function Cleaning up Resource management Making everything an object auto_ptr Function-level try blocks Standard exceptions Exception specifications The unexpected( ) function The set_unexpected( ) function Better exception specifications? Exception specifications and inheritance When not to use exception specifications Exception safety Programming with exceptions When to avoid exceptions Not for asynchronous events Not for benign error conditions Not for flow-of-control You’re not forced to use exceptions New exceptions, old code Typical uses of exceptions When to use exception specifications Start with standard exceptions Nest your own exceptions Use exception hierarchies Multiple inheritance (MI) Catch by reference, not by value Throw exceptions in constructors Don’t cause exceptions in destructors Avoid naked pointers Overhead Summary Exercises 2: Defensive programming Assertions A simple unit test framework Automated testing The TestSuite Framework Test suites The test framework code Debugging techniques Trace macros Trace file Finding memory leaks Tracking new/delete and malloc/free Summary Exercises Part 2.The Standard C++ Library 3: Strings in depth What’s in a string? Creating and initializing C++ strings Operating on strings Appending, inserting, and concatenating strings Replacing string characters Concatenation using nonmember overloaded operators Searching in strings Finding in reverse Finding first/last of a set of characters Removing characters from strings Comparing strings Strings and character traits A string application Summary Exercises 4: Iostreams Why iostreams? Iostreams to the rescue Inserters and extractors Common usage Line-oriented input Overloaded versions of get( ) Reading raw bytes Handling stream errors Stream state Streams and exceptions File iostreams A File-Processing Example Open modes Iostream buffering Seeking in iostreams String iostreams Input string streams Output string streams Output stream formatting Format flags Format fields Width, fill, and precision An exhaustive example Manipulators Manipulators with arguments Creating manipulators Effectors Iostream examples Maintaining class library source code Detecting compiler errors A simple data logger Generating test data Verifying and viewing the data Internationalization Wide Streams Locales Summary Exercises 5: Templates in depth Template parameters Non-type template parameters Default template arguments Template template parameters The typename keyword Typedef-ing a typename Using typename instead of class Using the template keyword as a hint Member Templates Function template issues Type deduction of function template arguments Function template overloading Taking the address of a generated function template Applying a function to an STL sequence Partial ordering of function templates Template specialization Explicit specialization Partial Specialization Partial ordering of class templates A practical example Preventing template code bloat Name lookup issues Names in templates Templates and friends Friend templates Template programming idioms Traits Policies The curiously recurring template pattern Template metaprogramming Compile-time programming Compile-time looping Loop unrolling Compile-time selection Compile-time assertions Expression templates Template compilation models The inclusion model Explicit instantiation The separation model Summary Exercises 6: Generic algorithms A first look Predicates Stream iterators Algorithm complexity Function objects Classification of function objects Automatic creation of function objects Adaptable function objects More function object examples Function pointer adapters Writing your own function object adapters A catalog of STL algorithms Support tools for example creation Filling and generating Example Counting Example Manipulating sequences Example Searching and replacing Example Comparing ranges Example Removing elements Example Sorting and operations on sorted ranges Sorting Locating elements in sorted ranges Example Merging sorted ranges Example Set operations on sorted ranges Example Heap operations Applying an operation to each element in a range Examples Numeric algorithms Example General utilities Creating your own STL-style algorithms Summary Exercises 7: Generic containers Containers and iterators STL reference documentation A first look Containers of strings Inheriting from STL containers A plethora of iterators Iterators in reversible containers Iterator categories Input: read-only, one pass Output: write-only, one pass Forward: multiple read/write Bidirectional: operator-- Random-access: like a pointer Is this really important? Predefined iterators More on stream iterators Manipulating raw storage The basic sequences: vector, list, deque Basic sequence operations vector Cost of overflowing allocated storage Inserting and erasing elements deque Converting between sequences Cost of overflowing allocated storage Checked random-access list Special list operations list vs. set Swapping basic sequences set A completely reusable tokenizer stack queue Priority queues Holding bits bitsetlt;ngt; vectorlt;boolgt; Associative containers Generators and fillers for associative containers The magic of maps Multimaps and duplicate keys Multisets Combining STL containers Cleaning up containers of pointers Creating your own containers STL extensions Non-STL containers Summary Exercises Part 3: Special Topics 8: Runtime type identification Runtime casts The typeid operator Casting to intermediate levels void pointers Using RTTI with templates Multiple inheritance Sensible uses for RTTI A trash recycler Mechanism and overhead of RTTI Summary Exercises 9: Multiple inheritance Perspective Interface inheritance Implementation inheritance Duplicate subobjects Virtual base classes Name lookup issues Avoiding MI Extending an interface Summary Exercises 10: Design patterns The pattern concept The Singleton Variations on Singleton Classifying patterns Features, idioms, patterns Building complex objects Factories: encapsulating object creation Polymorphic factories Abstract factories Virtual constructors Destructor operation Observer The "inner class" idiom The observer example Multiple dispatching Multiple dispatching with Visitor Exercises 11: Concurrency Motivation Concurrency in C++ Installing ZThreads Defining Tasks Using Threads Creating responsive user interfaces Simplifying with Executors Yielding Sleeping Priority Sharing limited resources Ensuring the existence of objects Improperly accessing resources Controlling access Simplified coding with Guards Synchronizing entire classes Thread local storage Terminating tasks Preventing iostream collision The ornamental garden Atomic operations Terminating when blocked Thread states Becoming blocked Interruption Blocked by a mutex Checking for an interrupt Cooperation between threads Wait and signal Producer-consumer relationships Solving threading problems with queues Proper toasting Broadcast Deadlock Summary Exercises A: Recommended reading General C++ Bruce’s books Chuck’s books In-depth C++ Design Patterns B: Etc Index Notes 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
Exercises We have discovered that simple exercises are exceptionally useful during a seminar to complete a student’s understanding, so you’ll find a set at the end of each chapter.
These are fairly simple, so they can be finished in a reasonable amount of time in a classroom situation while the instructor observes, making sure all the students are absorbing the material. Some exercises are a bit more challenging to keep advanced students entertained. They’re all designed to be solved in a short time and are only there to test and polish your knowledge rather than present major challenges (presumably, you’ll find those on your own—or more likely they’ll find you).