C++ Cookbook at Amazon.com

C++ Cookbook

Written by D. Ryan Stephens, Christopher Diggins, Jonathan Turkanis, and Jeff Cogswell.
Edited by Jonathan Gennick

The C++ CookBook is a collection of recipes for common programming tasks, so that you can concentrate on the stuff that really matters. A sample chapter can be downloaded here from O'Reilly.com.

Typical of O'Reilly's "Cookbook" series, the C++ Cookbook is written in a straightforward format, featuring recipes that contain problem statements and code solutions, and apply not to hypothetical situations, but those that you're likely to encounter. A detailed explanation then follows each recipe in order to show you how and why the solution works. This question-solution-discussion format is a proven teaching method, as any fan of the "Cookbook" series can attest to. This book will move quickly to the top of your list of essential C++ references.

Click here for more information or to purchase the C++ CookBook

Please visit the C++ Cookbook forum and mailing list, which is open to the public and managed by Google groups, where we answer questions related to the book or C++ in general.

Table of Contents

1. Building C++ Applications
       1.1 Obtaining and Installing GCC
       1.2 Building a Simple "Hello, World" Application from the Command Line
       1.3 Building a Static Library from the Command Line
       1.4 Building a Dynamic Library from the Command Line
       1.5 Building a Complex Application from the Command Line
       1.6 Installing Boost.Build
       1.7 Building a Simple "Hello, World" Application Using Boost.Build
       1.8 Building a Static Library Using Boost.Build
       1.9 Building a Dynamic Library Using Boost.Build
       1.10 Building a Complex Application Using Boost.Build
       1.11 Building a Static Library with an IDE
       1.12 Building a Dynamic Library with an IDE
       1.13 Building a Complex Application with an IDE
       1.14 Obtaining GNU make
       1.15 Building A Simple "Hello, World" Application with GNU make
       1.16 Building a Static Library with GNU Make
       1.17 Building a Dynamic Library with GNU Make
       1.18 Building a Complex Application with GNU make
       1.19 Defining a Macro
       1.20 Specifying a Command-Line Option from Your IDE
       1.21 Producing a Debug Build
       1.22 Producing a Release Build
       1.23 Specifying a Runtime Library Variant
       1.24 Enforcing Strict Conformance to the C++ Standard
       1.25 Causing a Source File to Be Linked Automatically Against a Specified Library
       1.26 Using Exported Templates
2. Code Organization
       2.1 Making Sure a Header File Gets Included Only Once
       2.2 Ensuring You Have Only One Instance of a Variable Across Multiple Source Files
       2.3 Reducing #includes with Forward Class Declarations
       2.4 Preventing Name Collisions with Namespaces
       2.5 Including an Inline File
3. Numbers
       3.1 Converting a String to a Numeric Type
       3.2 Converting Numbers to Strings
       3.3 Testing Whether a String Contains a Valid Number
       3.4 Comparing Floating-Point Numbers with Bounded Accuracy
       3.5 Parsing a String Containing a Number in Scientific Notation
       3.6 Converting Between Numeric Types
       3.7 Getting the Minimum and Maximum Values for a Numeric Type
4. Strings and Text
       4.1 Padding a String
       4.2 Trimming a String
       4.3 Storing Strings in a Sequence
       4.4 Getting the Length of a String
       4.5 Reversing a String
       4.6 Splitting a String
       4.7 Tokenizing a String
       4.8 Joining a Sequence of Strings
       4.9 Finding Things in Strings
       4.10 Finding the nth Instance of a Substring
       4.11 Removing a Substring from a String
       4.12 Converting a String to Lower- or Uppercase
       4.13 Doing a Case-Insensitive String Comparison
       4.14 Doing a Case-Insensitive String Search
       4.15 Converting Between Tabs and Spaces in a Text File
       4.16 Wrapping Lines in a Text File
       4.17 Counting the Number of Characters, Words, and Lines in a Text File
       4.18 Counting Instances of Each Word in a Text File
       4.19 Add Margins to a Text File
       4.20 Justify a Text File
       4.21 Squeeze Whitespace to Single Spaces in a Text File
       4.22 Autocorrect Text as a Buffer Changes
       4.23 Reading a Comma-Separated Text File
       4.24 Using Regular Expressions to Split a String
5. Dates and Times
       5.1 Obtaining the Current Date and Time
       5.2 Formatting a Date/Time as a String
       5.3 Performing Date and Time Arithmetic
       5.4 Converting Between Time Zones
       5.5 Determining a Day's Number Within a Given Year
       5.6 Defining Constrained Value Types
6. Managing Data with Containers
       6.1 Using vectors Instead of Arrays
       6.2 Using vectors Efficiently
       6.3 Copying a vector
       6.4 Storing Pointers in a vector
       6.5 Storing Objects in a list
       6.6 Mapping strings to Other Things
       6.7 Using Hashed Containers
       6.8 Storing Objects in Sorted Order
       6.9 Storing Containers in Containers
7. Algorithms
       7.1 Iterating Through a Container
       7.2 Removing Objects from a Container
       7.3 Randomly Shuffling Data
       7.4 Comparing Ranges
       7.5 Merging Data
       7.6 Sorting a Range
       7.7 Partitioning a Range
       7.8 Performing Set Operations on Sequences
       7.9 Transforming Elements in a Sequence
       7.10 Writing Your Own Algorithm
       7.11 Printing a Range to a Stream
8. Classes
       8.1 Initializing Class Member Variables
       8.2 Using a Function to Create Objects (a.k.a. Factory Pattern)
       8.3 Using Constructors and Destructors to Manage Resources (or RAII)
       8.4 Automatically Adding New Class Instances to a Container
       8.5 Ensuring a Single Copy of a Member Variable
       8.6 Determining an Object's Type at Runtime
       8.7 Determining if One Object's Class Is a Subclass of Another
       8.8 Giving Each Instance of a Class a Unique Identifier
       8.9 Creating a Singleton Class
       8.10 Creating an Interface with an Abstract Base Class
       8.11 Writing a Class Template
       8.12 Writing a Member Function Template
       8.13 Overloading the Increment and Decrement Operators
       8.14 Overloading Arithmetic and Assignment Operators for Intuitive Class Behavior
       8.15 Calling a Superclass Virtual Function
9. Exceptions and Safety
       9.1 Creating an Exception Class
       9.2 Making a Constructor Exception-Safe
       9.3 Making an Initializer List Exception-Safe
       9.4 Making Member Functions Exception-Safe
       9.5 Safely Copying an Object
10. Streams and Files
       10.1 Lining Up Text Output
       10.2 Formatting Floating-Point Output
       10.3 Writing Your Own Stream Manipulators
       10.4 Making a Class Writable to a Stream
       10.5 Making a Class Readable from a Stream
       10.6 Getting Information About a File
       10.7 Copying a File
       10.8 Deleting or Renaming a File
       10.9 Creating a Temporary Filename and File
       10.10 Creating a Directory
       10.11 Removing a Directory
       10.12 Reading the Contents of a Directory
       10.13 Extracting a File Extension from a String
       10.14 Extracting a Filename from a Full Path
       10.15 Extracting a Path from a Full Path and Filename
       10.16 Replacing a File Extension
       10.17 Combining Two Paths into a Single Path
11. Science and Mathematics
       11.1 Computing the Number of Elements in a Container
       11.2 Finding the Greatest or Least Value in a Container
       11.3 Computing the Sum and Mean of Elements in a Container
       11.4 Filtering Values Outside a Given Range
       11.5 Computing Variance, Standard Deviation, and Other Statistical Functions
       11.6 Generating Random Numbers
       11.7 Initializing a Container with Random Numbers
       11.8 Representing a Dynamically Sized Numerical Vector
       11.9 Representing a Fixed-Size Numerical Vector
       11.10 Computing a Dot Product
       11.11 Computing the Norm of a Vector
       11.12 Computing the Distance Between Two Vectors
       11.13 Implementing a Stride Iterator
       11.14 Implementing a Dynamically Sized Matrix
       11.15 Implementing a Constant-Sized Matrix
       11.16 Multiplying Matricies
       11.17 Computing the Fast Fourier Transform
       11.18 Working with Polar Coordinates
       11.19 Performing Arithmetic on Bitsets
       11.20 Representing Large Fixed-Width Integers
       11.21 Implementing Fixed-Point Numbers
12. Multithreading
       12.1 Creating a Thread
       12.2 Making a Resource Thread-Safe
       12.3 Notifying One Thread from Another
       12.4 Initializing Shared Resources Once
       12.5 Passing an Argument to a Thread Function
13. Internationalization
       13.1 Hardcoding a Unicode String
       13.2 Writing and Reading Numbers
       13.3 Writing and Reading Dates and Times
       13.4 Writing and Reading Currency
       13.5 Sorting Localized Strings
14. XML
       14.1 Parsing a Simple XML Document
       14.2 Working with Xerces Strings
       14.3 Parsing a Complex XML Document
       14.4 Manipulating an XML Document
       14.5 Validating an XML Document with a DTD
       14.6 Validating an XML Document with a Schema
       14.7 Transforming an XML Document with XSLT
       14.8 Evaluating an XPath Expression
       14.9 Using XML to Save and Restore a Collection of Objects
15. Miscellaneous
       15.1 Using Function Pointers for Callbacks
       15.2 Using Pointers to Class Members
       15.3 Ensuring That a Function Doesn't Modify an Argument
       15.4 Ensuring That a Member Function Doesn't Modify Its Object
       15.5 Writing an Operator That Isn't a Member Function
       15.6 Initializing a Sequence with Comma-Separated Values