C++ Cookbook – Jeff Cogswell, Christopher Diggins, Ryan Stephens, Jonathan Turkanis – 1st Edition


Despite its highly adaptable and flexible nature, C++ is also one of the more complex programming to learn. Once mastered, however, it can help you organize and information with amazing efficiency and quickness.

The C++ Cookbook will make your path to mastery much shorter. This practical, problem-solving guide is ideal if you’re an engineer, programmer, or researcher an application for one of the legions of platforms on which C++ runs. The algorithms provided in C++ Cookbook will jump-start your development by giving you some basic blocks that you don’t have to develop on your own.

Typical of O’Reilly’s “Cookbook” series, 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 works. This question-solution-discussion format is a proven teaching method, as any fan of the “Cookbook” series can attest to. This will move quickly to the top of your list of essential C++ references.

View more

Table of Contents

About the Examples
Conventions Used in This Book
Using Code Examples
Comments and Questions
Safari Enabled

Chapter 1. Building C++ Applications
Introduction to Building
Recipe 1.1. Obtaining and Installing GCC
Recipe 1.2. Building a Simple "Hello, World" Application from the Command Line
Recipe 1.3. Building a Static Library from the Command Line
Recipe 1.4. Building a Dynamic Library from the Command Line
Recipe 1.5. Building a Complex Application from the Command Line
Recipe 1.6. Installing Boost.Build
Recipe 1.7. Building a Simple "Hello, World" Application Using Boost.Build
Recipe 1.8. Building a Static Library Using Boost.Build
Recipe 1.9. Building a Dynamic Library Using Boost.Build
Recipe 1.10. Building a Complex application Using Boost.Build
Recipe 1.11. Building a Static Library with an IDE
Recipe 1.12. Building a Dynamic Library with an IDE
Recipe 1.13. Building a Complex Application with an IDE
Recipe 1.14. Obtaining GNU make
Recipe 1.15. Building A Simple "Hello, World" Application with GNU make
Recipe 1.16. Building a Static Library with GNU Make
Recipe 1.17. Building a Dynamic Library with GNU Make
Recipe 1.18. Building a Complex Application with GNU make
Recipe 1.19. Defining a Macro
Recipe 1.20. Specifying a Command-Line Option from Your IDE
Recipe 1.21. Producing a Debug Build
Recipe 1.22. Producing a Release Build
Recipe 1.23. Specifying a Runtime Library Variant
Recipe 1.24. Enforcing Strict Conformance to the C++ Standard
Recipe 1.25. Causing a Source File to Be Linked Automatically Against a Specified Library
Recipe 1.26. Using Exported Templates

Chapter 2. Code Organization
Recipe 2.1. Making Sure a Header File Gets Included Only Once
Recipe 2.2. Ensuring You Have Only One Instance of a Variable Across Multiple Source Files
Recipe 2.3. Reducing #includes with Forward Class Declarations
Recipe 2.4. Preventing Name Collisions with Namespaces
Recipe 2.5. Including an Inline File

Chapter 3. Numbers
Recipe 3.1. Converting a String to a Numeric Type
Recipe 3.2. Converting Numbers to Strings
Recipe 3.3. Testing Whether a String Contains a Valid Number
Recipe 3.4. Comparing Floating-Point Numbers with Bounded Accuracy
Recipe 3.5. Parsing a String Containing a Number in Scientific Notation
Recipe 3.6. Converting Between Numeric Types
Recipe 3.7. Getting the Minimum and Maximum Values for a Numeric Type

Chapter 4. Strings and Text
Recipe 4.1. Padding a String
Recipe 4.2. Trimming a String
Recipe 4.3. Storing Strings in a Sequence
Recipe 4.4. Getting the Length of a String
Recipe 4.5. Reversing a String
Recipe 4.6. Splitting a String
Recipe 4.7. Tokenizing a String
Recipe 4.8. Joining a Sequence of Strings
Recipe 4.9. Finding Things in Strings
Recipe 4.10. Finding the nth Instance of a Substring
Recipe 4.11. Removing a Substring from a String
Recipe 4.12. Converting a String to Lower- or Uppercase
Recipe 4.13. Doing a Case-Insensitive String Comparison
Recipe 4.14. Doing a Case-Insensitive String Search
Recipe 4.15. Converting Between Tabs and Spaces in a Text File
Recipe 4.16. Wrapping Lines in a Text File
Recipe 4.17. Counting the Number of Characters, Words, and Lines in a Text File
Recipe 4.18. Counting Instances of Each Word in a Text File
Recipe 4.19. Add Margins to a Text File
Recipe 4.20. Justify a Text File
Recipe 4.21. Squeeze Whitespace to Single Spaces in a Text File
Recipe 4.22. Autocorrect Text as a Buffer Changes
Recipe 4.23. Reading a Comma-Separated Text File
Recipe 4.24. Using Regular Expressions to Split a String

Chapter 5. Dates and Times
Recipe 5.1. Obtaining the Current Date and Time
Recipe 5.2. Formatting a Date/Time as a String
Recipe 5.3. Performing Date and Time Arithmetic
Recipe 5.4. Converting Between Time Zones
Recipe 5.5. Determining a Day's Number Within a Given Year
Recipe 5.6. Defining Constrained Value Types

Chapter 6. Managing Data with Containers
Recipe 6.1. Using vectors Instead of Arrays
Recipe 6.2. Using vectors Efficiently
Recipe 6.3. Copying a vector
Recipe 6.4. Storing Pointers in a vector
Recipe 6.5. Storing Objects in a list
Recipe 6.6. Mapping strings to Other Things
Recipe 6.7. Using Hashed Containers
Recipe 6.8. Storing Objects in Sorted Order
Recipe 6.9. Storing Containers in Containers

Chapter 7. Algorithms
Recipe 7.1. Iterating Through a Container
Recipe 7.2. Removing Objects from a Container
Recipe 7.3. Randomly Shuffling Data
Recipe 7.4. Comparing Ranges
Recipe 7.5. Merging Data
Recipe 7.6. Sorting a Range
Recipe 7.7. Partitioning a Range
Recipe 7.8. Performing Set Operations on Sequences
Recipe 7.9. Transforming Elements in a Sequence
Recipe 7.10. Writing Your Own Algorithm
Recipe 7.11. Printing a Range to a Stream

Chapter 8. Classes
Recipe 8.1. Initializing Class Member Variables
Recipe 8.2. Using a Function to Create Objects (a.k.a. Factory Pattern)
Recipe 8.3. Using Constructors and Destructors to Manage Resources (or RAII)
Recipe 8.4. Automatically Adding New Class Instances to a Container
Recipe 8.5. Ensuring a Single Copy of a Member Variable
Recipe 8.6. Determining an Object's Type at Runtime
Recipe 8.7. Determining if One Object's Class Is a Subclass of Another
Recipe 8.8. Giving Each Instance of a Class a Unique Identifier
Recipe 8.9. Creating a Singleton Class
Recipe 8.10. Creating an Interface with an Abstract Base Class
Recipe 8.11. Writing a Class Template
Recipe 8.12. Writing a Member Function Template
Recipe 8.13. Overloading the Increment and Decrement Operators
Recipe 8.14. Overloading Arithmetic and Assignment Operators for Intuitive Class Behavior
Recipe 8.15. Calling a Superclass Virtual Function

Chapter 9. Exceptions and Safety
Recipe 9.1. Creating an Exception Class
Recipe 9.2. Making a Constructor Exception-Safe
Recipe 9.3. Making an Initializer List Exception-Safe
Recipe 9.4. Making Member Functions Exception-Safe
Recipe 9.5. Safely Copying an Object

Chapter 10. Streams and Files
Recipe 10.1. Lining Up Text Output
Recipe 10.2. Formatting Floating-Point Output
Recipe 10.3. Writing Your Own Stream Manipulators
Recipe 10.4. Making a Class Writable to a Stream
Recipe 10.5. Making a Class Readable from a Stream
Recipe 10.6. Getting Information About a File
Recipe 10.7. Copying a File
Recipe 10.8. Deleting or Renaming a File
Recipe 10.9. Creating a Temporary Filename and File
Recipe 10.10. Creating a Directory
Recipe 10.11. Removing a Directory
Recipe 10.12. Reading the Contents of a Directory
Recipe 10.13. Extracting a File Extension from a String
Recipe 10.14. Extracting a Filename from a Full Path
Recipe 10.15. Extracting a Path from a Full Path and Filename
Recipe 10.16. Replacing a File Extension
Recipe 10.17. Combining Two Paths into a Single Path

Chapter 11. Science and Mathematics
Recipe 11.1. Computing the Number of Elements in a Container
Recipe 11.2. Finding the Greatest or Least Value in a Container
Recipe 11.3. Computing the Sum and Mean of Elements in a Container
Recipe 11.4. Filtering Values Outside a Given Range
Recipe 11.5. Computing Variance, Standard Deviation, and Other Statistical Functions
Recipe 11.6. Generating Random Numbers
Recipe 11.7. Initializing a Container with Random Numbers
Recipe 11.8. Representing a Dynamically Sized Numerical Vector
Recipe 11.9. Representing a Fixed-Size Numerical Vector
Recipe 11.10. Computing a Dot Product
Recipe 11.11. Computing the Norm of a Vector
Recipe 11.12. Computing the Distance Between Two Vectors
Recipe 11.13. Implementing a Stride Iterator
Recipe 11.14. Implementing a Dynamically Sized Matrix
Recipe 11.15. Implementing a Constant-Sized Matrix
Recipe 11.16. Multiplying Matricies
Recipe 11.17. Computing the Fast Fourier Transform
Recipe 11.18. Working with Polar Coordinates
Recipe 11.19. Performing Arithmetic on Bitsets
Recipe 11.20. Representing Large Fixed-Width Integers
Recipe 11.21. Implementing Fixed-Point Numbers

Chapter 12. Multithreading
Recipe 12.1. Creating a Thread
Recipe 12.2. Making a Resource Thread-Safe
Recipe 12.3. Notifying One Thread from Another
Recipe 12.4. Initializing Shared Resources Once
Recipe 12.5. Passing an Argument to a Thread Function

Chapter 13. Internationalization
Recipe 13.1. Hardcoding a Unicode String
Recipe 13.2. Writing and Reading Numbers
Recipe 13.3. Writing and Reading Dates and Times
Recipe 13.4. Writing and Reading Currency
Recipe 13.5. Sorting Localized Strings

Chapter 14. XML
Recipe 14.1. Parsing a Simple XML Document
Recipe 14.2. Working with Xerces Strings
Recipe 14.3. Parsing a Complex XML Document
Recipe 14.4. Manipulating an XML Document
Recipe 14.5. Validating an XML Document with a DTD
Recipe 14.6. Validating an XML Document with a Schema
Recipe 14.7. Transforming an XML Document with XSLT
Recipe 14.8. Evaluating an XPath Expression
Recipe 14.9. Using XML to Save and Restore a Collection of Objects

Chapter 15. Miscellaneous
Recipe 15.1. Using Function Pointers for Callbacks
Recipe 15.2. Using Pointers to Class Members
Recipe 15.3. Ensuring That a Function Doesn't Modify an Argument
Recipe 15.4. Ensuring That a Member Function Doesn't Modify Its Object
Recipe 15.5. Writing an Operator That Isn't a Member Function
Recipe 15.6. Initializing a Sequence with Comma-Separated Values

Leave us a commentNo Comments

Inline Feedbacks
View all comments
Would love your thoughts, please comment.x