Exploring C++: The Programmer's Introduction to C++

Code Listings

The following lists all the code examples from the book (with one deliberate omission—see Exploration 1 for details). A number of projects develop over the course of an exploration or multiple explorations. See the final versions of these files. See also the projects.

• Exploration 1—Honing Your Tools
  • Listing 1-1. Your First C++ Program
  • Listing 1-2. Testing Your Compiler
• Exploration 2—Reading C++ Code
  • Listing 2-1. Reading Test
  • Listing 2-2. Demonstrating Comment Styles and Nesting
  • Listing 2-3. Determining the Number of Bits in a bool.
• Exploration 3—Integer Expressions
  • Listing 3-1. Integer Arithmetic
  • Listing 3-2. Print Average, Testing for a Zero Count
  • Listing 3-3. Testing for Even or Odd Integers
  • Listing 3-4. Testing for Even or Odd Integers
  • Listing 3-5. Print Average, Testing for a Zero Count
• Exploration 4—Strings
  • Listing 4-1. Different Styles of String Output
  • Listing 4-2. Print a Double-quote Character
  • Listing 4-3. Adding Triangle and Keeping the Columns Aligned
  • Listing 4-4. Printing Information That Is Stored in Variables
  • Listing 4-5. Defining and Printing an Empty String
  • Listing 4-6. Demonstrating Uninitialized Variables
• Exploration 5—Simple Input
  • Listing 5-1. Demonstrating Input and Output
  • Listing 5-2. Reading Strings
  • Listing 5-3. Getting the User's Name and Age
  • Listing 5-4. Getting the User's Age and Then Name
• Exploration 6—Error Messages
  • Listing 6-1. Deliberate Errors
• Exploration 7—For Loops
  • Listing 7-1. Using a for Loop to Print Ten Non-negative Numbers
  • Listing 7-2. You Cannot Use the Loop Control Variable Outside the Loop
  • Listing 7-3. Using and Reusing a Loop Control Variable Name
  • Listing 7-4. Compute Sum of Integers from 10 to 20
  • Listing 7-5. Compute Sum of Integers from 10 to 20 (Completed)
• Exploration 8—Formatted Output
  • Listing 8-1. Print a Table of Squares and Cubes
  • Listing 8-2. Printing a Table of Powers the Right Way
  • Listing 8-3. Using Alternative Fill Characters
  • Listing 8-4. Exploring Field Width, Padding, and Alignment
  • Listing 8-5. Program to Produce Formatted Output
  • Listing 8-6. A copy of Listing 8-5, but Using Member Functions
  • Listing 8-7. Printing a Multiplication Table
• Exploration 9—Arrays
  • Listing 9-1. Sorting Integers
  • Listing 9-2. Demonstrating the std::copy Function
  • Listing 9-3. Sorting Integers, Using Iterators to Print the Results
  • Listing 9-4. Sorting Integers by Using Only Generic Algorithms and Iterator Adapters
  • Listing 9-5. Doubling Input Values in a Vector
  • Listing 9-6. Doubling Input Values in a Vector
• Exploration 10—Increment and Decrement
  • Listing 10-1. Demonstrating the Difference Between Prefix and Postfix Increment
  • Listing 10-2. Erroneous Program that Applies Decrement to an Output Iterator
  • Listing 10-3. Reversing the Input Order
  • Listing 10-4. Rewriting the for Loop
  • Listing 10-5. Taking Advantage of the Standard Library
• Exploration 11—Conditions and Logic
  • Listing 11-1. Printing bool Values
  • Listing 11-2. Automatic Type Conversion to bool
  • Listing 11-3. Converting a std::string to bool
  • Listing 11-4. Using Short-circuiting to Test for Non-zero Vector Elements
  • Listing 11-5. Comparing Vectors
  • Listing 11-6. Demonstrating How C++ Compares Strings
• Exploration 12—Compound Statements
  • Listing 12-1. Finding Statement Errors
  • Listing 12-2. Local Variable Definitions
  • Listing 12-3. Local Variable Definitions in a Nested Block
  • Listing 12-4. Mystery Function
• Exploration 13—Introduction to File I/O
  • Listing 13-1. Copying Integers from a File to Standard Output
  • Listing 13-2. Copying Integers from a Named File to a Named File
  • Listing 13-3. Copying Integers, with Minimal Error-checking
• Exploration 14—Maps
  • Listing 14-1. Counting Occurrences of Unique Words
  • Listing 14-2. Printing Word Frequencies
  • Listing 14-3. Aligning Words and Counts Neatly
  • Listing 14-4. Searching for a Word in a Map
• Exploration 15—Type Synonyms
  • Listing 15-1. Counting Words, with a Clean Program That Uses typedef
• Exploration 16—Characters
  • Listing 16-1. Working and Playing with Characters
  • Listing 16-2. Echoing Input to Output, One Character at a Time
  • Listing 16-3. Finding the Points with Largest x and y Values
• Exploration 17—Character Categories
  • Listing 17-1. Counting Words, Restricting Words to Letters and Letter-like Characters
  • Listing 17-2.Testing a Character by Calling isalnum
  • Listing 17-3. Using the Native Locale for Output
  • Listing 17-4. Creating and sharing a single locale object.
• Exploration 18—Case-Folding
  • Listing 18-1. Folding Uppercase to Lowercase Prior to Counting Words
• Exploration 19—Writing Functions
  • Listing 19-1. Examples of Functions
  • Listing 19-2. Separating Function Declarations from Definitions
  • Listing 19-3. Using Functions to Clarify the Word-Counting Program
• Exploration 20—Function Arguments
  • Listing 20-1. Function Arguments and Parameters
  • Listing 20-2. Pass Parameters by Reference
• Exploration 21—Using Algorithms
  • Listing 21-1. Calling transform to Apply a Function to Each Element of an Array
  • Listing 21-2. New main Function that Sets the Global Locale
  • Listing 21-3. Sanitizing a String by Transforming It
  • Listing 21-4. Sorting into Descending Order
  • Listing 21-5. Testing for Palindromes
• Exploration 22—Overloading Function Names
  • Listing 22-1. Printing Vectors by Using Overloaded Functions
  • Listing 22-2. Overloading Functions in the Manner of a Library-Writer
• Exploration 23—Big and Little Numbers
  • Listing 23-1. Discovering the Number of Bits in an Integer
  • Listing 23-2. Revealing the Number of Bits in Short and Long Integers
  • Listing 23-3. Using Overloading to Distinguish Types of Integer Literals
  • Listing 23-4. Using Type Casts
  • Listing 23-5. Overloading Prefers Type Promotion over Type Conversion
• Exploration 24—Very Big and Very Little Numbers
  • Listing 24-1. Floating-Point Numbers Do Not Always Behave as You Expect
  • Listing 24-2. Discovering the Attributes of a Floating-Point Type
  • Listing 24-3. Demonstrating Floating-Point Output
• Exploration 25—Documentation
  • Listing 25-1. Documenting Your Code with Doxygen
• Exploration 26—Project 1: Body-Mass Index
  • Listing 26-1. Sample User Session with the BMI Program
• Exploration 27—Custom Types
  • Listing 27-1. Defining a Custom rational Type
  • Listing 27-2. Using a Class and Its Members
  • Listing 27-3. Adding the reduce Member Function
  • Listing 27-4. Adding the assign Member Function
  • Listing 27-5. Adding the Ability to Initialize a rational Object
  • Listing 27-6. Modifying the reduce Member Function to Accept a Negative Denominator
  • Listing 27-7. Constructing a Rational Object from an Integer
• Exploration 28—Overloading Operators
  • Listing 28-1. Overloading the Equality Operator
  • Listing 28-2. Using inline for Trivial Functions
  • Listing 28-3. Implementing the < Operator for rational
  • Listing 28-4. Implementing the > and >= Operators in Terms of <
  • Listing 28-5. Testing the rational Comparison Operators
  • Listing 28-6. Addition Operator for the rational Type
  • Listing 28-7. Arithmetic Operators for the rational Type
  • Listing 28-8. Test Program for Multiplying an Integer and a Rational Number
  • Listing 28-9. Constructing a Rational Number from a Floating-point Argument
  • Listing 28-10. Optimizing Operators for a Specific Operand Type
  • Listing 28-11. Computing the Absolute Value of a Rational Number
  • Listing 28-12. Converting to Floating-point Types
• Exploration 29—Custom I/O Operators
  • Listing 29-1. Input Operator
  • Listing 29-2. Output Operator
  • Listing 29-3. Testing the I/O Operators
• Exploration 30—Assignment and Initialization
  • Listing 30-1. First Version of the Assignment Operator
  • Listing 30-2. Assignment Operator with Explicit Use of this->
  • Listing 30-3. Assignment of an Integer to a Rational
  • Listing 30-4. Overloaded Constructors for rational
  • Listing 30-5. Complete Definition of rational and Its Operators
• Exploration 31—Writing Classes
  • Listing 31-1. Class Definition for a Cartesian Point
  • Listing 31-2. Multiple Data Members in one Declaration
  • Listing 31-3. Using a Class and its Members
  • Listing 31-4. Member Functions for Class point
  • Listing 31-5. Constructors for Class point
  • Listing 31-6. Visual Constructors
• Exploration 32—More About Member functions
  • Listing 32-1. Mystery Program
  • Listing 32-2. Constructing a vector from Two Read Iterators
  • Listing 32-3. Problem with istream Iterators
  • Listing 32-4. New BMI Program
  • Listing 32-5. Adding the const Modifier to print
  • Listing 32-6. const Member Functions for Class point
  • Listing 32-7. Calling const and Non-const Member Functions
• Exploration 33—Access Levels
  • Listing 33-1. The point Class with Access Level Specifiers
  • Listing 33-2. The point Class Changed to Store Polar Coordinates
  • Listing 33-3. The point Class Defined with the class Keyword
  • Listing 33-4. The Latest Rewrite of the rational Class
• Exploration 34—Introduction to Object-Oriented Programming
• Exploration 35—Inheritance
  • Listing 35-1. Defining a Derived Class
  • Listing 35-2. Printing Messages from Constructors to Illustrate Order of Construction
  • Listing 35-3. Order of Calling Destructors
  • Listing 35-4. Constructors and Destructors
  • Listing 35-5. Accidentally Inheriting Privately
• Exploration 36—Virtual Functions
  • Listing 36-1. Adding a Polymorphic print Function to Every Class Derived from work
  • Listing 36-2. Calling the print Function
  • Listing 36-3. Output Operator for Class work
  • Listing 36-4. Adding a Class movie
  • Listing 36-5. Using the New movie Class
  • Listing 36-6. Adding a print Member Function to the movie Class
  • Listing 36-7. Defining work as an Abstract Class.
• Exploration 37—Classes and Types
  • Listing 37-1. Computing BMI
  • Listing 37-2. Defining Classes for height and weight
  • Listing 37-3. The color Class
• Exploration 38—Declarations and Definitions
  • Listing 38-1. Declarations and Definitions of Member Functions
  • Listing 38-2. The rational Class with inline Member Functions
  • Listing 38-3. Declaring and Using References
  • Listing 38-4. Finding the Mode of a Data Set
  • Listing 38-5. Generating Unique Identification Numbers
  • Listing 38-6. Calling generate_id to Demonstrate Static Variables
  • Listing 38-7. Declaring counter Outside of the generate_id Function
  • Listing 38-8. Declaring and Defining Static Data Members
  • Listing 38-9. Using Static Data Members for an ID Generator
• Exploration 39—Using Multiple Source Files
  • Listing 39-1. The Definition of generate_id's Members in generate_id.cpp
  • Listing 39-2. The main Function for the ID-generating Program in the main.cpp file
  • Listing 39-3. Renaming a Member Function Only in main.cpp
  • Listing 39-4. Adding a New Data Member Only in main.cpp
  • Listing 39-5. The #include File for the generate_id Class
  • Listing 39-6. Rewrite of generate_id.cpp to #include the generate_id.hpp File
  • Listing 39-7. Rewriting main.cpp to #include the generate_id.hpp file
  • Listing 39-8. The vital_stats Class to Record a Person's Vital Statistics
  • Listing 39-9. The vital_stats.hpp Header File
  • Listing 39-10. The vital_stats.cpp Source File
  • Listing 39-11. Simple Header for Math Constants
  • Listing 39-12. Definitions of Math Constants
  • Listing 39-13. The Original point.hpp File
• Exploration 40—Function Objects
  • Listing 40-1. Rewriting generate_id to Use the Function Call Operator
  • Listing 40-2. Implementation of the generate_id Function Call Operator
  • Listing 40-3. Using a generate_id Object's Function Call Operator
  • Listing 40-4. Rewriting the sanitize Function to Make Use of Function Objects
  • Listing 40-5. Rewriting the sanitize Function as a Function Object
  • Listing 40-6. Extracting BMI Values
  • Listing 40-7. The Functor Class Created by mem_fun_ref
  • Listing 40-8. The Main Program for Generating Successive Integers.
  • Listing 40-9. The sequence.hpp file
• Exploration 41—Useful Algorithms
  • Listing 41-1. Searching for an Integer
  • Listing 41-2. The data.hpp File to Support Integer Data
  • Listing 41-3. Functor intrange to Test Whether an Integer Lies Within a Certain Range
  • Listing 41-4. Using find_if and intrange to Find an Integer That Lies Within a Range
  • Listing 41-5. Finding a Subrange that Matches the First Four Digits of π
  • Listing 41-6. Searching for an Integer Using Binary Search
  • Listing 41-7. Exploring the lower_bound and upper_bound Functions
  • Listing 41-8. Testing Various Comparison Algorithms
  • Listing 41-9. Using replace_if and intrange to Replace All Integers in [10, 20] with 0
  • Listing 41-10. Shuffling Integers into Random Order
  • Listing 41-11. Erasing Elements from a Vector
• Exploration 42—Iterators
  • Listing 42-1. Comparing Iterators by Using the < Operator
  • Listing 42-2. Advancing an Iterator
  • Listing 42-3. Printing the Middle Item of a Series of Integers
  • Listing 42-4. Really Printing the Middle Item of a Series of Integers
  • Listing 42-5. Negating the Middle Value in a Series of Integers
  • Listing 42-6. Revealing the Implementation of reverse_iterator
  • Listing 42-7. You Can't erase with a const_iterator
• Exploration 43—Exceptions
  • Listing 43-1. Accessing an Element of a Vector
  • Listing 43-2. A Bad Way to Access an Element of a Vector
  • Listing 43-3. Forcing a string to Throw Exceptions
  • Listing 43-4. Visualizing an Exception
  • Listing 43-5. Using an I/O Stream Exception Mask
  • Listing 43-6. Throwing an Exception for a Zero Denominator
  • Listing 43-7. Checking for a Zero Denominator in reduce()
• Exploration 44—More Operators
  • Listing 44-1. Using Conditional Expressions in a Constructor's Initializer
  • Listing 44-2. Using a Function and Conditional Statements Instead of Conditional Expressions
  • Listing 44-3. Searching for a Matching Subrange in a Vector of Integers
  • Listing 44-4. The search Function Without Using the Comma Operator
  • Listing 44-5. Implementing the Multiplication Operator
  • Listing 44-6. Reimplementing Multiplication in Terms of an Assignment Operator
  • Listing 44-7. Other Arithmetic Assignment Operators
  • Listing 44-8. The Prefix Increment Operator for rational
  • Listing 44-9. Postfix Increment and Decrement Operators
  • Listing 44-10. The rational Class Definition
• Exploration 45—Project 2: Fixed-point Numbers
  • Listing 45-1. Testing the fixed Class
• Exploration 46—Function Templates
  • Listing 46-1. Writing an Absolute Value Function
  • Listing 46-2. Writing a Function Template
  • Listing 46-3. Testing the absval Function Template
  • Listing 46-4. Mystery Function Template
  • Listing 46-5. One Way to Implement the copy Algorithm
  • Listing 46-6. Implementing the find Algorithm
  • Listing 46-7. The std::min Algorithm
  • Listing 46-8. Multiple Template Arguments
  • Listing 46-9. The gcd Function Template
  • Listing 46-10. Implementing a Member Function Template
• Exploration 47—Class Templates
  • Listing 47-1. The point Class Template
  • Listing 47-2. The move_by Member Function
  • Listing 47-3. The rational Class Template
  • Listing 47-4. Trying to Use a Vector of Vectors
  • Listing 47-5. Simple I/O Test of the rational Class Template
  • Listing 47-6. Testing rational Comparison Operator
  • Listing 47-7. Invoking a Default Constructor of a Template Parameter
  • Listing 47-8. Trying to Mix rational Base Types
  • Listing 47-9. Defining the Assignment Operator Function Template
  • Listing 47-10. Defining a Member Constructor Template
• Exploration 48—Template Specialization
  • Listing 48-1. The point Class Template
  • Listing 48-2. The point<int> Specialization
  • Listing 48-3. Specializing point<double> and Testing the Code
  • Listing 48-4. Specializing std::less to Compare person Objects by Name
  • Listing 48-5. The Primary std::less Class Template
  • Listing 48-6. Specializing numeric_limits for the rational Class
• Exploration 49—Partial Specialization
  • Listing 49-1. The std::pair Class Template
  • Listing 49-2. Specializing pair<> for Two void Arguments
  • Listing 49-3. Specializing pair for One void Argument
  • Listing 49-4. Specializing pair for the Other void Argument
  • Listing 49-5. Changing fixed from a Class to a Class Template
  • Listing 49-6. Specializing fixed for N == 0
• Exploration 50—Names and Namespaces
  • Listing 50-1. Defining the rational Class Template in the numeric Namespace
  • Listing 50-2. Defining the fixed Class Template in the numeric Namespace
  • Listing 50-3. Defining Entities in a Namespace
  • Listing 50-4. Coping with Conflicting Names
  • Listing 50-5. Examples of using Directives
  • Listing 50-6. Examples of using Declarations
  • Listing 50-7. Comparing a using Directive with a using Declaration
  • Listing 50-8. Examples of using Declarations
  • Listing 50-9. Reading and Writing Tokens
  • Listing 50-10. Move the I/O Operators into the parser Namespace
  • Listing 50-11. Counting Occurrences of Tokens
• Exploration 51—Containers
  • Listing 51-1. Specializing the hash Template for the rational Type
  • Listing 51-2. Using a Hint Position When Inserting into a Set
  • Listing 51-3. Erasing Elements from a Sequence Container
  • Listing 51-4. Testing the erase_less Function Template
  • Listing 51-5. The Card Class, to Represent a Playing Card
  • Listing 51-6. Playing High-Card with an array
  • Listing 51-7. Playing High-Card with a deque
  • Listing 51-8. Playing High-Card with a list
  • Listing 51-9. Playing High-Card with a vector
  • Listing 51-10. Playing High-Card with a set
  • Listing 51-11. Playing High-Card Using an Explicit Specialization of std::less
  • Listing 51-12. Playing High-Card with an unordered_set
• Exploration 52—Wide Characters
  • Listing 52-1. Supporting Cast for the is_palindrome Function Template
  • Listing 52-2. Changing is_palindrome to a Function Template
  • Listing 52-3. The main Program for Testing is_palindrome
• Exploration 53—Locales and Facets
  • Listing 53-1. Reading and Writing Currency Using the Money Facets
  • Listing 53-2. Exploring Character Sets and Locales
  • Listing 53-3. Result of Running the Program in Listing 53-2
  • Listing 53-4. Caching the ctype Facet
  • Listing 53-5. Counting Words Again, This Time with Cached Facets
  • Listing 53-6. Demonstrating How Collation Order Depends on Locale
  • Listing 53-7. Testing Collation Order of Wide Strings
• Exploration 54—Text I/O
  • Listing 54-1. Header That Declares a Trivial Debugging Function
  • Listing 54-2. Implementing the Debug Function
  • Listing 54-3. Computing Miles-Per-Gallon
  • Listing 54-4.Computing Liters-Per-Kilometer
  • Listing 54-5. Rewriting the Miles-Per-Gallon Program to Parse a String Stream
  • Listing 54-6. Parsing Comments in the Miles-Per-Gallon Data File
  • Listing 54-7. Allowing Comments Anywhere in the Miles-Per-Gallon Data File
  • Listing 54-8. Adding Error-Checking for Each Line of Input
  • Listing 54-9. The from_string Function Extracts a Value from a String
  • Listing 54-10. The to_string Function Converts a Value to a String
  • Listing 54-11. Rewriting to_string as a Template Function
  • Listing 54-12. Demonstrating the Use of to_string
  • Listing 54-13. Passing the Destination String as an Argument to to_string
  • Listing 54-14. Improving the Calling Interface of to_string
  • Listing 54-15. Improving from_string by Adding Some Error-Checking
• Exploration 55—Project 3: Currency Type
• Exploration 56—Pointers
  • Listing 56-1. Topological Sort of a Directed Acyclic Graph
  • Listing 56-2. First Draft of the Pseudo-Make Program
  • Listing 56-3. New Definition of an Artifact
  • Listing 56-4. Second Draft, Adding Modification Times to Artifacts
  • Listing 56-5. Storing Pointers in the Dependency Graph
• Exploration 57—Dynamic Memory
  • Listing 57-1. Defining the list Class Template
  • Listing 57-2. Implementing list::push_back and list::pop_back
  • Listing 57-3. Expanding Variables
  • Listing 57-4. Parsing Variable Definitions
  • Listing 57-5. Adding Variable Storage and Lookup to the artifact Class
  • Listing 57-6. The variables.hpp File
  • Listing 57-7. The variables.cpp File Implements the expand Function
  • Listing 57-8. Adding Per-Target Variables to parse_graph
  • Listing 57-9. Simple Wrapper for Dynamic Memory
  • Listing 57-10. Making a Deep Copy
• Exploration 58—Exception-safety
  • Listing 58-1. Silly Program to Demonstrate Memory Leaks
  • Listing 58-2. Adding Delete Expressions to the Silly Program
  • Listing 58-3. Demonstrating Issues with Exceptions and Dynamic Memory
  • Listing 58-4. Using the auto_ptr Class Template
  • Listing 58-5. Fixing Memory Leaks
  • Listing 58-6. Demonstrating Constructors That Throw Exceptions
  • Listing 58-7. Using auto_ptr in bomb
  • Listing 58-8. Mystery Program That Uses auto_ptr
• Exploration 59—Old-Fashioned Arrays
  • Listing 59-1. Array Type in Function Parameters
  • Listing 59-2. Echoing Command-Line Arguments
  • Listing 59-3. Copying a File Named on the Command-Line
  • Listing 59-4. Using Pointer Arithmetic to Determine the Length of a C String
• Exploration 60—Smart Pointers
  • Listing 60-1. Copying an auto_ptr Object (Or Not)
  • Listing 60-2. The Correct Way to Copy auto_ptr Objects
  • Listing 60-3. Working with shared_ptr
  • Listing 60-4. Using Smart Pointers to Manage Artifacts
  • Listing 60-5. Defining an artifact Pimpl Wrapper Class
  • Listing 60-6. Implementing the artifact Class
  • Listing 60-7. Defining the Artifact Implementation Class
  • Listing 60-8. The artifact_impl.cpp Source File
  • Listing 60-9. Rewriting the Program to Use the New artifact Value Class
• Exploration 61—Bits and Bytes
  • Listing 61-1. An Initial Definition of Formatting Flags
  • Listing 61-2. A Simple Implementation of the setf Member Function
  • Listing 61-5. Declarations for Formatting Fields
  • Listing 61-6. Two-Argument Form of the setf Function
  • Listing 61-7. Using Shift Operators to Define the Formatting Fields
  • Listing 61-8. Exploring how Negative and Unsigned Values are Shifted
  • Listing 61-9. Mystery Program
  • Listing 61-10. Another Mystery Program
  • Listing 61-11. Fixing the Second Mystery Program
  • Listing 61-12. Declaring Formatting Flags with Bitfields
  • Listing 61-13. Example of Using std::bitset
  • Listing 61-14. The find_pair Function and Test Program
• Exploration 62—Enumerations
  • Listing 62-1. The language Class with Error-Checked Successor Functions
  • Listing 62-2. The Language Class with Comparison and Assignment
  • Listing 62-3. The Language Class with String Conversion
  • Listing 62-4. The Language Class with All Enhancements
  • Listing 62-5. The language.cpp File Initializes the Language Data Structures
  • Listing 62-6. Just the I/O Operators for a Language Object
  • Listing 62-7. Program to Test the language Class
  • Listing 62-8. Improving the card Class with Enumerations
• Exploration 63—Multiple Inheritance
  • Listing 63-1. Demonstrating the Order of Initialization of Base Classes
  • Listing 63-2. Changing the Inheritance of Visible to Virtual
  • Listing 63-3. The Hashable Interface in C++
  • Listing 63-4. The HashableString Class
  • Listing 63-5. Undefined Behavior Arises from HashableString That Derives from std::string
  • Listing 63-6. The hash<> Class Template
  • Listing 63-7. Rewriting string_pool to Use hash<>
  • Listing 63-8. The assignment_mixin Class Template
  • Listing 63-9. Using mix-in Class Template
  • Listing 63-10. The comparison_mixin and equality_mixin Class Templates
  • Listing 63-11. The thing Class with All of Its Mix-ins.
• Exploration 64—Policies and Traits
  • Listing 64-1. One Possible Implementation of std::advance
  • Listing 64-2. Example Program to Use the my_advance Function
  • Listing 64-3. Specializing iterator_advancer for Random Access Iterators
  • Listing 64-4. Using Character Traits When Copying Input to Output
  • Listing 64-5. The newstring Class Template
  • Listing 64-6. The vector_storage Class Template
  • Listing 64-7. The deque_storage Class Template
  • Listing 64-8. The array_storage Class Template
  • Listing 64-9. The array_storage Class Template, Based on array<>
  • Listing 64-10. Quick and Dirty I/O Functions for newstring
• Exploration 65—Names and Templates
  • Listing 65-1. Simple Overload of abs for rational Arguments
  • Listing 65-2. Hypothetical Arbitrary-Size Integer Class
  • Listing 65-3. Equivalent Code to the Instantiation of abs(rational<integer>)
  • Listing 65-4. Rewriting abs to Take Advantage of a Using Declaration
  • Listing 65-5. Using an Unqualified Name in a Function Template
  • Listing 65-6. Reordering Functions Affects Name Lookup in Function Templates
  • Listing 65-7. Qualifying Dependent Names
  • Listing 65-8. Fix the Mistakes
• Exploration 66—Overloaded Functions
  • Listing 66-1. Qualifying a Member Function with the base Class Name
  • Listing 66-2. Overloading Named with a using Declaration
  • Listing 66-3. Adding a Base Class Overload
  • Listing 66-4. Determining Candidate Functions for Overload Resolution
  • Listing 66-5. Fix the Overloading Errors
  • Listing 66-6. Default Arguments
• Exploration 67—Metaprogramming
  • Listing 67-1. Excerpt of the fixed Class Template
  • Listing 67-2. Simple Implementation of the power10 Class Template
  • Listing 67-3. Testing the power10 Class Template
  • Listing 67-4. Computing a Power of 10 Efficiently
  • Listing 67-5. The fixed Class Template
  • Listing 67-6. Using Metaprogramming to Implement vector's insert Function
  • Listing 67-7. Testing Two Types to See Whether They Are the Same
• Exploration 68—Project 4: Calculator