与大师面对面（译序）
序
前言
泛型程序设计与C++标准库
　条款1：流
　条款2：Predicates，之一：remove()删除了什么?
　条款3：Predicates，之二：状态带来的问题
　条款4：可扩充的模板：使用继承还是traits?
　条款5：typename
　条款6：容器、指针和“不是容器的容器”
　条款7：使用vector和deque
　条款8：使用set和map
　条款9：等同的代码吗?
　条款10：模板特殊化与重载
　条款11：Mastermind
优化与性能
　条款12：内联
　条款13：缓式优化，之一：一个普通的旧式String
　条款14：缓式优化，之二：引入缓式优化
　条款15：缓式优化，之三：迭代器与引用
　条款16：缓式优化，之四：多线程环境
异常安全议题及技术
　条款17：构造函数失败，之一：对象生命期
　条款18：构造函数失败，之二：吸收异常?
　条款19：未捕获的异常
　条款20：未管理指针存在的问题，之一：参数求值
　条款21：未管理指针存在的问题，之二：使用auto~tr7
　条款22：异常安全与类的设计，之一：复制赋值
　条款23：异常安全与类的设计，之二：继承
继承与多态
　条款24：为什么要使用多继承?
　条款25：模拟多继承
　条款26：多继承与连体双婴问题
　条款27： (非)纯虚函数
　条款28：受控的多态
内存及资源管理
　条款29：使用auto_ptr
　条款30：智能指针成员，之一：auto_ptr存在的问题
　条款31：智能指针成员，之二：设计Va1uePtr
自由函数与宏
　条款32：递归声明
　条款33：模拟嵌套函数
　条款34：预处理宏
　条款35：宏定义
杂项议题
　条款36：初始化
　条款37：前置声明
　条款38：typedef
　条款39：名字空间，之一：using声明和using指令
　条款40：名字空间，之二：迁徙到名字空间
后记
参考文献
索引

Preface
Acknowledgments 

 1 About this Book 1.1 Why this Book 1.2 What You Should Know Before Reading this Book 1.3 Style and Structure of the Book 1.4 How to Read this Book 1.5 State of the Art 1.6 Example Code and Additional Information 1.7 Feedback

 2 Introduction to C++ and the Standard Library 2.1 History 2.2 New Language Features 2.2.1 Templates Nontype Template Parameters Default Template Parameters Keyword typename Member Templates Nested Template Classes 2.2.2 Explicit Initialization for Fundamental Types 2.2.3 Exception Handling 2.2.4 Namespaces 2.2.5 Type bool 2.2.6 Keyword explicit 2.2.7 New Operators for Type Conversion 2.2.8 Initialization of Constant Static Members 2.2.9 Definition of main() 2.3 Complexity and the Big-O Notation

 3 General Concepts 3.1 Namespace std 3.2 Header Files 3.3 Error and Exception Handling 3.3.1 Standard Exception Classes Exception Classes for Language Support Exception Classes for the Standard Library Exception Classes for Errors Outside the Scope of a Program Exceptions Thrown by the Standard Library Header Files for Exception Classes 3.3.2 Members of Exception Classes 3.3.3 Throwing Standard Exceptions 3.3.4 Deriving Standard Exception Classes 3.4 Allocators

 4 Utilities 4.1 Pairs Pair Comparisons 4.1.1 Convenience Function make_pair() 4.1.2 Examples of Pair Usage 4.2 Class auto_ptr 4.2.1 Motivation of Class auto_ptr 4.2.2 Transfer of Ownership by auto_ptr Source and Sink Caveat 4.2.3 auto_ptrs as Members 4.2.4 Misusing auto_ptrs 4.2.5 auto_ptr Examples 4.2.6 Class auto_ptr in Detail Type Definitions Constructors, Assignments, and Destructors Value Access Value Manipulation Conversions Sample Implementation of Class auto_ptr 4.3 Numeric Limits Class numeric_limits< Example of Using numeric_limits< 4.4 Auxiliary Functions 4.4.1 Processing the Minimum and Maximum 4.4.2 Swapping Two Values 4.5 Supplementary Comparison Operators 4.6 Header Files 4.6.1 Definitions in 4.6.2 Definitions in

 5 The Standard Template Library 5.1 STL Components 5.2 Containers 5.2.1 Sequence Containers Vectors Deques Lists Strings Ordinary Arrays 5.2.2 Associative Containers 5.2.3 Container Adapters 5.3 Iterators 5.3.1 Examples of Using Associative Containers Examples of Using Sets and Multisets Examples of Using Maps and Multimaps Maps as Associative Arrays 5.3.2 Iterator Categories 5.4 Algorithms 5.4.1 Ranges 5.4.2 Handling Multiple Ranges 5.5 Iterator Adapters 5.5.1 Insert Iterators 5.5.2 Stream Iterators 5.5.3 Reverse Iterators 5.6 Manipulating Algorithms 5.6.1 “Removing” Elements 5.6.2 Manipulating Algorithms and Associative Containers 5.6.3 Algorithms versus Member Functions 5.7 User-Defined Generic Functions 5.8 Functions as Algorithm Arguments 5.8.1 Examples of Using Functions as Algorithm Arguments 5.8.2 Predicates Unary Predicates Binary Predicates 5.9 Function Objects 5.9.1 What Are Function Objects? 5.9.2 Predefined Function Objects 5.10 Container Elements 5.10.1 Requirements for Container Elements 5.10.2 Value Semantics or Reference Semantics 5.11 Errors and Exceptions Inside the STL 5.11.1 Error Handling 5.11.2 Exception Handling 5.12 Extending the STL

 6 STL Containers 6.1 Common Container Abilities and Operations 6.1.1 Common Container Abilities 6.1.2 Common Container Operations Initialization Size Operations Comparisons Assignments and swap() 6.2 Vectors 6.2.1 Abilities of Vectors Size and Capacity 6.2.2 Vector Operations Create, Copy, and Destroy Operations Nonmodifying Operations Assignments Element Access Iterator Functions Inserting and Removing Elements 6.2.3 Using Vectors as Ordinary Arrays 6.2.4 Exception Handling 6.2.5 Examples of Using Vectors 6.2.6 Class vector 6.3 Deques 6.3.1 Abilities of Deques 6.3.2 Deque Operations 6.3.3 Exception Handling 6.3.4 Examples of Using Deques 6.4 Lists 6.4.1 Abilities of Lists 6.4.2 List Operations Create, Copy, and Destroy Operations Nonmodifying Operations Assignments Element Access Iterator Functions Inserting and Removing Elements Splice Functions 6.4.3 Exception Handling 6.4.4 Examples of Using Lists 6.5 Sets and Multisets 6.5.1 Abilities of Sets and Multisets 6.5.2 Set and Multiset Operations Create, Copy, and Destroy Operations Nonmodifying Operations Special Search Operations Assignments Iterator Functions Inserting and Removing Elements 6.5.3 Exception Handling 6.5.4 Examples of Using Sets and Multisets 6.5.5 Example of Specifying the Sorting Criterion at Runtime 6.6 Maps and Multimaps 6.6.1 Abilities of Maps and Multimaps 6.6.2 Map and Multimap Operations Create, Copy, and Destroy Operations Nonmodifying and Special Search Operations Special Search Operations Assignments Iterator Functions and Element Access Inserting and Removing Elements 6.6.3 Using Maps as Associative Arrays 6.6.4 Exception Handling 6.6.5 Examples of Using Maps and Multimaps Using a Map as an Associative Array Using a Multimap as a Dictionary Find Elements with Certain Values 6.6.6 Example with Maps, Strings, and Sorting Criterion at Runtime 6.7 Other STL Containers 6.7.1 Strings as STL Containers 6.7.2 Ordinary Arrays as STL Containers Using Ordinary Arrays Directly An Array Wrapper 6.7.3 Hash Tables 6.8 Implementing Reference Semantics 6.9 When to Use which Container 6.10 Container Types and Members in Detail 6.10.1 Type Definitions 6.10.2 Create, Copy, and Destroy Operations 6.10.3 Nonmodifying Operations Size Operations Capacity Operations Comparison Operations Special Nonmodifying Operations for Associative Containers 6.10.4 Assignments 6.10.5 Direct Element Access 6.10.6 Operations to Generate Iterators 6.10.7 Inserting and Removing Elements 6.10.8 Special Member Functions for Lists 6.10.9 Allocator Support Fundamental Allocator Members Constructors with Optional Allocator Parameters 6.10.10 Overview of Exception Handling in STL Containers

 7 STL Iterators 7.1 Header Files for Iterators 7.2 Iterator Categories 7.2.1 Input Iterators 7.2.2 Output Iterators 7.2.3 Forward Iterators 7.2.4 Bidirectional\Iterational discretionary Iterators 7.2.5 Random Access Iterational discretionary Iteratorstors 7.2.6 The Increment and Decrement Problem of Vector Iterators 7.3 Auxiliary Iterator Functions 7.3.1 Stepping Iterators Using advance() 7.3.2 Processing Iterator Distance Using distance() 7.3.3 Swapping Iterator Values Using iter_swap() 7.4 Iterator Adapters 7.4.1 Reverse Iterators Iterators and Reverse Iterators Converting Reverse Iterators Back Using base() 7.4.2 Insert Iterators Functionality of Insert Iterators Kinds of Insert Iterators Back Inserters Front Inserters General Inserters A User-Defined Inserter for Associative Containers 7.4.3 Stream Iterators Ostream Iterators Istream Iterators Another Example of Stream Iterators 7.5 Iterator Traits 7.5.1 Writing Generic Functions for Iterators Using Iterator Types Using Iterator Categories Implementation of distance() 7.5.2 User-Defined Iterators

 8 STL Function Objects 8.1 The Concept of Function Objects 8.1.1 Function Objects as Sorting Criteria 8.1.2 Function Objects with Internal State 8.1.3 The Return Value of for_each() 8.1.4 Predicates versus Function Objects 8.2 Predefined Function Objects 8.2.1 Function Adapters 8.2.2 Function Adapters for Member Functions 8.2.3 Function Adapters for Ordinary Functions 8.2.4 User-Defined Function Objects for Function Adapters 8.3 Supplementary Composing Function Objects 8.3.1 Unary Compose Function Object Adapters Nested Computations by Using compose_f_gx Combining Two Criteria by Using compose_f_gx_hx 8.3.2 Binary Compose Function Object Adapters

 9 STL Algorithms 9.1 Algorithm Header Files 9.2 Algorithm Overview 9.2.1 A Brief Introduction 9.2.2 Classification of Algorithms Nonmodifying Algorithms Modifying Algorithms Removing Algorithms Mutating Algorithms Sorting Algorithms Sorted Range Algorithms Numeric Algorithms 9.3 Auxiliary Functions 9.4 The for_each() Algorithm 9.5 Nonmodifying Algorithms 9.5.1 Counting Elements 9.5.2 Minimum and Maximum 9.5.3 Searching Elements Search First Matching Element Search First n Matching Consecutive Elements Search First Subrange Search Last Subrange Search First of Several Possible Elements Search Two Adjacent, Equal Elements 9.5.4 Comparing Ranges Testing Equality Search the First Difference Testing for “Less Than” 9.6 Modifying Algorithms 9.6.1 Copying Elements 9.6.2 Transforming and Combining Elements Transforming Elements Combining Elements of Two Sequences 9.6.3 Swapping Elements 9.6.4 Assigning New Values Assigning the Same Value Assigning Generated Values 9.6.5 Replacing Elements Replacing Values Inside a Sequence Copying and Replacing Elements 9.7 Removing Algorithms 9.7.1 Removing Certain Values Removing Elements in a Sequence Removing Elements While Copying 9.7.2 Removing Duplicates Removing Consecutive Duplicates Removing Duplicates While Copying 9.8 Mutating Algorithms 9.8.1 Reversing the Order of Elements 9.8.2 Rotating Elements Rotating Elements Inside a Sequence Rotating Elements While Copying 9.8.3 Permuting Elements 9.8.4 Shuffling Elements 9.8.5 Moving Elements to the Front 9.9 Sorting Algorithms 9.9.1 Sorting All Elements 9.9.2 Partial Sorting 9.9.3 Sorting According to the nth Element 9.9.4 Heap Algorithms Heap Algorithms in Detail Example Using Heaps 9.10 Sorted Range Algorithms 9.10.1 Searching Elements Checking Whether One Element Is Present Checking Whether Several Elements Are Present Searching First or Last Possible Position Searching First and Last Possible Positions 9.10.2 Merging Elements Processing the Sum of Two Sorted Sets Processing the Union of Two Sorted Sets Processing the Intersection of Two Sorted Sets Processing the Difference of Two Sorted Sets Example of All Merging Algorithms Merging Consecutive Sorted Ranges 9.11 Numeric Algorithms 9.11.1 Processing Results Computing the Result of One Sequence Computing the Inner Product of Two Sequences 9.11.2 Converting Relative and Absolute Values Converting Relative Values into Absolute Values Converting Absolute Values into Relative Values Example of Converting Relative Values into Absolute Values

 10 Special Containers 10.1 Stacks 10.1.1 The Core Interface 10.1.2 Example of Using Stacks 10.1.3 Class stack Type Definitions Operations 10.1.4 A User-Defined Stack Class 10.2 Queues 10.2.1 The Core Interface 10.2.2 Example of Using Queues 10.2.3 Class queue Type Definitions Operations 10.2.4 A User-Defined Queue Class 10.3 Priority Queues 10.3.1 The Core Interface 10.3.2 Example of Using Priority Queues 10.3.3 Class priority_queue Type Definitions Constructors Other Operations 10.4 Bitsets 10.4.1 Examples of Using Bitsets Using Bitsets as Set of Flags Using Bitsets for I/O with Binary Representation 10.4.2 Class bitset in Detail Create, Copy, and Destroy Operations Nonmanipulating Operations Manipulating Operations Access with Operator _hspace *] Creating New Modified Bitsets Operations for Type Conversions Input/Output Operations

 11 Strings 11.1 Motivation 11.1.1 A First Example: Extracting a Temporary File Name 11.1.2 A Second Example: Extracting Words and Printing Them Backward 11.2 Description of the String Classes 11.2.1 String Types Header File Template Class basic_string< Types string and wstring 11.2.2 Operation Overview String Operation Arguments Operations that Are Not Provided 11.2.3 Constructors and Destructors 11.2.4 Strings and C-Strings 11.2.5 Size and Capacity 11.2.6 Element Access 11.2.7 Comparisons 11.2.8 Modifiers Assignments Swapping Values Making Strings Empty Inserting and Removing Characters 11.2.9 Substrings and String Concatenation 11.2.10 Input/Output Operators 11.2.11 Searching and Finding 11.2.12 The Value npos 11.2.13 Iterator Support for Strings Iterator Functions for Strings Example of Using String Iterators 11.2.14 Internationalization 11.2.15 Performance 11.2.16 Strings and Vectors 11.3 String Class in Detail 11.3.1 Type Definitions and Static Values 11.3.2 Create, Copy, and Destroy Operations 11.3.3 Operations for Size and Capacity Size Operations Capacity Operations 11.3.4 Comparisons 11.3.5 Character Access 11.3.6 Generating C-Strings and Character Arrays 11.3.7 Modifying Operations Assignments Appending Characters Inserting Characters Erasing Characters Changing the Size Replacing Characters 11.3.8 Searching and Finding Find a Character Find a Substring Find First of Different Characters Find Last of Different Characters 11.3.9 Substrings and String Concatenation 11.3.10 Input/Output Functions 11.3.11 Generating Iterators 11.3.12 Allocator Support

 12 Numerics 12.1 Complex Numbers 12.1.1 Examples Using Class Complex 12.1.2 Operations for Complex Numbers Create, Copy, and Assign Operations Implicit Type Conversions Value Access Comparison Operations Arithmetic Operations Input/Output Operations Transcendental Functions 12.1.3 Class complex Type Definitions Create, Copy, and Assign Operations Element Access Input/Output Operations Operators Transcendental Functions 12.2 Valarrays 12.2.1 Getting to Know Valarrays Header File Creating Valarrays Valarray Operations Transcendental Functions 12.2.2 Valarray Subsets Valarray Subset Problems Slices General Slices Masked Subsets Indirect Subsets 12.2.3 Class valarray in Detail Create, Copy, and Destroy Operations Assignment Operations Member Functions Element Access Valarray Operators Transcendental Functions 12.2.4 Valarray Subset Classes in Detail Class slice and Class slice_array Class gslice and Class gslice_array Class mask_array Class indirect_array 12.3 Global Numeric Functions

 13 Input/Output Using Stream Classes Recent Changes in the IOStream Library 13.1 Common Background of I/O Streams 13.1.1 Stream Objects 13.1.2 Stream Classes 13.1.3 Global Stream Objects 13.1.4 Stream Operators 13.1.5 Manipulators 13.1.6 A Simple Example 13.2 Fundamental Stream Classes and Objects 13.2.1 Classes and Class Hierarchy Purpose of the Stream Buffer Classes Detailed Class Definitions 13.2.2 Global Stream Objects 13.2.3 Header Files 13.3 Standard Stream Operators << and 13.3.1 Output Operator << 13.3.2 Input Operator 13.3.3 Input/Output of Special Types Type bool Types char and wchar_t Type char Type void Stream Buffers User-Defined Types 13.4 State of Streams 13.4.1 Constants for the State of Streams 13.4.2 Member Functions Accessing the State of Streams 13.4.3 Stream State and Boolean Conditions 13.4.4 Stream State and Exceptions 13.5 Standard Input/Output Functions 13.5.1 Member Functions for Input 13.5.2 Member Functions for Output 13.5.3 Example Uses 13.6 Manipulators 13.6.1 How Manipulators Work 13.6.2 User-Defined Manipulators 13.7 Formatting 13.7.1 Format Flags 13.7.2 Input/Output Format of Boolean Values 13.7.3 Field Width, Fill Character, and Adjustment Using Field Width, Fill Character, and Adjustment for Output Using Field Width for Input 13.7.4 Positive Sign and Uppercase Letters 13.7.5 Numeric Base 13.7.6 Floating-Point Notation 13.7.7 General Formatting Definitions 13.8 Internationalization 13.9 File Access 13.9.1 File Flags 13.9.2 Random Access 13.9.3 Using File Descriptors 13.10 Connecting Input and Output Streams 13.10.1 Loose Coupling Using tie() 13.10.2 Tight Coupling Using Stream Buffers 13.10.3 Redirecting Standard Streams 13.10.4 Streams for Reading and Writing 13.11 Stream Classes for Strings 13.11.1 String Stream Classes 13.11.2 char* Stream Classes 13.12 Input/Output Operators for User-Defined Types 13.12.1 Implementing Output Operators 13.12.2 Implementing Input Operators 13.12.3 Input/Output Using Auxiliary Functions 13.12.4 User-Defined Operators Using Unformatted Functions 13.12.5 User-Defined Format Flags 13.12.6 Conventions for User-Defined Input/Output Operators 13.13 The Stream Buffer Classes 13.13.1 User’s View of Stream Buffers 13.13.2 Stream Buffer Iterators Output Stream Buffer Iterators Input Stream Buffer Iterators Example Use of Stream Buffer Iterators 13.13.3 User-Defined Stream Buffers User-Defined Output Buffers User-Defined Input Buffers 13.14 Performance Issues 13.14.1 Synchronization with C’s Standard Streams 13.14.2 Buffering in Stream Buffers 13.14.3 Using Stream Buffers Directly

 14 Internationalization 14.1 Different Character Encodings 14.1.1 Wide-Character and Multibyte Text 14.1.2 Character Traits 14.1.3 Internationalization of Special Characters 14.2 The Concept of Locales 14.2.1 Using Locales 14.2.2 Locale Facets 14.3 Locales in Detail 14.4 Facets in Detail 14.4.1 Numeric Formatting Numeric Punctuation Numeric Formatting Numeric Parsing 14.4.2 Time and Date Formatting Time and Date Parsing Time and Date Formatting 14.4.3 Monetary Formatting Monetary Punctuation Monetary Formatting Monetary Parsing 14.4.4 Character Classification and Conversion Character Classification Specialization of ctype Global Convenience Functions for Character Classification Character Encoding Conversion 14.4.5 String Collation 14.4.6 Internationalized Messages

 15 Allocators 15.1 Using Allocators as an Application Programmer 15.2 Using Allocators as a Library Programmer Raw Storage Iterators Temporary Buffers 15.3 The Default Allocator 15.4 A User-Defined Allocator 15.5 Allocators in Detail 15.5.1 Type Definitions 15.5.2 Operations 15.6 Utilities for Uninitialized Memory in Detail

 Internet Resources Bibliography Index

Preface
13
What’s new in the second edition13
What’s in Volume 2 of this book ……14
How to get Volume 2 ……………………14
Prerequisites…………………………. 14
Learning C++……………………….. 14
Goals …………………………………… 16
Chapters ………………………………. 17
Exercises ……………………………… 18
Exercise solutions ………………………..18
Source code………………………….. 18
Language standards……………….. 20
Language support…………………………20
The book’s CD ROM …………….. 20
Seminars, CD Roms & consulting20
Errors ………………………………….. 21
Acknowledgements……………….. 21
Part 1: The Standard C++ Library
23
Library overview…………………… 24
1: Strings
27
What’s in a string ………………….. 27
Creating and initializing C++ strings 29
Operating on strings………………. 31
Appending, inserting and concatenating strings
32
Replacing string characters ……………34
Concatenation using non-member overloaded operators
Searching in strings……………….. 38
Finding in reverse…………………………43
Finding first/last of a set………………..44
Removing characters from strings…..45
Comparing strings ………………………..49
Using iterators……………………………..53
37
Strings and character traits …………….55
A string application……………….. 58
Summary……………………………… 61
Exercises ……………………………… 62
2: Iostreams
63
Why iostreams?…………………….. 63
True wrapping……………………………..65
Iostreams to the rescue…………… 67
Sneak preview of operator overloading68
Inserters and extractors …………………69
Common usage…………………………….70
Line-oriented input……………………….72
File iostreams……………………….. 74
Open modes ………………………………..76
Iostream buffering…………………. 76
Using get( ) with a streambuf…………78
Seeking in iostreams ……………… 78
Creating read/write files ………………..80
stringstreams ………………………… 81
strstreams …………………………….. 81
User-allocated storage…………………..81
Automatic storage allocation………….84
Output stream formatting ……….. 87
Internal formatting data…………………88
An exhaustive example …………………92
Formatting manipulators………… 95
Manipulators with arguments…………96
Creating manipulators……………. 99
Effectors……………………………………100
Iostream examples ………………. 102
Code generation …………………………102
A simple datalogger ……………………110
Counting editor ………………………….117
Breaking up big files …………………..118
Summary……………………………. 120
Exercises ……………………………. 120
3: Templates in depth
121
Nontype template arguments … 121
Default template arguments ….. 122
The typename keyword………… 122
Typedefing a typename ……………….124
Using typename instead of class ….124
Function templates ………………. 124
A string conversion system ………….125
A memory allocation system………..126
Type induction in function templates
129
Taking the address of a generated function template
Chapter 2: Hiding the Implementation
130
7
Local classes in templates …….. 131
Applying a function to an STL sequence
Template-templates ……………… 134
Member function templates ….. 135
131
Why virtual member template functions are disallowed
Nested template classes……………….137
137
Template specializations ………. 137
Full specialization ………………………137
Partial Specialization…………………..137
A practical example ……………………137
Design & efficiency ……………………141
Preventing template bloat…………….141
Explicit instantiation ……………. 143
Explicit specification of template functions
144
Controlling template instantiation144
The inclusion vs. separation models145
The export keyword ……………………145
Template programming idioms 145
The “curiously-recurring template”.145
Traits………………………………………..145
Summary……………………………. 145
4: STL Containers & Iterators147
Containers and iterators ……….. 147
STL reference documentation ………149
The Standard Template Library 149
The basic concepts ………………. 151
Containers of strings ……………. 155
Inheriting from STL containers 157
A plethora of iterators ………….. 159
Iterators in reversible containers …..161
Iterator categories……………………….162
Predefined iterators …………………….163
Basic sequences: vector, list & deque
169
Basic sequence operations……………169
vector ………………………………… 172
Cost of overflowing allocated storage173
Inserting and erasing elements ……..177
deque…………………………………. 179
Converting between sequences …….181
Cost of overflowing allocated storage182
Checked random-access ………………184
list …………………………………….. 185
Special list operations …………………187
Swapping all basic sequences……….191
Robustness of lists………………………192
Performance comparison ……… 193
set……………………………………… 198
Eliminating strtok( ) …………………..199
StreamTokenizer: a more flexible solution
Chapter 2: Hiding the Implementation
201
8
A completely reusable tokenizer …..203
stack ………………………………….. 208
queue…………………………………. 211
Priority queues ……………………. 216
Holding bits………………………… 226
bitset ………………………………….226 vector…………………………….230 Associative containers …………. 232 Generators and fillers for associative containers The magic of maps……………………..239 Multimaps and duplicate keys ………244 Multisets …………………………………..247 236 Combining STL containers …… 250 Cleaning up containers of pointers253 Creating your own containers .. 255 Freely-available STL extensions257 Summary……………………………. 259 Exercises ……………………………. 260 5: STL Algorithms 263 Function objects………………….. 263 Classification of function objects ….264 Automatic creation of function objects265 SGI extensions …………………………..279 A catalog of STL algorithms…. 285 Support tools for example creation..287 Filling & generating ……………………291 Counting …………………………………..293 Manipulating sequences ………………294 Searching & replacing…………………299 Comparing ranges ………………………305 Removing elements…………………….308 Sorting and operations on sorted ranges311 Heap operations …………………………322 Applying an operation to each element in a range 323 Numeric algorithms…………………….331 General utilities………………………….334 Creating your own STL-style algorithms Summary……………………………. 337 Exercises ……………………………. 337 Part 2: Advanced Topics 341 6: Multiple inheritance 336 342 Perspective …………………………. 342 Duplicate subobjects ……………. 344 Ambiguous upcasting…………… 345 virtual base classes……………… 346 Chapter 2: Hiding the Implementation 9 The “most derived” class and virtual base initialization “Tying off” virtual bases with a default constructor 349 348 Overhead……………………………. 351 Upcasting …………………………… 352 Persistence ………………………………..355 Avoiding MI……………………….. 362 Repairing an interface ………….. 362 Summary……………………………. 367 Exercises ……………………………. 368 7: Exception handling 369 Error handling in C ……………… 369 Throwing an exception ………… 372 Catching an exception………….. 373 The try block …………………………….373 Exception handlers……………………..373 The exception specification………….374 Better exception specifications?……377 Catching any exception ……………….377 Rethrowing an exception……………..378 Uncaught exceptions …………………..378 Function-level try blocks……………..380 Cleaning up ………………………… 380 Constructors ……………………….. 384 Making everything an object………..386 Exception matching …………….. 388 Standard exceptions …………….. 390 Programming with exceptions . 391 When to avoid exceptions ……………391 Typical uses of exceptions …………..392 Overhead……………………………. 396 Summary……………………………. 397 Exercises ……………………………. 397 8: Run-time type identification399 The “Shape” example ………….. 399 What is RTTI?…………………….. 400 Two syntaxes for RTTI ……………….400 Syntax specifics ………………….. 404 typeid( ) with built-in types …………404 Producing the proper type name……405 Nonpolymorphic types ………………..405 Casting to intermediate levels ………406 void pointers ……………………………..408 Using RTTI with templates ………….408 References………………………….. 409 Exceptions…………………………………410 Multiple inheritance …………….. 411 Chapter 2: Hiding the Implementation 10 Sensible uses for RTTI…………. 412 Revisiting the trash recycler …………413 Mechanism & overhead of RTTI416 Creating your own RTTI………. 416 Explicit cast syntax ……………… 420 Summary……………………………. 421 Exercises ……………………………. 422 9: Building stable systems 423 Shared objects & reference counting 423 Reference-counted class hierarchies423 The canonical object & singly-rooted hierarchies 423 An extended canonical form…………424 Design by contract ………………. 424 Integrated unit testing ………….. 424 Dynamic aggregation …………… 424 Exercises ……………………………. 428 10: Design patterns 429 The pattern concept……………… 429 The singleton……………………………..430 Classifying patterns……………… 434 Features, idioms, patterns…………….435 Basic complexity hiding………………435 Factories: encapsulating object creation 436 Polymorphic factories …………………438 Abstract factories ……………………….441 Virtual constructors…………………….444 Callbacks……………………………. 449 Functor/Command ……………………..450 Strategy …………………………………….450 Observer……………………………………450 Multiple dispatching ……………. 459 Visitor, a type of multiple dispatching463 Efficiency…………………………… 466 Flyweight ………………………………….466 The composite…………………….. 466 Evolving a design: the trash recycler Improving the design …………… 471 466 “Make more objects”…………………..471 A pattern for prototyping creation…476 Abstracting usage………………… 488 Applying double dispatching … 492 Implementing the double dispatch…492 Applying the visitor pattern ….. 497 RTTI considered harmful? ……. 503 Summary……………………………. 506 Chapter 2: Hiding the Implementation 11 Exercises ……………………………. 507 11: Tools & topics 509 The code extractor ………………. 509 Debugging………………………….. 531 assert( )…………………………………….531 Trace macros……………………………..531 Trace file …………………………………..532 Abstract base class for debugging …533 Tracking new/delete & malloc/free533 CGI programming in C++…….. 539 Encoding data for CGI ………………..540 The CGI parser…………………………..541 Using POST ………………………………548 Handling mailing lists …………………549 A general information-extraction CGI program Parsing the data files …………………..566 560 Summary……………………………. 573 Exercises ……………………………. 573 A: Recommended reading 575 C……………………………………….. 575 General C++……………………….. 575 My own list of books…………………..576 Depth & dark corners…………… 576 The STL …………………………….. 576 Design Patterns …………………… 576 B:Compiler specifics 577 Index 580

侯捷译序a
孟岩译序g
目录（contents） v
前言（preface） xvii
致谢（acknowledgments） xix
1 关于本书1
1.1 缘起1
1.2 阅读前的必要基础2
1.3 本书风格与结构2
1.4 如何阅读本书4
1.5 目前发展形式5
1.6 范例程序代码及额外信息5
1.7 回应5
2 c++ 及其标准程序库简介7
2.1 沿革7
2.2 新的语言特性9
2.2.1 templates（模板） 9
2.2.2 基本型别的显式初始化（explicit initialization） 14
2.2.3 异常处理（exception handling） 15
.2.2.4 命名空间（namespaces） 16
2.2.5 bool型别18
2.2.6 关键词explicit 18
2.2.7 新的型别转换操作符（type conversion operators） 19
2.2.8 常数静态成员（constant static members）的初始化20
2.2.9 main() 的定义21
2.3 复杂度和big-o 表示法21
3 一般概念（general concepts） 23
3.1 命名空间（namespace）std 23
3.2 头文件（header files） 24
3.3 错误（error）处理和异常（exception）处理25
3.3.1 标准异常类别（standard exception classes） 25
3.3.2 异常类别（exception classes）的成员28
3.3.3 抛出标准异常29
3.3.4 从标准异常类别（exception classes）中派生新的类别30
3.4 配置器（allocators） 31
4 通用工具（utilities） 33
4.1 pairs（对组） 33
4.1.1 便捷函数make_pair() 36
4.1.2 pair运用实例37
4.2 class auto_ptr 38
4.2.1 auto_ptr的发展动机38
4.2.2 auto_ptr拥有权（ownership）的转移40
4.2.3 auto_ptrs 做为成员之一44
4.2.4 auto_ptrs 的错误运用46
4.2.5 auto_ptr运用实例47
4.2.6 auto_ptr实作细目51
4.3 数值极限（numeric limits） 59
4.4 辅助函数66
4.4.1 挑选较小值和较大值66
4.4.2 两值互换67
4.5 辅助性的“比较操作符”（comparison operators） 69
4.6 头文件[cstddef] 和[cstdlib] 71
4.6.1 [cstddef] 内的各种定义71
4.6.2 [cstdlib] 内的各种定义71
5 standard template library（标准模板库） 73
5.1 stl 组件（stl components） 73
5.2 容器（containers） 75
5.2.1 序列式容器（sequence containers） 76
5.2.2 关联式容器（associative containers） 81
5.2.3 容器配接器（container adapters） 82
5.3 迭代器（iterators） 83
5.3.1 关联式容器的运用实例86
5.3.2 迭代器类型（iterator categories） 93
5.4 算法（algorithms） 94
5.4.1 区间（ranges） 97
5.4.2 处理多个区间101
5.5 迭代器之配接器（iterator adapters） 104
5.5.1 insert iterators（安插型迭代器） 104
5.5.2 stream iterators（串流迭代器） 107
5.5.3 reverse iterators（逆向迭代器） 109
5.6 更易型算法（manipulating algorithms） 111
5.6.1 移除（removing）元素111
5.6.2 更易型算法和关联式容器115
5.6.3 算法v.s. 成员函数116
5.7 使用者自定之泛型函数（user-defined generic functions） 117
5.8 以函数做为算法的参数119
5.8.1“以函数做为算法的参数”实例示范119
5.8.2 判断式（predicates） 121
5.9 仿函数（functors or function objects） 124
5.9.1 什么是仿函数124
5.9.2 预先定义的仿函数131
5.10 容器内的元素（container elements） 134
5.10.1 容器元素的条件134
5.10.2 value 语意vs. reference 语意135
5.11 stl内部的错误处理和异常处理136
5.11.1 错误处理（error handling） 137
5.11.2 异常处理（exception handling） 139
5.12 扩展stl 141
6 stl 容器（containers） 143
6.1 容器的共通能力和共通操作144
6.1.1 容器的共通能力144
6.1.2 容器的共通操作144
6.2 vectors 148
6.2.1 vectors 的能力148
6.2.2 vector 的操作函数150
6.2.3 将vectors 当做一般arrays 使用155
6.2.4 异常处理155
6.2.5 vectors 运用实例156
6.2.6 class vector[bool] 158
6.3 deques 160
6.3.1 deques 的能力161
6.3.2 deque 的操作函数162
6.3.3 异常处理（exception handling） 164
6.3.4 deques 运用实例164
6.4 lists 166
6.4.1 lists 的能力166
6.4.2 list 的操作函数167
6.4.3 异常处理（exception handling） 172
6.4.4 lists 运用实例172
6.5 sets和multisets
175
6.5.1 sets 和multisets 的能力176
6.5.2 set 和multiset 的操作177
6.5.3 异常处理（exception handling） 185
6.5.4 sets 和multisets 运用实例186
6.5.5 执行期指定排序准则（sorting criterion） 191
6.6 maps 和multimaps 194
6.6.1 maps 和multimaps 的能力195
6.6.2 map 和multimap 的操作函数196
6.6.3 将maps 视为关联式数组（associated arrays） 205
6.6.4 异常处理（exception handling） 207
6.6.5 maps 和multimaps 运用实例207
6.6.6 综合实例：运用maps, strings 并于执行期指定排序准则213
6.7 其它的stl容器217
6.7.1 strings 可被视为一种stl容器217
6.7.2 arrays 可被视为一种stl容器218
6.7.3 hash tables 221
6.8 动手实现reference 语意222
6.9 各种容器的运用时机226
6.10 细说容器内的型别和成员230
6.10.1 容器内的型别230
6.10.2 生成（create）、复制（copy）、销毁（destroy） 231
6.10.3“非变动性操作（nonmodifying operations） 233
6.10.4 赋值（指派, assignments） 236
6.10.5 直接元素存取237
6.10.6 “会产出迭代器”的各项操作239
6.10.7 元素的安插（inserting）和移除（removing） 240
6.10.8 lists 的特殊成员函数244
6.10.9 对配置器（allocator）的支持246
6.10.10 综观stl容器的异常处理248
7 stl 迭代器（iterators） 251
7.1 迭代器头文件251
7.2 迭代器类型（iterator categories） 251
7.2.1 input（输入）迭代器252
7.2.2 output（输出）迭代器253
7.2.3 forward（前向）迭代器254
7.2.4 bidirectional（双向）迭代器255
7.2.5 random access（随机存取）迭代器255
7.2.6 vector 迭代器的递增（increment）和递减（decrement） 258
7.3 迭代器相关辅助函数259
7.3.1 advance() 可令迭代器前进259
7.3.2 distance() 可处理迭代器之间的距离261
7.3.3 iter_swap() 可交换两个迭代器所指内容263
7.4 迭代器配接器（iterator adapters） 264
7.4.1 reverse（逆向）迭代器264
7.4.2 insert（安插型）迭代器271
7.4.3 stream（串流）迭代器277
7.5 迭代器特性（iterator traits） 283
7.5.1 为迭代器编写泛型函数（generic functions） 285
7.5.2 使用者自定（user-defined）的迭代器288
8 stl 仿函数（functors or function objects） 293
8.1 仿函数的概念293
8.1.1 仿函数可当做排序准则（sort criteria） 294
8.1.2 仿函数可拥有自己的内部状态（internal state） 296
8.1.3 for_each() 的回返值300
8.1.4 判断式（predicates）和仿函数（functors） 302
8.2 预定义的仿函数305
8.2.1 函数配接器（function adapters） 306
8.2.2 针对成员函数而设计的函数配接器307
8.2.3 针对一般函数（非成员函数）而设计的函数配接器309
8.2.4 让自定仿函数也可以使用函数配接器310
8.3 辅助用（组合型）仿函数313
8.3.1 一元组合函数配接器（unary compose function object adapters） 314
8.3.2 二元组合函数配接器（binary compose function object adapters） 318
9 stl 算法（algorithms） 321
9.1 算法头文件（header files） 321
9.2 算法概观322
9.2.1 简介322
9.2.2 算法分门别类323
9.3 辅助函数332
9.4 for_each() 算法334
9.5 非变动性算法（nonmodifying algorithms） 338
9.5.1 计算元素个数338
9.5.2 求最大值和最小值339
9.5.3 搜寻元素341
9.5.4 区间的比较356
9.6 变动性算法（modifying algorithms） 363
9.6.1 复制（copying）元素363
9.6.2 转换（transforming）和结合（combining）元素366
9.6.3 互换（swapping）元素内容370
9.6.4 赋予（assigning）新值372
9.6.5 替换（replacing）元素375
9.7 移除性算法（removing algorithms） 378
9.7.1 移除某些特定元素378
9.7.2 移除重复元素381
9.8 变序性算法（mutating algorithms） 386
9.8.1 逆转（reversing）元素次序386
9.8.2 旋转（rotating）元素次序388
9.8.3 排列（permuting）元素391
9.8.4 重排元素（shuffling, 搅乱次序） 393
9.8.5 将元素向前搬移395
9.9 排序算法（sorting algorithms） 397
9.9.1 对所有元素排序397
9.9.2 局部排序（partial sorting） 400
9.9.3 根据第n 个元素排序404
9.9.4 heap 算法406
9.10 已序区间算法（sorted range algorithms） 409
9.10.1 搜寻元素（searching） 410
9.10.2 合并元素（merging） 416
9.11 数值算法（numeric algorithms） 425
9.11.1 加工运算后产生结果425
9.11.2 相对值和绝对值之间的转换429
10 特殊容器（special containers） 435
10.1 stacks（堆栈） 435
10.1.1 核心界面436
10.1.2 stacks 运用实例437
10.1.3 class stack[] 细部讨论438
10.1.4 一个使用者自定的stack class 441
10.2 queues（队列） 444
10.2.1 核心界面445
10.2.2 queues 运用实例446
10.2.3 class queue[] 细部讨论447
10.2.4 一个使用者自定的queue class 450
10.3 priority queues（优先队列） 453
10.3.1 核心界面455
10.3.2 priority queues 运用实例455
10.3.3 class priority_queue[] 细部讨论456
10.4 bitsets 460
10.4.1 bitsets 运用实例460
10.4.2 class bitset 细部讨论463
11 strings（字符串） 471
11.1 动机471
11.1.1 例一：引出一个临时文件名
472
11.1.2 例二：引出一段文字并逆向打印476
11.2 string classes 细部描述479
11.2.1 string 的各种相关型别479
11.2.2 操作函数（operations）综览481
11.2.3 建构式和解构式（constructors and destructors） 483
11.2.4 strings 和c-strings 484
11.2.5 大小（size）和容量（capacity） 485
11.2.6 元素存取（element access） 487
11.2.7 比较（comparisons） 488
11.2.8 更改内容（modifiers） 489
11.2.9 子字符串及字符串接合492
11.2.10 i/o 操作符492
11.2.11 搜寻和查找（searching and finding） 493
11.2.12 数值npos 的意义495
11.2.13 strings 对迭代器的支援497
11.2.14 国际化（internationalization） 503
11.2.15 效率（performance） 506
11.2.16 strings 和vectors 506
11.3 细说string class 507
11.3.1 内部的型别定义和静态值507
11.3.2 生成（create）、拷贝（copy）、销毁（destroy） 508
11.3.3 大小（size）和容量（capacity） 510
11.3.4 比较（comparisons） 511
11.3.5 字符存取（character access） 512
11.3.6 产生c-strings 和字符数组（character arrays） 513
11.3.7 更改内容514
11.3.8 搜寻（searching and finding） 520
11.3.9 子字符串及字符串接合524
11.3.10 i/o 函数524
11.3.11 产生迭代器525
11.3.12 对配置器（allocator）的支持526
12 数值（numerics） 529
12.1 复数（complex numbers） 529
12.1.1 class complex运用实例530
12.1.2 复数的各种操作533
12.1.3 class complex[] 细部讨论541
12.2 valarrays 547
12.2.1 认识valarrays 547
12.2.2 valarray 的子集（subsets） 553
12.2.3 class valarray 细部讨论569
12.2.4 valarray子集类别（subset classes）细部讨论575
12.3 全域性的数值函数581
13 以stream classes完成输入和输出583
13.1 i/o streams 基本概念584
13.1.1 stream物件584
13.1.2 stream类别584
13.1.3 全域性的stream物件585
13.1.4 stream操作符586
13.1.5 操控器（manipulators） 586
13.1.6 一个简单的例子587
13.2 基本的stream类别和stream对象588
13.2.1 相关类别及其阶层体系588
13.2.2 全域性的stream物件591
13.2.3 头文件（headers） 592
13.3 标准的stream操作符[[ 和]] 593
13.3.1 output操作符[[ 593
13.3.2 input操作符]] 594
13.3.3 特殊型别的i/o 595
13.4 streams 的状态（state） 597
13.4.1 用来表示streams 状态的一些常数597
13.4.2 用来处理streams 状态的一些成员函数598
13.4.3 stream状态与布尔条件测试600
13.4.4 stream的状态和异常602
13.5 标准i/o 函数607
13.5.1 输入用的成员函数607
13.5.2 输出用的成员函数610
13.5.3 运用实例611
13.6 操控器（manipulators） 612
13.6.1 操控器如何运作612
13.6.2 使用者自定操控器614
13.7 格式化（formatting） 615
13.7.1 格式标志（format flags） 615
13.7.2 布尔值（boolean values）的i/o 格式617
13.7.3 字段宽度、填充字符、位置调整618
13.7.4 正记号与大写字620
13.7.5 数值进制（numeric base） 621
13.7.6 浮点数（floating-point）表示法623
13.7.7 一般性的格式定义625
13.8 国际化（internationalization） 625
13.9 文件存取（file access） 627
13.9.1 文件标志（file flags） 631
13.9.2 随机存取634
13.9.3 使用文件描述器（file descriptors） 637
13.10 连接input streams 和output streams 637
13.10.1 以tie()完成“松耦合”（loose coupling） 637
13.10.2 以stream缓冲区完成“紧耦合”（tight coupling） 638
13.10.3 将标准streams 重新导向（redirecting） 641
13.10.4 用于读写的streams 643
13.11 string stream classes 645
13.11.1 string stream classes 645
13.11.2 char* stream classes 649
13.12 “使用者自定型别”之i/o操作符652
13.12.1 实作一个output 操作符652
13.12.2 实作一个input 操作符654
13.12.3 以辅助函数完成i/o 656
13.12.4 以非格式化函数完成使用者自定的操作符658
13.12.5 使用者自定的格式标志（format flags） 659
13.12.6 使用者自定之i/o 操作符的数个依循惯例662
13.13 stream buffer classes 663
13.13.1 从使用者的角度看stream缓冲区663
13.13.2 stream缓冲区迭代器（buffer iterators） 665
13.13.3 使用者自定的stream 缓冲区668
13.14 关于效能（performance） 681
13.14.1 与c 标准输入输出流（standard streams）同步682
13.14.2 stream缓冲区内的缓冲机制682
13.14.3 直接使用stream缓冲区683
14 国际化（internationalization, i18n） 685
14.1 不同的字符编码（character encoding） 686
14.1.1 宽字符（wide-character）和多字节文本（multibyte text） 686
14.1.2 字符特性（character traits） 687
14.1.3 特殊字符国际化691
14.2 locales 的概念692
14.2.1 运用locales 693
14.2.2 locale facets 698
14.3 locales 细部讨论700
14.4 facets 细部讨论704
14.4.1 数值格式化705
14.4.2 时间和日期格式化708
14.4.3 货币符号格式化711
14.4.4 字符的分类和转换715
14.4.5 字符串校勘（string collation） 724
14.4.6 信息国际化725
15 空间配置器（allocators） 727
15.1 应用程序开发者如何使用配置器727
15.2 程序库开发者如何使用配置器728
15.3 c++ 标准程序库的预设配置器732
15.4 使用者自行定义的配置器735
15.5 配置器细部讨论737
15.5.1 内部定义的型别737
15.5.2 各项操作739
15.6“未初始化内存”之处理工具细部讨论740
网络上的资源（internet resources） 743
参考书目（bibliography） 745
索引（index） 747

《c++编程思想(两卷合订本)》
出版者的话
出版说明
第1卷 标准c++导引
译者序 3
前言 5
第1章 对象导言 11
1.1 抽象的过程 11
1.2 对象有一个接口 12
1.3 实现的隐藏 14
1.4 实现的重用 15
1.5 继承：重用接口 15
1.5.1 is-a 关系和is-like-a 关系 18
1.6 具有多态性的可互换对象 18
1.7 创建和销毁对象 21
1.8 异常处理：应对错误 22
1.9 分析和设计 22
1.9.1 第0阶段：制定计划 24
1.9.2 第1阶段：我们在做什么 24
1.9.3 第2阶段：我们将如何建立对象 26 

 .1.9.4 第3阶段：创建核心 28 1.9.5 第4阶段：迭代用例 29 1.9.6 第5阶段：进化 29 1.9.7 计划的回报 30 1.10 极限编程 30 1.10.1 先写测试 31 1.10.2 结对编程 32 1.11 为什么c++会成功 32 1.11.1 一个较好的c 32 1.11.2 延续式的学习过程 33 1.11.3 效率 33 1.11.4 系统更容易表达和理解 33 1.11.5 尽量使用库 33 1.11.6 利用模板的源代码重用 34 1.11.7 错误处理 34 1.11.8 大型程序设计 34 1.12 为向oop转变而采取的策略 34 1.12.1 指导方针 35 1.12.2 管理的障碍 35 1.13 小结 37 第2章 对象的创建与使用 38 2.1 语言的翻译过程 38 2.1.1 解释器 38 2.1.2 编译器 39 2.1.3 编译过程 39 2.2 分段编译工具 40 2.2.1 声明与定义 40 2.2.2 连接 44 2.2.3 使用库文件 44 2.3 编写第一个c++程序 45 2.3.1 使用iostream类 45 2.3.2 名字空间 46 2.3.3 程序的基本结构 47 2.3.4 “hello, world!” 47 2.3.5 运行编译器 48 2.4 关于输入输出流 48 2.4.1 字符数组的拼接 49 2.4.2 读取输入数据 49 2.4.3 调用其他程序 50 2.5 字符串简介 50 2.6 文件的读写 51 2.7 vector简介 52 2.8 小结 55 2.9 练习 56 第3章 c++中的c 57 3.1 创建函数 57 3.1.1 函数的返回值 58 3.1.2 使用c的函数库 59 3.1.3 通过库管理器创建自己的库 59 3.2 执行控制语句 60 3.2.1 真和假 60 3.2.2 if-else语句 60 3.2.3 while语句 61 3.2.4 do-while语句 61 3.2.5 for语句 62 3.2.6 关键字break 和 continue 63 3.2.7 switch语句 64 3.2.8 使用和滥用goto 65 3.2.9 递归 65 3.3 运算符简介 66 3.3.1 优先级 66 3.3.2 自增和自减 67 3.4 数据类型简介 67 3.4.1 基本内建类型 67 3.4.2 bool类型与true和false 68 3.4.3 说明符 69 3.4.4 指针简介 70 3.4.5 修改外部对象 72 3.4.6 c++引用简介 74 3.4.7 用指针和引用作为修饰符 75 3.5 作用域 76 3.5.1 实时定义变量 77 3.6 指定存储空间分配 78 3.6.1 全局变量 78 3.6.2 局部变量 79 3.6.3 静态变量 80 3.6.4 外部变量 81 3.6.5 常量 82 3.6.6 volatile变量 83 3.7 运算符及其使用 83 3.7.1 赋值 83 3.7.2 数学运算符 83 3.7.3 关系运算符 85 3.7.4 逻辑运算符 85 3.7.5 位运算符 85 3.7.6 移位运算符 86 3.7.7 一元运算符 88 3.7.8 三元运算符 88 3.7.9 逗号运算符 89 3.7.10 使用运算符时的常见问题 89 3.7.11 转换运算符 90 3.7.12 c++的显式转换 90 3.7.13 sizeof—独立运算符 93 3.7.14 asm 关键字 94 3.7.15 显式运算符 94 3.8 创建复合类型 94 3.8.1 用typedef命名别名 95 3.8.2 用struct把变量结合在一起 95 3.8.3 用enum提高程度清晰度 97 3.8.4 用union节省内存 98 3.8.5 数组 99 3.9 调试技巧 106 3.9.1 调试标记 106 3.9.2 把变量和表达式转换成字符串 108 3.9.3 c语言assert( )宏 108 3.10 函数地址 109 3.10.1 定义函数指针 109 3.10.2 复杂的声明和定义 109 3.10.3 使用函数指针 110 3.10.4 指向函数的指针数组 111 3.11 make：管理分段编译 111 3.11.1 make的行为 112 3.11.2 本书中的makefile 114 3.11.3 makefile的一个例子 114 3.12 小结 116 3.13 练习 116 第4章 数据抽象 119 4.1 一个袖珍c库 119 4.1.1 动态存储分配 122 4.1.2 有害的猜测 124 4.2 哪儿出问题 125 4.3 基本对象 126 4.4 什么是对象 130 4.5 抽象数据类型 131 4.6 对象细节 131 4.7 头文件形式 132 4.7.1 头文件的重要性 132 4.7.2 多次声明问题 133 4.7.3 预处理器指示#define、#ifdef 和#endif 134 4.7.4 头文件的标准 134 4.7.5 头文件中的名字空间 135 4.7.6 在项目中使用头文件 135 4.8 嵌套结构 136 4.8.1 全局作用域解析 138 4.9 小结 139 4.10 练习 139 第5章 隐藏实现 142 5.1 设置限制 142 5.2 c++的访问控制 142 5.2.1 protected说明符 144 5.3 友元 144 5.3.1 嵌套友元 146 5.3.2 它是纯面向对象的吗 148 5.4 对象布局 148 5.5 类 149 5.5.1 用访问控制来修改stash 151 5.5.2 用访问控制来修改stack 151 5.6 句柄类 152 5.6.1 隐藏实现 152 5.6.2 减少重复编译 152 5.7 小结 154 5.8 练习 154 第6章 初始化与清除 156 6.1 用构造函数确保初始化 156 6.2 用析构函数确保清除 157 6.3 清除定义块 159 6.3.1 for循环 160 6.3.2 内存分配 161 6.4 带有构造函数和析构函数的stash 162 6.5 带有构造函数和析构函数的stack 164 6.6 聚合初始化 166 6.7 默认构造函数 168 6.8 小结 169 6.9 练习 169 第7章 函数重载与默认参数 171 7.1 名字修饰 172 7.1.1 用返回值重载 172 7.1.2 类型安全连接 172 7.2 重载的例子 173 7.3 联合 176 7.4 默认参数 178 7.4.1 占位符参数 179 7.5 选择重载还是默认参数 180 7.6 小结 183 7.7 练习 183 第8章 常量 185 8.1 值替代 185 8.1.1 头文件里的const 186 8.1.2 const的安全性 186 8.1.3 聚合 187 8.1.4 与c语言的区别 187 8.2 指针 188 8.2.1 指向const的指针 189 8.2.2 const指针 189 8.2.3 赋值和类型检查 190 8.3 函数参数和返回值 191 8.3.1 传递const值 191 8.3.2 返回const值 191 8.3.3 传递和返回地址 193 8.4 类 195 8.4.1 类里的const 196 8.4.2 编译期间类里的常量 198 8.4.3 const对象和成员函数 200 8.5 volatile 204 8.6 小结 205 8.7 练习 205 第9章 内联函数 207 9.1 预处理器的缺陷 207 9.1.1 宏和访问 209 9.2 内联函数 210 9.2.1 类内部的内联函数 210 9.2.2 访问函数 211 9.3 带内联函数的stash和stack 215 9.4 内联函数和编译器 218 9.4.1 限制 219 9.4.2 向前引用 219 9.4.3 在构造函数和析构函数里隐藏行为 220 9.5 减少混乱 220 9.6 预处理器的更多特征 221 9.6.1 标志粘贴 222 9.7 改进的错误检查 222 9.8 小结 225 9.9 练习 225 第10章 名字控制 227 10.1 来自c语言中的静态元素 227 10.1.1 函数内部的静态变量 227 10.1.2 控制连接 230 10.1.3 其他存储类型说明符 232 10.2 名字空间 232 10.2.1 创建一个名字空间 232 10.2.2 使用名字空间 234 10.2.3 名字空间的使用 237 10.3 c++中的静态成员 238 10.3.1 定义静态数据成员的存储 238 10.3.2 嵌套类和局部类 241 10.3.3 静态成员函数 242 10.4 静态初始化的相依性 244 10.4.1 怎么办 245 10.5 替代连接说明 250 10.6 小结 250 10.7 练习 251 第11章 引用和拷贝构造函数 254 11.1 c++中的指针 254 11.2 c++中的引用 254 11.2.1 函数中的引用 255 11.2.2 参数传递准则 257 11.3 拷贝构造函数 257 11.3.1 按值传递和返回 257 11.3.2 拷贝构造函数 261 11.3.3 默认拷贝构造函数 265 11.3.4 替代拷贝构造函数的方法 266 11.4 指向成员的指针 267 11.4.1 函数 269 11.5 小结 271 11.6 练习 271 第12章 运算符重载 274 12.1 两个极端 274 12.2 语法 274 12.3 可重载的运算符 275 12.3.1 一元运算符 276 12.3.2 二元运算符 279 12.3.3 参数和返回值 288 12.3.4 不常用的运算符 290 12.3.5 不能重载的运算符 295 12.4 非成员运算符 296 12.4.1 基本方针 297 12.5 重载赋值符 297 12.5.1 operator=的行为 298 12.6 自动类型转换 306 12.6.1 构造函数转换 306 12.6.2 运算符转换 307 12.6.3 类型转换例子 309 12.6.4 自动类型转换的缺陷 310 12.7 小结 312 12.8 练习 312 第13章 动态对象创建 315 13.1 对象创建 315 13.1.1 c从堆中获取存储单元的方法 316 13.1.2 operator new 317 13.1.3 operator delete 317 13.1.4 一个简单的例子 318 13.1.5 内存管理的开销 318 13.2 重新设计前面的例子 319 13.2.1 使用delete void*可能会出错 319 13.2.2 对指针的清除责任 320 13.2.3 指针的stash 320 13.3 用于数组的new和delete 324 13.3.1 使指针更像数组 325 13.4 耗尽内存 325 13.5 重载new和delete 326 13.5.1 重载全局new和delete 327 13.5.2 对于一个类重载new和delete 328 13.5.3 为数组重载new和delete 330 13.5.4 构造函数调用 332 13.5.5 定位new和delete 333 13.6 小结 334 13.7 练习 334 第14章 继承和组合 336 14.1 组合语法 336 14.2 继承语法 337 14.3 构造函数的初始化表达式表 339 14.3.1 成员对象初始化 339 14.3.2 在初始化表达式表中的内建类型 339 14.4 组合和继承的联合 340 14.4.1 构造函数和析构函数调用的次序 341 14.5 名字隐藏 343 14.6 非自动继承的函数 346 14.6.1 继承和静态成员函数 349 14.7 组合与继承的选择 349 14.7.1 子类型设置 350 14.7.2 私有继承 352 14.8 protected 353 14.8.1 protected继承 353 14.9 运算符的重载与继承 353 14.10 多重继承 355 14.11 渐增式开发 355 14.12 向上类型转换 356 14.12.1 为什么要“向上类型转换” 357 14.12.2 向上类型转换和拷贝构造函数 357 14.12.3 组合与继承（再论） 359 14.12.4 指针和引用的向上类型转换 360 14.12.5 危机 360 14.13 小结 361 14.14 练习 361 第15章 多态性和虚函数 364 15.1 c++程序员的演变 364 15.2 向上类型转换 365 15.3 问题 366 15.3.1 函数调用捆绑 366 15.4 虚函数 366 15.4.1 扩展性 367 15.5 c++如何实现晚捆绑 369 15.5.1 存放类型信息 370 15.5.2 虚函数功能图示 371 15.5.3 撩开面纱 372 15.5.4 安装vpointer 373 15.5.5 对象是不同的 373 15.6 为什么需要虚函数 374 15.7 抽象基类和纯虚函数 375 15.7.1 纯虚定义 378 15.8 继承和vtable 378 15.8.1 对象切片 380 15.9 重载和重新定义 382 15.9.1 变量返回类型 383 15.10 虚函数和构造函数 385 15.10.1 构造函数调用次序 385 15.10.2 虚函数在构造函数中的行为 386 15.11 析构函数和虚拟析构函数 386 15.11.1 纯虚析构函数 388 15.11.2 析构函数中的虚机制 389 15.11.3 创建基于对象的继承 390 15.12 运算符重载 392 15.13 向下类型转换 394 15.14 小结 396 15.15 练习 397 第16章 模板介绍 400 16.1 容器 400 16.1.1 容器的需求 401 16.2 模板综述 402 16.2.1 模板方法 403 16.3 模板语法 404 16.3.1 非内联函数定义 405 16.3.2 作为模板的intstack 406 16.3.3 模板中的常量 408 16.4 作为模板的stash和stack 409 16.4.1 模板化的指针stash 411 16.5 打开和关闭所有权 415 16.6 以值存放对象 417 16.7 迭代器简介 418 16.7.1 带有迭代器的栈 425 16.7.2 带有迭代器的pstash 427 16.8 为什么使用迭代器 432 16.8.1 函数模板 434 16.9 小结 435 16.10 练习 435 附录a 编码风格 附录b 编程准则 附录c 推荐读物 第2卷 实用编程技术 译者序 441 前言 442 第一部分 建立稳定的系统 第1章 异常处理 448 1.1 传统的错误处理 448 1.2 抛出异常 450 1.3 捕获异常 451 1.3.1 try块 451 1.3.2 异常处理器 451 1.3.3 终止和恢复 452 1.4 异常匹配 453 1.4.1 捕获所有异常 454 1.4.2 重新抛出异常 454 1.4.3 不捕获异常 455 1.5 清理 456 1.5.1 资源管理 457 1.5.2 使所有事物都成为对象 458 1.5.3 auto_ptr 460 1.5.4 函数级的try块 461 1.6 标准异常 462 1.7 异常规格说明 464 1.7.1 更好的异常规格说明 467 1.7.2 异常规格说明和继承 467 1.7.3 什么时候不使用异常规格说明 468 1.8 异常安全 468 1.9 在编程中使用异常 471 1.9.1 什么时候避免异常 471 1.9.2 异常的典型应用 472 1.10 使用异常造成的开销 474 1.11 小结 476 1.12 练习 476 第2章 防御性编程 478 2.1 断言 480 2.2 一个简单的单元测试框架 482 2.2.1 自动测试 483 2.2.2 testsuite框架 485 2.2.3 测试套件 488 2.2.4 测试框架的源代码 489 2.3 调试技术 493 2.3.1 用于代码跟踪的宏 494 2.3.2 跟踪文件 494 2.3.3 发现内存泄漏 495 2.4 小结 499 2.5 练习 500 第二部分 标准c++库 第3章 深入理解字符串 504 3.1 字符串的内部是什么 504 3.2 创建并初始化c++字符串 505 3.3 对字符串进行操作 508 3.3.1 追加、插入和连接字符串 508 3.3.2 替换字符串中的字符 509 3.3.3 使用非成员重载运算符连接 512 3.4 字符串的查找 513 3.4.1 反向查找 516 3.4.2 查找一组字符第1次或最后一次出现的位置 517 3.4.3 从字符串中删除字符 519 3.4.4 字符串的比较 520 3.4.5 字符串和字符的特性 523 3.5 字符串的应用 527 3.6 小结 531 3.7 练习 531 第4章 输入输出流 534 4.1 为什么引入输入输出流 534 4.2 救助输入输出流 537 4.2.1 插入符和提取符 537 4.2.2 通常用法 540 4.2.3 按行输入 541 4.3 处理流错误 542 4.4 文件输入输出流 544 4.4.1 一个文件处理的例子 544 4.4.2 打开模式 546 4.5 输入输出流缓冲 546 4.6 在输入输出流中定位 548 4.7 字符串输入输出流 550 4.7.1 输入字符串流 551 4.7.2 输出字符串流 552 4.8 输出流的格式化 555 4.8.1 格式化标志 555 4.8.2 格式化域 556 4.8.3 宽度、填充和精度设置 557 4.8.4 一个完整的例子 557 4.9 操纵算子 560 4.9.1 带参数的操纵算子 560 4.9.2 创建操纵算子 562 4.9.3 效用算子 563 4.10 输入输出流程序举例 565 4.10.1 维护类库的源代码 565 4.10.2 检测编译器错误 568 4.10.3 一个简单的数据记录器 570 4.11 国际化 573 4.11.1 宽字符流 574 4.11.2 区域性字符流 575 4.12 小结 577 4.13 练习 577 第5章 深入理解模板 580 5.1 模板参数 580 5.1.1 无类型模板参数 580 5.1.2 默认模板参数 582 5.1.3 模板类型的模板参数 583 5.1.4 typename关键字 587 5.1.5 以template关键字作为提示 588 5.1.6 成员模板 589 5.2 有关函数模板的几个问题 591 5.2.1 函数模板参数的类型推断 591 5.2.2 函数模板重载 594 5.2.3 以一个已生成的函数模板地址作为参数 595 5.2.4 将函数应用到stl序列容器中 598 5.2.5 函数模板的半有序 600 5.3 模板特化 601 5.3.1 显式特化 601 5.3.2 半特化 602 5.3.3 一个实例 604 5.3.4 防止模板代码膨胀 606 5.4 名称查找问题 609 5.4.1 模板中的名称 609 5.4.2 模板和友元 613 5.5 模板编程中的习语 617 5.5.1 特征 617 5.5.2 策略 621 5.5.3 奇特的递归模板模式 623 5.6 模板元编程 624 5.6.1 编译时编程 625 5.6.2 表达式模板 631 5.7 模板编译模型 636 5.7.1 包含模型 636 5.7.2 显式实例化 637 5.7.3 分离模型 638 5.8 小结 639 5.9 练习 640 第6章 通用算法 642 6.1 概述 642 6.1.1 判定函数 644 6.1.2 流迭代器 646 6.1.3 算法复杂性 647 6.2 函数对象 648 6.2.1 函数对象的分类 649 6.2.2 自动创建函数对象 649 6.2.3 可调整的函数对象 652 6.2.4 更多的函数对象例子 653 6.2.5 函数指针适配器 658 6.2.6 编写自己的函数对象适配器 662 6.3 stl算法目录 665 6.3.1 实例创建的支持工具 666 6.3.2 填充和生成 669 6.3.3 计数 670 6.3.4 操作序列 671 6.3.5 查找和替换 674 6.3.6 比较范围 679 6.3.7 删除元素 681 6.3.8 对已排序的序列进行排序和运算 684 6.3.9 堆运算 691 6.3.10 对某一范围内的所有元素进行运算 691 6.3.11 数值算法 697 6.3.12 通用实用程序 699 6.4 创建自己的stl风格算法 700 6.5 小结 701 6.6 练习 702 第7章 通用容器 706 7.1 容器和迭代器 706 7.2 概述 707 7.2.1 字符串容器 711 7.2.2 从stl容器继承 712 7.3 更多迭代器 714 7.3.1 可逆容器中的迭代器 715 7.3.2 迭代器的种类 716 7.3.3 预定义迭代器 717 7.4 基本序列容器：vector、list和deque 721 7.4.1 基本序列容器的操作 721 7.4.2 向量 723 7.4.3 双端队列 728 7.4.4 序列容器间的转换 730 7.4.5 被检查的随机访问 731 7.4.6 链表 732 7.4.7 交换序列 736 7.5 集合 737 7.6 堆栈 743 7.7 队列 745 7.8 优先队列 748 7.9 持有二进制位 755 7.9.1 bitset[n] 756 7.9.2 vector[bool] 758 7.10 关联式容器 760 7.10.1 用于关联式容器的发生器和填充器 763 7.10.2 不可思议的映像 765 7.10.3 多重映像和重复的关键字 766 7.10.4 多重集合 768 7.11 将stl容器联合使用 771 7.12 清除容器的指针 773 7.13 创建自己的容器 774 7.14 对stl的扩充 776 7.15 非stl容器 777 7.16 小结 781 7.17 练习 781 第三部分 专 题 第8章 运行时类型识别 785 8.1 运行时类型转换 785 8.2 typeid 操作符 789 8.2.1 类型转换到中间层次类型 790 8.2.2 void型指针 791 8.2.3 运用带模板的rtti 792 8.3 多重继承 793 8.4 合理使用rtti 793 8.5 rtti的机制和开销 797 8.6 小结 797 8.7 练习 798 第9章 多重继承 800 9.1 概论 800 9.2 接口继承 801 9.3 实现继承 803 9.4 重复子对象 807 9.5 虚基类 810 9.6 名字查找问题 817 9.7 避免使用多重继承 819 9.8 扩充一个接口 820 9.9 小结 823 9.10 练习 823 第10章 设计模式 825 10.1 模式的概念 825 10.2 模式分类 826 10.3 简化习语 827 10.3.1 信使 827 10.3.2 收集参数 828 10.4 单件 829 10.5 命令：选择操作 833 10.6 消除对象耦合 836 10.6.1 代理模式：作为其他对象的前端 837 10.6.2 状态模式：改变对象的行为 838 10.7 适配器模式 840 10.8 模板方法模式 841 10.9 策略模式：运行时选择算法 842 10.10 职责链模式：尝试采用一系列 策略模式 843 10.11 工厂模式：封装对象的创建 845 10.11.1 多态工厂 847 10.11.2 抽象工厂 849 10.11.3 虚构造函数 851 10.12 构建器模式：创建复杂对象 855 10.13 观察者模式 860 10.13.1 “内部类”方法 862 10.13.2 观察者模式举例 864 10.14 多重派遣 867 10.15 小结 873 10.16 练习 873 第11章 并发 875 11.1 动机 875 11.2 c++中的并发 876 11.3 定义任务 878 11.4 使用线程 879 11.4.1 创建有响应的用户界面 880 11.4.2 使用执行器简化工作 882 11.4.3 让步 884 11.4.4 休眠 885 11.4.5 优先权 886 11.5 共享有限资源 887 11.5.1 保证对象的存在 887 11.5.2 不恰当地访问资源 890 11.5.3 访问控制 892 11.5.4 使用保护简化编码 893 11.5.5 线程本地存储 896 11.6 终止任务 897 11.6.1 防止输入/输出流冲突 897 11.6.2 举例观赏植物园 898 11.6.3 阻塞时终止 901 11.6.4 中断 902 11.7 线程间协作 906 11.7.1 等待和信号 906 11.7.2 生产者-消费者关系 909 11.7.3 用队列解决线程处理的问题 912 11.7.4 广播 916 11.8 死锁 921 11.9 小结 925 11.10 练习 926 附 录 附录a 推荐读物 附录b 其他