C Cookbook


book cover
C++ Cookbook
By Jeff Cogswell, Christopher Diggins, Ryan Stephens, Jonathan Turkanis
...............................................
Publisher: O'Reilly
Pub Date: November 2005
ISBN: 0-596-00761-2
Pages: 592
 



Table of Contents  | Index
overview

Despite its highly adaptable and flexible nature, C++ is also one of the more complex programming languages to learn. Once mastered, however, it can help you organize and process 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 writing 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 building blocks that you don't have to develop on your own.

Less a tutorial than a problem-solver, the book addresses many of the most common problems you're likely encounter--whether you've been programming in C++ for years or you're relatively new to the language. Here are just some of the time-consuming tasks this book contains practical solutions for:

  • Reading the contents of a directory

  • Creating a singleton class

  • Date and time parsing/arithmetic

  • String and text manipulation

  • Working with files

  • Parsing XML

  • Using the standard containers

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 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.



book cover
C++ Cookbook
By Jeff Cogswell, Christopher Diggins, Ryan Stephens, Jonathan Turkanis
...............................................
Publisher: O'Reilly
Pub Date: November 2005
ISBN: 0-596-00761-2
Pages: 592
 



Table of Contents  | Index

   Copyright
   Preface
      About the Examples
      Conventions Used in This Book
      Using Code Examples
      Comments and Questions
      Safari Enabled
      Acknowledgments
        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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
      Introduction
      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
   Colophon
   Index