Table of contents for C++ cookbook / D. Ryan Stephens ... [et al.].


Bibliographic record and links to related information available from the Library of Congress catalog
Note: Electronic data is machine generated. May be incomplete or contain other coding.


Counter
1.  Building C++  Applications ...................................... .. .  1
1.1 Obtaining and Installing GCC                           15
1.2 Building a Simple "Hello, World" Application
from the Command Line                                   18
1.3 Building a Static Library from the Command Line        23
1.4 Building a Dynamic Library from the Command Line       25
1.5 Building a Complex Application from the Command Line   33
1.6 Installing Boost.Build                                 38
1.7 Building a Simple "Hello, World" Application Using Boost.Build  40
1.8 Building a Static Library Using Boost.Build            44
1.9 Building a Dynamic Library Using Boost.Build           45
1.10 Building a Complex Application Using Boost.Build       46
1.11 Building a Static Library with an IDE                  50
1.12 Building a Dynamic Library with an IDE                 53
1.13 Building a Complex Application with an IDE             57
1.14 Obtaining GNU make                                     62
1.15 Building A Simple "Hello, World" Application with GNU make  64
1.16 Building a Static Library with GNU Make                72
1.17 Building a Dynamic Library with GNU Make               77
1.18 Building a Complex Application with GNU make           78
1.19 Defining a Macro                                       82
1.20 Specifying a Command-Line Option from Your IDE         84
1.21 Producing a Debug Build                                85
1.22 Producing a Release Build                              89
1.23 Specifying a Runtime Library Variant                   92
1.24 Enforcing Strict Conformance to the C++ Standard         95
1.25 Causing a Source File to Be Linked Automatically Against
a Specified Library                                      99
1.26 Using Exported Templates                                101
2.  Code Organization  ......... . . . ......................  ..........  105
2.1 Making Sure a Header File Gets Included Only Once       107
2.2 Ensuring You Have Only One Instance of a Variable
Across Multiple Source Files                            108
2.3 Reducing #includes with Forward Class Declarations      110
2.4 Preventing Name Collisions with Namespaces              111
2.5 Including an Inline File                                118
3. Numbers ............................................ ............. 120
3.1 Converting a String to a Numeric Type                   120
3.2 Converting Numbers to Strings                           123
3.3 Testing Whether a String Contains a Valid Number        126
3.4 Comparing Floating-Point Numbers with Bounded Accuracy  129
3.5 Parsing a String Containing a Number in Scientific Notation  131
3.6 Converting Between Numeric Types                        133
3.7 Getting the Minimum and Maximum Values for a Numeric Type  136
4.  Strings and  Text  .............  .   . . ..   ........... ....... . ............. .. . ..139
4.1 Padding a String                                        140
4.2 Trimming a String                                       142
4.3 Storing Strings in a Sequence                           147
4.4 Getting the Length of a String                          151
4.5 Reversing a String                                      153
4.6 Splitting a String                                      154
4.7 Tokenizing a String                                     157
4.8 Joining a Sequence of Strings                           159
4.9 Finding Things in Strings                               162
4.10 Finding the nth Instance of a Substring                 165
4.11 Removing a Substring from a String                      167
4.12 Converting a String to Lower- or Uppercase              168
4.13 Doing a Case-Insensitive String Comparison              171
4.14 Doing a Case-Insensitive String Search                  173
4.15 Converting Between Tabs and Spaces in a Text File       175
4.16 Wrapping Lines in a Text File                           178
4.17 Counting the Number of Characters, Words, and Lines
in a Text File                                          180
4.18 Counting Instances of Each Word in a Text File          183
4.19 Add Margins to a Text File                              185
4.20 Justify a Text File                                     188
4.21 Squeeze Whitespace to Single Spaces in a Text File      190
4.22 Autocorrect Text as a Buffer Changes                    191
4.23 Reading a Comma-Separated Text File                     194
4.24 Using Regular Expressions to Split a String             196
5.  Dates and  Tim es  .. . .......................................... .198
5.1 Obtaining the Current Date and Time                     198
5.2 Formatting a Date/Time as a String                      201
5.3 Performing Date and Time Arithmetic                     204
5.4 Converting Between Time Zones                           205
5.5 Determining a Day's Number Within a Given Year          207
5.6 Defining Constrained Value Types                        208
6.  Managing Data with Containers  .................. .................. 213
6.1 Using vectors Instead of Arrays                         214
6.2 Using vectors Efficiently                               218
6.3 Copying a vector                                        222
6.4 Storing Pointers in a vector                            224
6.5 Storing Objects in a list                               226
6.6 Mapping strings to Other Things                         231
6.7 Using Hashed Containers                                 237
6.8 Storing Objects in Sorted Order                         242
6.9 Storing Containers in Containers                        245
7.  Algorithm s  ....................................... ..... ....... ..  248
7.1 Iterating Through a Container                           249
7.2 Removing Objects from a Container                       256
7.3 Randomly Shuffling Data                                 259
7.4 Comparing Ranges                                        260
7.5 Merging Data                                            264
7.6 Sorting a Range                                         268
7.7 Partitioning a Range                                    271
7.8 Performing Set Operations on Sequences                  272
7.9 Transforming Elements in a Sequence                     276
7.10 Writing Your Own Algorithm                              278
7.11 Printing a Range to a Stream                            281
8.  Classes  ....................... .. ...... ... ......................... . .285
8.1 Initializing Class Member Variables                     286
8.2 Using a Function to Create Objects (a.k.a. Factory Pattern)  289
8.3 Using Constructors and Destructors to Manage Resources (or RAII) 291
8.4 Automatically Adding New Class Instances to a Container  294
8.5 Ensuring a Single Copy of a Member Variable             296
8.6 Determining an Object's Type at Runtime                 297
8.7 Determining if One Object's Class Is a Subclass of Another  299
8.8 Giving Each Instance of a Class a Unique Identifier     301
8.9 Creating a Singleton Class                              303
8.10 Creating an Interface with an Abstract Base Class       306
8.11 Writing a Class Template                                310
8.12 Writing a Member Function Template                      315
8.13 Overloading the Increment and Decrement Operators       318
8.14 Overloading Arithmetic and Assignment Operators
for Intuitive Class Behavior                            320
8.15 Calling a Superclass Virtual Function                   328
9.  Exceptions and  Safety  ... . ............ ............ ............................... . 330
9.1 Creating an Exception Class                             330
9.2 Making a Constructor Exception-Safe                     335
9.3 Making an Initializer List Exception-Safe               338
9.4 Making Member Functions Exception-Safe                  341
9.5 Safely Copying an Object                                346
10.  Streams and  Files  ......................... .............. ...... ........... . .. 351
10.1 Lining Up Text Output                                   352
10.2 Formatting Floating-Point Output                        356
10.3 Writing Your Own Stream Manipulators                    359
10.4 Making a Class Writable to a Stream                     363
10.5 Making a Class Readable from a Stream                   366
10.6 Getting Information About a File                        368
10.7 Copying a File                                          370
10.8 Deleting or Renaming a File                             374
10.9 Creating a Temporary Filename and File                  376
10.10 Creating a Directory                                    378
10.11 Removing a Directory                                    380
10.12 Reading the Contents of a Directory                     383
10.13 Extracting a File Extension from a String               385
10.14 Extracting a Filename from a Full Path                  386
10.15 Extracting a Path from a Full Path and Filename         388
10.16 Replacing a File Extension                              389
10.17 Combining Two Paths into a Single Path                  390
11. Science and Mathematics ........................................ 394
11.1 Computing the Number of Elements in a Container         395
11.2 Finding the Greatest or Least Value in a Container      396
11.3 Computing the Sum and Mean of Elements in a Container   399
11.4 Filtering Values Outside a Given Range                  402
11.5 Computing Variance, Standard Deviation,
and Other Statistical Functions                         403
11.6 Generating Random Numbers                               407
11.7 Initializing a Container with Random Numbers            409
11.8 Representing a Dynamically Sized Numerical Vector       410
11.9 Representing a Fixed-Size Numerical Vector              412
11.10 Computing a Dot Product                                 415
11.11 Computing the Norm of a Vector                          416
11.12 Computing the Distance Between Two Vectors              417
11.13 Implementing a Stride Iterator                          419
11.14 Implementing a Dynamically Sized Matrix                 423
11.15 Implementing a Constant-Sized Matrix                    426
11.16 Multiplying Matricies                                   429
11.17 Computing the Fast Fourier Transform                    431
11.18 Working with Polar Coordinates                          433
11.19 Performing Arithmetic on Bitsets                        435
11.20 Representing Large Fixed-Width Integers                 439
11.21 Implementing Fixed-Point Numbers                        443
12. Multithreading ..................................... .........446
12.1 Creating a Thread                                       447
12.2 Making a Resource Thread-Safe                           450
12.3 Notifying One Thread from Another                       458
12.4 Initializing Shared Resources Once                      462
12.5 Passing an Argument to a Thread Function                463
13. Internationalization .. . . .... .............................. 466
13.1 Hardcoding a Unicode String                            467
13.2 Writing and Reading Numbers                            468
13.3 Writing and Reading Dates and Times                    472
13.4 Writing and Reading Currency                           477
13.5 Sorting Localized Strings                              481
14.  XM L  ................... .................  ......  ...................   484
14.1 Parsing a Simple XML Document                          485
14.2 Working with Xerces Strings                            494
14.3 Parsing a Complex XML Document                         496
14.4 Manipulating an XML Document                           508
14.5 Validating an XML Document with a DTD                  512
14.6 Validating an XML Document with a Schema               517
14.7 Transforming an XML Document with XSLT                 520
14.8 Evaluating an XPath Expression                         527
14.9 Using XML to Save and Restore a Collection of Objects  533
15.  Miscellaneous  ................................... ...........   539
15.1 Using Function Pointers for Callbacks                  539
15.2 Using Pointers to Class Members                        541
15.3 Ensuring That a Function Doesn't Modify an Argument    544
15.4 Ensuring That a Member Function Doesn't Modify Its Object  546
15.5 Writing an Operator That Isn't a Member Function       548
15.6 Initializing a Sequence with Comma-Separated Values    550



Library of Congress subject headings for this publication: C++ (Computer program language)