iii
Chapter 4. Small-Object Allocation................................................................................ 68
4.1 The Default Free Store Allocator ........................................................................ 68
4.2 The Workings of a Memory Allocator................................................................. 69
4.3 A Small-Object Allocator ...................................................................................... 70
4.4 Chunks ................................................................................................................... 71
4.5 The Fixed-Size Allocator...................................................................................... 74
4.6 The SmallObjAllocator Class...................................................................... 77
4.7 A Hat Trick.............................................................................................................. 79
4.8 Simple, Complicated, Yet Simple in the End..................................................... 81
4.9 Administrivia........................................................................................................... 82
4.10 Summary .............................................................................................................. 83
4.11 Small-Object Allocator Quick Facts.................................................................. 83
Part II: Components.............................................................................................................. 85
Chapter 5. Generalized Functors................................................................................... 86
5.1 The Command Design Pattern............................................................................ 86
5.2 Command in the Real World................................................................................ 89
5.3 C++ Callable Entities ............................................................................................ 89
5.4 The Functor Class Template Skeleton ........................................................... 91
5.5 Implementing the Forwarding Functor::operator() ............................... 95
5.6 Handling Functors ................................................................................................. 96
5.7 Build One, Get One Free...................................................................................... 98
5.8 Argument and Return Type Conversions .......................................................... 99
5.9 Handling Pointers to Member Functions.......................................................... 101
5.10 Binding................................................................................................................ 104
5.11 Chaining Requests............................................................................................ 106
5.12 Real-World Issues I: The Cost of Forwarding Functions ............................ 107
5.13 Real-World Issues II: Heap Allocation ........................................................... 108
5.14 Implementing Undo and Redo with Functor .............................................. 110
5.15 Summary ............................................................................................................ 110
5.16 Functor Quick Facts....................................................................................... 111
Chapter 6. Implementing Singletons ........................................................................... 113
6.1 Static Data + Static Functions != Singleton..................................................... 113
6.2 The Basic C++ Idioms Supporting Singletons ................................................ 114
6.3 Enforcing the Singleton's Uniqueness ............................................................. 116
6.4 Destroying the Singleton .................................................................................... 116
6.5 The Dead Reference Problem........................................................................... 118
6.6 Addressing the Dead Reference Problem (I): The Phoenix Singleton........ 120
6.7 Addressing the Dead Reference Problem (II): Singletons with Longevity.. 122
6.8 Implementing Singletons with Longevity.......................................................... 125
6.9 Living in a Multithreaded World......................................................................... 128
6.10 Putting It All Together....................................................................................... 130
6.11 Working with SingletonHolder.................................................................. 134
6.12 Summary ............................................................................................................ 136
6.13 SingletonHolder Class Template Quick Facts....................................... 136
Chapter 7. Smart Pointers............................................................................................. 138
7.1 Smart Pointers 101 ............................................................................................. 138
7.2 The Deal ............................................................................................................... 139
7.3 Storage of Smart Pointers.................................................................................. 140
7.4 Smart Pointer Member Functions..................................................................... 142
7.5 Ownership-Handling Strategies ........................................................................ 143
7.6 The Address-of Operator.................................................................................... 150
7.7 Implicit Conversion to Raw Pointer Types....................................................... 151
7.8 Equality and Inequality........................................................................................ 153
7.9 Ordering Comparisons........................................................................................ 157
评论0