Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

! (logical NOT) operator, if Statement, Logical Operators
!= (not equal to) operator, if Statement, Relational Operators
# (preprocess) operator, The # Operator
## diagnostic tag, Debugging
#define macro, Templates: The Hard Way
% (modulus) operator, Simple Expressions, Binary Arithmetic Operators
%= (modulus into) operator, Operators for Performing Shortcuts, Shortcut Operators
%c conversion, The std::printf Family of Output Functions
%d conversion, The std::printf Family of Output Functions
%e conversion, The std::printf Family of Output Functions
%f conversion, The std::printf Family of Output Functions
%ld conversion, The std::printf Family of Output Functions
%lu conversion, The std::printf Family of Output Functions
%o conversion, The std::printf Family of Output Functions
%s conversion, The std::printf Family of Output Functions
%u conversion, The std::printf Family of Output Functions
%x conversion, The std::printf Family of Output Functions
& (address of) operator, Binary Arithmetic Operators
& (for reference variables), Constant and Reference Declarations
& (address of) operator, Simple Pointers, Unary Operators
& (bitwise AND) operator, The AND Operator (&)–The AND Operator (&), Binary Arithmetic Operators
&& (logical AND) operator, if Statement, Logical Operators
&= (AND into) operator, Shortcut Operators
( ) (default class function) operator, Exotic Operators
overloading, Overloading the ( ) Operator
( ) parentheses
with macro parameters, Parameterized Macros
and simple operators, Simple Expressions
* (dereference) operator, Simple Pointers, Unary Operators
* (multiplication) operator, Simple Expressions, Binary Arithmetic Operators
*= (multiply by) operator, Operators for Performing Shortcuts, Shortcut Operators
+ (addition) operator, Simple Expressions, Binary Arithmetic Operators
+ (positive) operator, Unary Operators
+ (string concatenation) operator, Strings
++ (increment) operator, Operators for Performing Shortcuts, Increment and Decrement Operators
x++ vs. ++x, Side Effects
+= (increase) operator, Operators for Performing Shortcuts, Shortcut Operators
, (comma) operator, Exotic Operators, The Comma Operator
- (for command-line options), Command-Line Arguments
- (negative) operator, Unary Operators
- (subtraction) operator, Binary Arithmetic Operators
- (unary) operator, Binary Arithmetic Operators
-- (decrement) operator, Operators for Performing Shortcuts, Increment and Decrement Operators
-= (decrease) operator, Operators for Performing Shortcuts, Shortcut Operators
-> (class member) operator, Exotic Operators
-> (structure pointer) operator, Linked Lists
->* (pointer to member) operator, Exotic Operators
. (dot) operator, Linked Lists
/ (division) operator, Simple Expressions, Floating-Point Divide Versus Integer Divide, Binary Arithmetic Operators
/* */ comment markers, Comments
“//fall through” comment, switch Statement
/= (divide into) operator, Operators for Performing Shortcuts, Shortcut Operators
: construct, The ?: Construct
:: (scope) operator, Derived Classes, Pointers to Members
; (semicolon), Basic Program Structure
with if-else statements, else Statement
and preprocessor directives, #define Statement
< (less than) operator, if Statement, Relational Operators
<< (left shift) operator, The Left and Right Shift Operators (<<, >>), Binary Arithmetic Operators
<< (number-to-character) operator, Conversion Routines
<< (output) operator, The std::cout Output Object, C-Style Conversion Routines, Operator Functions, I/O Operators
<<= (shift left) shortcut operator, Shortcut Operators
<= (less than or equal to) operator, if Statement, Relational Operators
= (assignment) operator, Assignment Statements
for classes, Automatically Generated and Used Functions
versus == (equal to) operator, Answers to Chapter Questions
== (equal to) operator, if Statement, Relational Operators
versus = (assignment) operator, Answers to Chapter Questions
> (greater than) operator, if Statement, Relational Operators
>= (greater than or equal to) operator, if Statement, Relational Operators
>> (character-to-number) operator, Binary and ASCII Files
>> (input) operator, Reading Data, C-Style Conversion Routines, Operator Functions, I/O Operators
>> (right shift) operator, The Left and Right Shift Operators (<<, >>), Binary Arithmetic Operators
>>= (shift right) shortcut operator, Shortcut Operators
? construct, The ?: Construct
[ ] (index) operator, Index Operator “[ ]”
(backslash)
as escape character, Characters
in preprocessor directives, #define Statement
character, C-Style Strings, Splitting a C-Style String
 (backspace character), Characters
f (form-feed character), Characters
(newline character), Characters
(return character), Characters
(tab character), Characters
^ (exclusive OR) operator, The Bitwise Exclusive OR (^), Binary Arithmetic Operators
^= (exclusive OR into) operator, Shortcut Operators
{ } (curly braces), Initializing Variables, if Statement
and structures, Structures
| (bitwise OR) operator, Bitwise OR (|), Binary Arithmetic Operators
to merge flags, Unbuffered I/O
|= (OR into) operator, Shortcut Operators
|| (logical OR) operator, if Statement, Logical Operators
~ (bitwise NOT) operator, The Ones Complement Operator (NOT) (~), Unary Operators
~ (tilde) in class destructor names, Destructors

A

abstract classes, Virtual Functions, Statistics Class, stat Class
stat class, stat Class–stat Class
accuracy of floating-point arithmetic, Accuracy–Power Series
float versus double datatypes, Precision and Speed
add function (for fixed point numbers), Creating the fixed_pt Class
adding
comments, General
element to linked list, Linked Lists
exceptions to stack classes, Adding Exceptions to the Stack Class–Exceptions Versus assert
fixed point numbers, Creating the fixed_pt Class
floating-point numbers, Floating Addition/Subtraction
addition (+) operator, Simple Expressions, Binary Arithmetic Operators
address of (&) operator, Simple Pointers, Simple Pointers, Binary Arithmetic Operators, Unary Operators
(see also pointers)
addresses, variable, Simple Pointers
algorithms
foreach, Using std::foreach to Write Out the Set–Using std::foreach to Write Out the Set
STL, Algorithms–Algorithms
allocating
arrays, Pointers, Structures, and Classes
memory, The C malloc function
stacks, Derived Classes
ampersand (&), Constant and Reference Declarations
(see also AND operator)
for reference variables, Constant and Reference Declarations
AND (&&) operator, logical, if Statement, Logical Operators
AND (&) operator, binary, The AND Operator (&)–The AND Operator (&), Binary Arithmetic Operators
AND into (&=) operator, Shortcut Operators
apostrophe (see quotation mark)
argc and argv arguments, Command-Line Arguments
arguments, command-line, Command-Line Arguments–Command-Line Arguments
arrays, Arrays–Arrays, Structures
(see also structures)
allocating, Pointers, Structures, and Classes
bounds errors, Bounds Errors–Bounds Errors
of characters, Strings
declarations, Arrays
elements, Arrays
index operator [ ], Index Operator “[ ]”
infinite, module for (example), Modules–Using the Infinite Array
initializing, Initializing Variables, Multidimensional Arrays, Arrays of Structures
multidimensional, Multidimensional Arrays–Multidimensional Arrays, Array Parameters
as parameters, Array Parameters–Array Parameters
passing to procedures, Pointers and Arrays
and pointers, Pointers and Arrays–Pointers and Arrays
optimizing, How to Optimize
of structures, Arrays of Structures–Arrays of Structures
subscripts, Arrays
ASCII characters, Characters
ASCII files, Binary and ASCII Files
asm (assembly) statement, The asm Statement
assembly language, The Basics of Program Writing, The Basics of Program Writing
assert statements, Bounds Errors, Adding Exceptions to the Stack Class–Exceptions Versus assert
assignment (=) operator, Assignment Statements
for classes, Automatically Generated and Used Functions
versus == (equal to) operator, Answers to Chapter Questions
assignment statements, C++ Organization, Assignment Statements
placement of, The Assignment Anywhere Side Effect
at member function, Strings
author, comments about, Comments
auto qualifier, Scope and Storage Class
auto variable class, Storage Class
automatic
generation of member functions, Automatically Generated Member Functions
variables, Scope and Storage Class

B

backslash ()
as escape character, Characters
in preprocessor directives, #define Statement
backspace character (), Characters
bad member function, C++ File I/O
base classes, Derived Classes
initializing, Derived Classes
search order, Virtual Functions
binary files, Binary and ASCII Files
with multiple structures, Designing File Formats
binary I/O, Binary I/O–Binary I/O, C-Style Binary I/O
binary operations (see bits)
binary operators, Binary Arithmetic Operators
% (modulus), Binary Arithmetic Operators
& (AND), The AND Operator (&)–The AND Operator (&), Binary Arithmetic Operators
versus logical AND (&&), The AND Operator (&)
* (multiplication), Binary Arithmetic Operators
+ (addition), Binary Arithmetic Operators
- (subtraction), Binary Arithmetic Operators
/ (division), Binary Arithmetic Operators
<< (left shift), The Left and Right Shift Operators (<<, >>), Binary Arithmetic Operators
>> (right shift), The Left and Right Shift Operators (<<, >>), Binary Arithmetic Operators
^ (exclusive OR), The Bitwise Exclusive OR (^), Binary Arithmetic Operators
| (OR), Bitwise OR (|), Binary Arithmetic Operators
to merge flags, Unbuffered I/O
~ (NOT), The Ones Complement Operator (NOT) (~), Unary Operators
binary search, debugging, Debugging a Binary Search
binary trees, Trees–Printing a Tree
nodes, Trees
recursion with, Trees
bitmapped graphics, Bitmapped Graphics–Bitmapped Graphics
bits, Integers
constants, Setting, Clearing, and Testing Bits
defining, Setting, Clearing, and Testing Bits
fields, Bit Members or Packed Structures–Bit Members or Packed Structures
flags, assigning, Setting, Clearing, and Testing Bits
operations, Bitmapped Graphics
operations on, Bit Operations–Answers to Chapter Questions
setting, clearing, and testing, Setting, Clearing, and Testing Bits–Setting, Clearing, and Testing Bits
bitwise operators (see binary operators)
<blank> modifier, The extern Storage Class
blocks, Scope and Storage Class, Scope and Storage Class
(see also local variables)
normal execution of, Using a Try Block for Normal Execution–Using a Try Block for Normal Execution
stack of, Scope and Storage Class
body of modules, The Body of the Module–The Body of the Module
boldface in comments, Comments
bool, Boolean Type
bottom-up programming, Structured Programming Basics
bounds errors, array, Bounds Errors–Bounds Errors
brace-counter class, brace_counter Class
brackets { } (see curly braces)
branching statements, Decision and Control Statements
if statements, if Statement–How Not to Use std::strcmp
switch statements, switch Statement–switch, break, and continue
break command (debugger), Basic Debugging Commands, Basic Debugging Commands
(see also gdb debugger)
break statements, break Statement, switch, break, and continue
in switch statements, switch Statement, switch Statement
browsers, class, Electronic Archaeology
buckets, infinite arrays, A Program to Use Infinite Arrays–A Program to Use Infinite Arrays
bytes, Integers, Bit Operations

C

%c conversion, The std::printf Family of Output Functions
C language, A Brief History of C++
binary I/O, C-Style Binary I/O
and C++ language, From C to C++–Programming Exercise
compilers, The C++ Preprocessor
conversion routines, C-Style I/O Routines, C-Style Conversion Routines
free function, The C free function
handling exceptions in, setjmp and longjmp
malloc function, The C malloc function–The C malloc function
mixing with C++ code, Mixing C and C++ Code
programming tools for, Electronic Archaeology–Electronic Archaeology
prototypes, Prototypes
strings, C-Style Strings–The Differences Between C++ and C-Style Strings
converting C++ strings to C-style strings, Converting Between C-Style and C++ Strings
versus C++ strings, The Differences Between C++ and C-Style Strings
C++
history of, A Brief History of C++–A Brief History of C++
learning to program, How to Learn C++
organization of, C++ Organization–C++ Organization
programming tools for, Electronic Archaeology–Electronic Archaeology
standard functions in, C++ Organization
C++ compiler
g++, Free Software Foundation’s g++ Compiler
Microsoft Visual, Microsoft Visual C++ .NET
Turbo, Borland’s Turbo C++
Unix CC, Unix CC Compiler (Generic Unix)
C++ file I/O, C++ File I/O–Output Files
C++ interfaces, Interfaces and C++ Classes–Interfaces and C++ Classes
C++ language, A Brief History of C++
compared with C language, From C to C++–Programming Exercise
mixing with C code, Mixing C and C++ Code
C++ preprocessor, The C++ Preprocessor–Answers to Chapter Questions
#define directive, #define Statement–#define Versus const
#include directive, #include Files
calculation errors, Power Series
call by address, Array Parameters, Summary of Parameter Types
call by value, Functions, Reference Parameters and Return Values, Summary of Parameter Types
and copy constructors, Copy Constructor
callbacks
functions, Unused Parameters
troubleshooting, Callbacks–Callbacks
calling functions, Conversion Routines
calloc function, The C malloc function
<carriage return> character, The End-of-Line Puzzle
case labels (see switch statements)
case sensitivity, Naming Style, Variables and Storage
casts, Converting Between C-Style and C++ Strings
dynamic_cast operator, The dynamic_cast Operator–The dynamic_cast Operator
operators, Casting
static_cast operator, Converting Between C-Style and C++ Strings
catch keyword, Exceptions
catch statement, Using a Try Block for Normal Execution
cerr (console error) class variable, C++ File I/O
char variable type, Types of Integers, Type, Type
character(s), Types of Integers
arrays of, Strings
ASCII, Characters
char_type class, char_type Class
constants, Characters
converting, Conversion Routines–Conversion Routines
data (see files, ASCII)
partial specialization, Partial Specialization–Partial Specialization
special, Characters
treated as bits, Setting, Clearing, and Testing Bits–Setting, Clearing, and Testing Bits
trigraphs, Trigraphs
character-to-number (>>) operator, Binary and ASCII Files
character-type modules, Character-Type Module
char_type class, char_type Class
chess, data structures, Data Structures for a Chess Program–Data Structures for a Chess Program
cin (console input)
class variable, C++ File I/O
object variable, Reading Data–Reading Data
class member (->) operator, Exotic Operators
classes, A Brief History of C++, A Brief History of C++, Simple Classes–Structures Versus Classes, Pointers, Structures, and Classes
( ) operator for, Exotic Operators
abstract, Virtual Functions, Statistics Class
accessing members of, Using a Class
assignment (=) operator for, Automatically Generated and Used Functions
base, Derived Classes
base_counter, brace_counter Class
browsers for, Electronic Archaeology
char_type, char_type Class
comment_counter, comment_counter Class
constant members of, Constant Members–Constant Members
constructors and destructors, Introduction to Constructors and Destructors–Automatically Generated and Used Functions
copy constructors, Copy Constructor–Copy Constructor
declaring, Improved Stack
default constructors, Automatically Generated and Used Functions
defining, Full Definition of the Fixed-Point Class–Programming Exercises
derived, Derived Classes
extern storage, The extern Storage Class–The extern Storage Class
fixed point, Full Definition of the Fixed-Point Class
friends of (see friend classes)
hierarchy of, Statistics Class
input_file, input_file Class
interfaces, Interfaces and C++ Classes–Interfaces and C++ Classes
keywords, Using a Class
line_counter, line_counter Class
member functions, Automatically Generated Member Functions
member variables, Improved Stack
members of, Static Member Variables–Static Member Variables
paren_counter, paren_counter Class
and pointers, Pointers, Structures, and Classes
pointers to members, Pointers to Members–Pointers to Members
problems reading, Turning Structures into Classes
programming style for, Style–Style
pure virtual functions, stat Class
search order of, Virtual Functions
stacks, Adding Exceptions to the Stack Class–Exceptions Versus assert
standard, Basic Program Structure
stat, stat Class–stat Class
and structures, Turning Structures into Classes
templates of, Class Templates–Class Specialization
token, token Class
versus structures, Structures Versus Classes
virtual, Virtual Classes–Virtual Classes
clearing bits, Setting, Clearing, and Testing Bits–Setting, Clearing, and Testing Bits
clog (console log) class variable, C++ File I/O
close member function, C++ File I/O
close system call, Unbuffered I/O
COBOL, The Basics of Program Writing
code, Indentation and Code Format
(see also programs; source)
asm (assembly) statements, The asm Statement
callbacks, Callbacks–Callbacks
design goals, Design Goals–Design Factors
design principles, Design Principles–Coding
foreach algorithm, Using std::foreach to Write Out the Set–Using std::foreach to Write Out the Set
generating, When to Generate Code
interfaces, Decoupling the Interface and Implementation–Decoupling the Interface and Implementation
linked lists, The Linked List Problem–The Linked List Problem
mixing, Mixing C and C++ Code
procedures, Coding–Coding details
interfaces, Interfaces and C++ Classes–Interfaces and C++ Classes
modules, Modules and Structured Programming–Module Summary
objects, Objects–Objects
requirements, Requirements–Requirements
reviews, Code Reviews–Metrics
metrics, Metrics–Metrics
planning, Planning the Review–The Review Meeting
testing, Design Factors
comma (,) operator, Exotic Operators, The Comma Operator
command-line
arguments, Command-Line Arguments–Command-Line Arguments
debugging switch, Debug Command-Line Switch
wildcards, Command-Line Arguments
commands, The Makefile for Multiple Files
(see also functions)
Makefiles, The Makefile for Multiple Files
comments, Comments, Add Comments–Add Comments, General
boxes, Comments
“fall through”, switch Statement
in headers, Comments, Basic Program Structure
marking variable units, C++ Code
styles for, Comments
value of, How to Learn C++
comment_counter class, comment_counter Class
comparing strings (see strcmp function)
compiler, Programs from Conception to Execution
C language, The C++ Preprocessor
g++, Free Software Foundation’s g++ Compiler, The Makefile for Multiple Files
Microsoft Visual C++, Microsoft Visual C++ .NET
templates, Real-World Templates
Turbo-C++, Borland’s Turbo C++
Unix CC, Unix CC Compiler (Generic Unix)
compiles
conditional, Conditional Compilation–Conditional Compilation
Makefile, The Makefile for Multiple Files–The Makefile for Multiple Files, Compiling
concatenating
expressions (,) operator, Exotic Operators
strcat function, C-Style Strings
strings, Strings
strncat function, C-Style Strings
conditional
breakpoints, Interactive Debugging Tips and Tricks
clauses (see branching statements)
compilation, Conditional Compilation–Conditional Compilation
statements (see construct ? construct switch statements)
confessional method of debugging, The Confessional Method of Debugging
const directive, enum Type
const keyword, Constant, Constant Functions
versus #define directive, #define Versus const
const parameters, const Parameters and Return Values
reference, Reference Parameters and Return Values
const variable type, Constant and Reference Declarations–Constant and Reference Declarations
constants
bits, Setting, Clearing, and Testing Bits
call by value, Summary of Parameter Types
character, Characters
class members as, Constant Members–Constant Members
declaring, Constant and Reference Declarations–Constant and Reference Declarations, #define Statement–#define Versus const
functions as, Constant Functions–Constant Functions
hexadecimal, Hexadecimal and Octal Constants
modifying, The mutable Qualifier
naming, Naming Style
naming conventions, Constant and Reference Declarations
octal, Hexadecimal and Octal Constants
pointers as, const Pointers–const Pointers
constructors, class, Introduction to Constructors and Destructors–Automatically Generated and Used Functions
copy, Copy Constructor–Copy Constructor
default, Automatically Generated and Used Functions
in derived classes, Constructors and Destructors in Derived Classes
explicit, Explicit Constructors–Explicit Constructors
overloading, Parameterized Constructors
parameterized, Parameterized Constructors
cont command (debugger), Basic Debugging Commands, Basic Debugging Commands
(see also gdb debugger)
containers
lists, Creating a Waiting List with the STL List–Creating a Waiting List with the STL List
set, Class List—A Set of Students–Multisets
STL, Containers–Containers
continue statements, continue Statement, switch, break, and continue
control statements, C++ Organization
control variables, for Statement–for Statement, for Statement
(see also for statements)
conversion, Conversion Routines
C-style I/O, C-Style I/O Routines, C-Style Conversion Routines
dynamic_cast operator, The dynamic_cast Operator–The dynamic_cast Operator
flags, Conversion Routines
integer-to-floating-point, Floating-Point Divide Versus Integer Divide
routines for, Conversion Routines–Conversion Routines
copy constructors, Copy Constructor–Copy Constructor
core files, Runtime Errors
cout (console out) class, Basic Program Structure, C++ File I/O
for debugging, Divide and Conquer
temporary, Debug-Only Code
cout (console out) object, The std::cout Output Object, Debugging
cross-references, Electronic Archaeology
ctype.h include file, The Rest of the Program
curly braces { }, Initializing Variables, if Statement
customizing templates, Function Specialization–Function Specialization
c_str() member function, Converting Between C-Style and C++ Strings

D

%d conversion, The std::printf Family of Output Functions
data
inputting, Reading Data–Reading Data
numbers, Reading Data
strings, Reading Data
protecting, Improved Stack
stacks of (see stacks)
data declarations, C++ Organization, Basic Program Structure
data structures, The Rest of the Program–The Rest of the Program
chess, Data Structures for a Chess Program–Data Structures for a Chess Program
doubly linked lists, Doubly Linked Lists–Doubly Linked Lists
dynamic, Advanced Pointers
linked lists, Linked Lists–Linked Lists
objects, Objects–Objects
ordered linked lists, Ordered Linked Lists–Ordered Linked Lists
templates, Real-World Templates
trees, Trees–Trees
datatypes, Ranges–Ranges
enum (enumerated), Constant Members
modifying, Casting
debugging, Style, The Programming Process, Debugging–Debugging, Debugging and Optimization–The Confessional Method of Debugging
assert statement, Bounds Errors
binary search, Debugging a Binary Search
confessional method of, The Confessional Method of Debugging
debugger as browser, Use the Debugger
divide-and-conquer method, Divide and Conquer
interactively (see interactive debugging)
serial, Serial Debugging–Debug Command-Line Switch
text editor as browser, Use the Text Editor as a Browser–Use the Text Editor as a Browser
with text editor, Going Through the Output
using a program switch, Debug Command-Line Switch
within program code, Debug-Only Code
dec I/O manipulator, Conversion Routines
decimal numbers, Types of Floats, Conversion Routines
declarations
arrays, Arrays
class, Improved Stack
constants, Constant and Reference Declarations–Constant and Reference Declarations, #define Versus const
data, C++ Organization, Basic Program Structure
file variables, C-Style I/O Routines
fixed-point numbers, Creating the fixed_pt Class
functions, Functions, Functions, Functions
lists, Putting It All Together–Putting It All Together
maps, Storing Grades in a STL Map
mutable, The mutable Qualifier
output files, Output Files–Conversion Routines
pointers, Simple Pointers
qualifiers, Qualifiers
reference variables, Constant and Reference Declarations
strings, Strings
struct keyword, struct
structures, Structures, Bit Members or Packed Structures
style of, Declarations
templates, Templates: The C++ Way
types, typedef
unions, Unions
variables, C++ Code, Variable Declarations, Scope and Storage Class
namespaces, Namespaces
scope, Scope and Storage Class
decoupling interfaces, Decoupling the Interface and Implementation–Decoupling the Interface and Implementation
decrease (-=) operator, Operators for Performing Shortcuts, Shortcut Operators
decrement (--) operator, Operators for Performing Shortcuts, Increment and Decrement Operators
default
constructors, Automatically Generated and Used Functions
parameters, Default Arguments
statements, in switch statements (see switch statements)
#define directive, #define Statement–#define Versus const, Preprocessor
versus const keyword, #define Versus const
versus typedef statement, typedef
defining
cast operators, Casting
fixed-point classes, Full Definition of the Fixed-Point Class–Programming Exercises
generic functions, Templates: The C++ Way
parameterized macros, Templates: The Hard Way–Templates: The Hard Way
variable types, typedef
definition stage, Templates: The Hard Way
delete function, malloc and free
delete operator, new and delete, delete Operator–delete Operator
using brackets [ ] with, delete Operator
deleting derived classes, Constructors and Destructors in Derived Classes
dereference (*) operator, Simple Pointers, Unary Operators
derived classes, Derived Classes
constructors and destructors, Constructors and Destructors in Derived Classes
deleting, Constructors and Destructors in Derived Classes
hiding members functions in, Function Hiding in Derived Classes
search order, Virtual Functions
design
callbacks, Callbacks–Callbacks
code
interfaces, Interfaces and C++ Classes–Interfaces and C++ Classes
modules, Modules and Structured Programming–Module Summary
objects, Objects–Objects
procedures, Coding–Coding details
dividing tasks into modules, Dividing a Task into Modules–Dividing a Task into Modules
file formats, Designing File Formats–Designing File Formats
goals, Design Goals–Design Factors
interfaces, Decoupling the Interface and Implementation–Decoupling the Interface and Implementation
linked lists, The Linked List Problem–The Linked List Problem
modules, Module Design Guidelines
principles, Design Principles–Coding
programs, Code Design–Statistics Class, Design
requirements, Requirements–Requirements
destructors, Introduction to Constructors and Destructors–Destructors, Automatically Generated and Used Functions
calling virtual functions from, Constructors and Destructors in Derived Classes
in derived classes, Constructors and Destructors in Derived Classes
exceptions, Exceptions and Destructors–Exceptions and Destructors
naming conventions, Destructors
virtual, Constructors and Destructors in Derived Classes
diagnostic cout, Debugging
directories, creating, Setting Up Your Work Area–Setting Up Your Work Area
disk files, I/O with, C++ File I/O
divide by 0 error, Runtime Errors
divide into (/=) operator, Operators for Performing Shortcuts, Shortcut Operators
divide-and-conquer debugging method, Divide and Conquer
dividing
floating-point numbers, Floating-Point Divide Versus Integer Divide, Multiplication and Division
tasks into modules, Dividing a Task into Modules–Dividing a Task into Modules
division (/) operator, Simple Expressions, Floating-Point Divide Versus Integer Divide, Binary Arithmetic Operators
do/while loops (see while loops)
documentation, Oualline’s law of, Comments
dot (.) operator, Linked Lists
double keyword, Determining Accuracy
double qualifier, Types of Floats, Size
versus float datatype, Precision and Speed
double quote (see quotation mark)
double-linked lists, Doubly Linked Lists
do_file procedure, do_file Procedure
dynamic data structures, Advanced Pointers
dynamic_cast operator, The dynamic_cast Operator–The dynamic_cast Operator

E

%e conversion, The std::printf Family of Output Functions
ease of use as a design goal, Design Goals
economy as a design goal, Design Goals
editing programs, Revisions
elements, array, Arrays
else statements, else Statement
end-of-line puzzle, The End-of-Line Puzzle
end-of-string character, Splitting a C-Style String
end-of-string marker, C-Style Strings
#endif directive, Conditional Compilation, Preprocessor
endl I/O manipulator, Conversion Routines
ends I/O manipulator, Conversion Routines
enum (enumerated) datatype, enum Type–enum Type, Constant Members
equal to (==) operator, if Statement, Relational Operators
versus = (assignment) operator, Answers to Chapter Questions
errors
bounds errors, array, Bounds Errors–Bounds Errors
calculations, Power Series
eliminating from code (see debugging)
handling within programs, Exceptions–Programming Exercises
infinite recursion, Recursion
messages, Error Messages
null effect warning, Simple Expressions
roundoff (floating-point), Roundoff Error
runtime (see runtime errors)
stack overflow, Scope and Storage Class
escape character (), Characters
evaluation order, Side Effects–Side Effects
exceptions, Exceptions–Programming Exercises
destructors, Exceptions and Destructors–Exceptions and Destructors
formatting, Creating an Exception
in C, setjmp and longjmp
runtime library, Exceptions Versus assert
for stacks, Adding Exceptions to the Stack Class
throwing, Throwing an Exception–Throwing an Exception
exclusive OR (^) operator, The Bitwise Exclusive OR (^), Binary Arithmetic Operators, Binary Arithmetic Operators
exclusive OR into (^=) operator, Shortcut Operators
executable programs, Programs from Conception to Execution, Programs from Conception to Execution
execution, Using a Try Block for Normal Execution–Using a Try Block for Normal Execution
Makefile, The Makefile for Multiple Files–The Makefile for Multiple Files
expandability as a design goal, Design Factors
explicit class constructors, Explicit Constructors–Explicit Constructors
exponential notation, Floating-Point Numbers
expressions
simple, Simple Expressions–Simple Expressions
testing, do/while
typeid function, Run Time Type Identification
extended precision, Types of Floats
extern modifier, The extern Storage Class–The extern Storage Class
extern variable class, Storage Class
external number formats, Fixed Point Basics

F

%f conversion, The std::printf Family of Output Functions
fast prototyping, The Prototype
fclose (file close) function, C-Style I/O Routines
fgetc (get character) function, C-Style I/O Routines
fgets (get string) function, C-Style I/O Routines
file formats, comments on, Comments
file-specific namespaces, File-Specific Namespace
filenames, headers, Headers–Headers
files
ASCII, Binary and ASCII Files
binary, Binary and ASCII Files, Designing File Formats
changing modification date of, The Makefile for Multiple Files
core, Runtime Errors
designing formats for, Designing File Formats–Designing File Formats
directing debugging information into, Going Through the Output
disk, C++ File I/O
headers, #include Files, Headers–Headers
I/O with (see I/O)
identification numbers for, Designing File Formats
include (see include files)
input_file class, input_file Class
integer.h, Implementation Details
main.cpp, Implementation Details
multiple (see modules)
object (see object files)
output file functions, Output Files–Conversion Routines
program, Program Files–Programming Exercises
source (see source files)
square.cpp, Implementation Details
square.h, Implementation Details
standard unbuffered, Unbuffered I/O
variables for, C-Style I/O Routines
fixed point class, Full Definition of the Fixed-Point Class–Programming Exercises
fixed point numbers, Creating a Simple Fixed-Point Class, Creating the fixed_pt Class
flags
conversion, Conversion Routines
open, Output Files, Unbuffered I/O
float datatype, Types of Floats, Type, Precision and Speed
float keyword, Floating-Point Numbers
float.h include file, Determining Accuracy
floating-point numbers, Floating-Point Numbers, Types of Floats
arithmetic, Floating Point–Power Series
accuracy of, Accuracy–Power Series
guard digit, Floating-Point Format
overflow and underflow, Overflow and Underflow
roundoff error, Roundoff Error, Minimizing Roundoff Error
speed of, Precision and Speed
converting to integers, Floating-Point Divide Versus Integer Divide
dividing, Floating-Point Divide Versus Integer Divide
versus integers, Case Study: Optimizing a Color-Rendering Algorithm
floating-point precision arithmetic, Determining Accuracy
flush command, Runtime Errors
flush I/O manipulator, Conversion Routines, Buffering Problems
fopen (file open) function, C-Style I/O Routines
for statements, C++ Organization, for Statement–for Statement, The for Scope
foreach algorithm, Using std::foreach to Write Out the Set–Using std::foreach to Write Out the Set
form-feed character (f), Characters
formatting
dividing tasks into modules, Dividing a Task into Modules–Dividing a Task into Modules
exceptions, Creating an Exception
files, Designing File Formats–Designing File Formats
fixed-point numbers, Fixed Point Basics
floating-point numbers, Floating-Point Format
Makefiles, The Makefile for Multiple Files–The Makefile for Multiple Files
programs, Indentation and Code Format–Clarity
requirements, Requirements–Requirements
FORTRAN, The Basics of Program Writing
fputc (put character) function, C-Style I/O Routines
fputs (put string) function, C-Style I/O Routines
fractional numbers, Floating-Point Numbers
fread routine, C-Style Binary I/O
free function (C language), malloc and free–The C free function
free library routine, malloc and free
friend directive, Friend Functions
fscanf function, The std::scanf Family of Input Functions
fstream class, C++ File I/O
fstream.h file, C++ File I/O
functions, C++ Organization, Functions–Summary of Parameter Types
body of modules, The Body of the Module–The Body of the Module
callback, Unused Parameters
calling, Conversion Routines
calloc, The C malloc function
as class members, Using a Class
code, When to Generate Code
constant, Constant Functions–Constant Functions
declaring, Functions
generic, Templates: The C++ Way
getline, C++ File I/O
inline, Inline Functions, Parameterized Macros Versus Inline Functions, Using the System Library
K&R style, K&R-Style Functions
length of, Simplicity
longjmp, setjmp and longjmp
and namespaces, Namespaces and Functions
naming conventions, Function Overloading
as operators, Operator Functions–Exotic Operators
output files, Output Files–Conversion Routines
overloading, Function Overloading
parameters of, Functions–Summary of Parameter Types
arrays as, Array Parameters–Array Parameters
const, const Parameters and Return Values
reference, Reference Parameters and Return Values–Dangling References
pop, Adding Exceptions to the Stack Class–Exceptions Versus assert
prototypes, Functions, Prototypes
push, Adding Exceptions to the Stack Class–Exceptions Versus assert
qsort, C++ Organization
recursive, Recursion–Recursion
return(0), Basic Program Structure
setjmp, setjmp and longjmp
single-function programs, Basic Program Structure
specialization, Function Specialization
standard, C++ Organization
static, Static Member Functions
templates of, Templates: The C++ Way
trigonometry, Power Series
typeid, Run Time Type Identification
virtual, Virtual Functions–Virtual Functions
fwrite routine, C-Style Binary I/O

G

-g (compiler option), Unix CC Compiler (Generic Unix)
g++ compiler, Free Software Foundation’s g++ Compiler, The Makefile for Multiple Files
gdb debugger, Basic Debugging Commands–Debugging a Simple Program
example of using, The First Bug, a Segmentation Fault–Interactive Debugging Tips and Tricks
generality as a design goal, Design Factors
generating templates, Templates: The Hard Way
generic functions, defining, Templates: The C++ Way
getline member function, Reading C-Style Strings
global namespaces, Global Namespace
global variables, Scope and Storage Class–Scope and Storage Class, Global variables
goto statements, goto
programming without, Coding Religion
graphics
bitmapped, Bitmapped Graphics–Bitmapped Graphics
histograms, Using the Infinite Array
greater than (>) operator, if Statement, Relational Operators
greater than or equal to (>=) operator, if Statement, Relational Operators
guard digits, Floating-Point Format, Floating-Point Format
(see also floating-point numbers)
guidelines
coding, Coding details
design, Design Principles
modules, Module Design Guidelines

H

headers, Headers–Headers
comments in, Comments, Basic Program Structure
files, #include Files
help, online Unix, Getting Help in Unix
hex I/O manipulator, Conversion Routines
hexadecimal numbers, Characters, Hexadecimal and Octal Constants, Bit Operations, Conversion Routines
converting, Conversion Routines
hiding member functions, Function Hiding in Derived Classes
hierarchy, class, Statistics Class
high-level languages, The Basics of Program Writing
histogram program (hist), Using the Infinite Array
history
of C++, A Brief History of C++–A Brief History of C++
of programming, The Basics of Program Writing–The Basics of Program Writing
hyphen (-) for command-line options, Command-Line Arguments

I

I/O (input/output)
binary, Binary I/O–Binary I/O, C-Style Binary I/O
C++ file, File Input/Output–Answers to Chapter Questions
C++ file package, C++ File I/O–Output Files
conversion routines, Conversion Routines–Conversion Routines, C-Style I/O Routines
with disk files, C++ File I/O
manipulators, Conversion Routines
operators
<< (output), I/O Operators
>> (input), I/O Operators
output file functions, Output Files–Conversion Routines
streams module, Basic Program Structure
unbuffered, Unbuffered I/O–Unbuffered I/O
IDE (integrated development environment), Programs from Conception to Execution
identification of storage classes, The extern Storage Class
if statements, C++ Organization, if Statement–How Not to Use std::strcmp, The ?: Construct
(see also ? construct; : construct; switch statements)
with else statement, else Statement
#ifdef directive, Preprocessor
ifstream
::bad, C++ File I/O
::close, C++ File I/O
::open, C++ File I/O
implementing
interfaces, Decoupling the Interface and Implementation–Decoupling the Interface and Implementation
templates, Implementation Details–Writing Portable Templates
#include directive, #include Files
include files, #include Files, Headers–Headers
ctype.h, The Rest of the Program
dstream.h, C++ File I/O
float.h, Determining Accuracy
iostream.h, C++ File I/O
local, #include Files
nested, #include Files
stdio.h, C-Style I/O Routines
inclusive OR operator (see OR operator)
increase (+=) operator, Operators for Performing Shortcuts, Shortcut Operators
increment (++) operator, Operators for Performing Shortcuts, Increment and Decrement Operators
x++ vs. ++x, Side Effects
#indef directive, Conditional Compilation
indentation, Indentation and Code Format, if Statement
styles of, Indentation and Code Format
tools for, Electronic Archaeology
index [ ] operator, Index Operator “[ ]”
infinite arrays, module for (example), Modules–Using the Infinite Array
infinite recursion error, Recursion
info command (debugger), Debugging a Simple Program, Debugging a Simple Program
(see also gdb debugger)
information hiding, Information hiding
as a design goal, Design Factors
init function, Improved Stack
initializing
arrays, Initializing Variables, Multidimensional Arrays, Arrays of Structures
base classes, Derived Classes
fixed-point numbers, Creating the fixed_pt Class
stacks, Designing a Stack, Improved Stack
automatically, Introduction to Constructors and Destructors
strings, C-Style Strings
temporary variables, Scope and Storage Class
variables, Initializing Variables–Initializing Variables
inline directive, and classes, Shortcuts
inline functions, Inline Functions, Using the System Library
versus parameterized macros, Parameterized Macros Versus Inline Functions
input (>>) operator, Reading Data, C-Style Conversion Routines, Operator Functions, I/O Operators
inputting data, Reading Data–Reading Data
numbers, Reading Data
strings, Reading Data
input_file class, input_file Class
instructions, C++ Organization, C++ Organization
int (integer) keyword, Variable Declarations
int number type, Type
int variable type, Types of Integers
integer.h file, Implementation Details
integers, Integers, Types of Integers, The reinterpret_cast
converting to floating-point numbers, Floating-Point Divide Versus Integer Divide
dividing, Floating-Point Divide Versus Integer Divide
long int type, Types of Integers, Summary of Integer Types
short int type, Types of Integers, Summary of Integer Types
signed versus unsigned, Types of Integers
types, Summary of Integer Types
unsigned, Summary of Integer Types
very short (char type), Summary of Integer Types
integrated development environment (IDE), Programs from Conception to Execution
interaction with modules, Modules and Structured Programming
interactive debugging, Interactive Debuggers–Debugging a Simple Program
conditional breakpoint trick, Interactive Debugging Tips and Tricks
interfaces
procedures, Procedure interface, Interfaces and C++ Classes–Interfaces and C++ Classes
troubleshooting, Decoupling the Interface and Implementation–Decoupling the Interface and Implementation
internal number formats, Fixed Point Basics
invert (~) operator (see NOT operator, binary)
ios
::app flag, Output Files
::ate flag, Output Files
::binary flag, Output Files, The End-of-Line Puzzle
::dec flag, Conversion Routines
::fixed flag, Conversion Routines
::hex flag, Conversion Routines
::in flag, Output Files
::internal flag, Conversion Routines, Conversion Routines
::left flag, Conversion Routines
::nocreate flag, Output Files
::oct flag, Conversion Routines
::out flag, Output Files
::right flag, Conversion Routines
::scientific flag, Conversion Routines
::showbase flag, Conversion Routines
::showpoint flag, Conversion Routines
::showpos flag, Conversion Routines
::skipws flag, Conversion Routines
::trunc flag, Output Files
::uppercase flag, Conversion Routines
::unitbuf flag, Conversion Routines
iostream
class, C++ File I/O
::fill, Conversion Routines
::precision, Conversion Routines
::setf, Conversion Routines
::unsetf, Conversion Routines
iostream.h include file, #include Files, C++ File I/O
isalpha macro, The Rest of the Program
istream
class, C++ File I/O
::getline, Reading C-Style Strings
::sentry, I/O Operators
italics in comments, Comments
iterators
set containers, Iterating Through a Set
STL, Iterators

J

justification, Conversion Routines

K

K&R-style functions, K&R-Style Functions
keyboards, trigraphs, Trigraphs
keywords
static, The extern Storage Class
struct, struct

L

L character, for long integers, Types of Integers
labels for goto statements, goto
languages
assembly language, The Basics of Program Writing
C (see C language)
C++ (see C++ language)
COBOL, The Basics of Program Writing
FORTRAN, The Basics of Program Writing
high-level, The Basics of Program Writing
low-level, Programs from Conception to Execution
machine code, Programs from Conception to Execution
machine language, The Basics of Program Writing
PASCAL, The Basics of Program Writing
%ld conversion, The std::printf Family of Output Functions
leaves, trees, Trees
left shift (<<) operator, The Left and Right Shift Operators (<<, >>), Binary Arithmetic Operators, Binary Arithmetic Operators
length function, C-Style Strings
length member function, Strings
less than (<) operator, if Statement, Relational Operators
less than or equal to (<=) operator, if Statement, Relational Operators
libraries, C++ Organization
free, malloc and free
malloc, malloc and free
standard, Programs from Conception to Execution, Basic Program Structure
STL, Advanced Pointers, STL Basics–Algorithms
algorithms, Algorithms–Algorithms
containers, Containers–Containers
iterators, Iterators
lists, Putting It All Together–Putting It All Together
maps, Storing Grades in a STL Map
set container, Class List—A Set of Students–Multisets
troubleshooting, Practical Considerations When Using the STL–Error Messages
waiting list, Creating a Waiting List with the STL List–Creating a Waiting List with the STL List
LIFO (last-in-first-out) order, Stacks
<line-feed> character, The End-of-Line Puzzle
linear programs, Decision and Control Statements
line_counter class, line_counter Class
linked lists, Linked Lists–Doubly Linked Lists
double-linked, Doubly Linked Lists
infinite arrays, A Program to Use Infinite Arrays–A Program to Use Infinite Arrays
ordered, Ordered Linked Lists
troubleshooting, The Linked List Problem–The Linked List Problem
linkers, Programs from Conception to Execution
list command (debugger), Basic Debugging Commands, Basic Debugging Commands
(see also gdb debugger)
lists
STL, Putting It All Together–Putting It All Together
templates, Default Parameters
waiting, Creating a Waiting List with the STL List–Creating a Waiting List with the STL List
local include files, #include Files
local variables, Scope and Storage Class–Scope and Storage Class, Scope and Storage Class
logical operators, Logical Operators
! (NOT), if Statement, Logical Operators
&& (AND), if Statement, The AND Operator (&), Logical Operators
and relational operators, if Statement
|| (OR), if Statement, Logical Operators
long double qualifier, Types of Floats
long int keyword, Answers to Chapter Questions
long int type, Types of Integers, Summary of Integer Types
long qualifier, Size
longjmp function (C language), setjmp and longjmp
looping statements, C++ Organization, Decision and Control Statements, Looping Statements
bit operations, Bitmapped Graphics
and break statements, break Statement
control variables in (see control variables)
for statements, for Statement–for Statement
optimizing order of, Loop ordering, How to Optimize
ordering, How to Optimize
while loops, while Statement–The Assignment Anywhere Side Effect, do/while
low-level languages, Programs from Conception to Execution
%lu conversion, The std::printf Family of Output Functions

M

machine code, Programs from Conception to Execution
machine language, The Basics of Program Writing, The Basics of Program Writing
macros
#define, Templates: The Hard Way
defining, Templates: The Hard Way–Templates: The Hard Way
parameterized, Parameterized Macros–Parameterized Macros Versus Inline Functions
replacement, #define Statement
magic numbers, Designing File Formats
main function, Functions
main.cpp file, Implementation Details
make program, The Makefile for Multiple Files–The Makefile for Multiple Files
make utility, The Makefile–The Makefile
Makefile, The Makefile–The Makefile, Compiling, Compiling
for multiple files, The Makefile for Multiple Files–The Makefile for Multiple Files
malloc function (C language), malloc and free–The C free function
man pages (Unix), Getting Help in Unix
manipulators, I/O (see I/O manipulators)
maps, STL, Storing Grades in a STL Map
markers, end-of-string, C-Style Strings
member functions
at, Strings
automatically generated, Automatically Generated Member Functions
constant, Constant Functions–Constant Functions
c_str(), Converting Between C-Style and C++ Strings
hiding, Function Hiding in Derived Classes
inline, Shortcuts
length, Strings
naming, Derived Classes
operators as, Operator Member Functions–Casting
searching, Virtual Functions
static, Static Member Functions
substr, Strings
member variables, Improved Stack
access privileges to, Improved Stack
constant, Constant Members–Constant Members
static, Static Member Variables–Static Member Variables
members
classes, Pointers to Members–Pointers to Members
constant objects, The mutable Qualifier
memory
C language, The C malloc function
leak, delete Operator
memset library routine, Using the System Library, Using the Infinite Array
merging flags, Unbuffered I/O
metrics, code reviews, Metrics–Metrics
Microsoft C++ compiler, Microsoft Visual C++ .NET
mixing C and C++ code, Mixing C and C++ Code
modification date, changing, The Makefile for Multiple Files
modification times, The Makefile for Multiple Files
modifying
cast operators, Casting
constant objects, The mutable Qualifier
programs, Revisions
modules, C++ Organization, Modular Programming–Programming Exercises
body of, The Body of the Module–The Body of the Module
character-type, Character-Type Module
design guidelines for, Module Design Guidelines
dividing task into, Dividing a Task into Modules
libraries, C++ Organization
Makefile for, The Makefile for Multiple Files–The Makefile for Multiple Files
private versus public parts, Public and Private
procedures, Modules and Structured Programming–Module Summary
token, Token Module
troubleshooting, Callbacks–Callbacks
modulus (%) operator, Simple Expressions, Binary Arithmetic Operators
modulus into (%=) operator, Operators for Performing Shortcuts, Shortcut Operators
more than (see greater than)
multidimensional arrays, Multidimensional Arrays–Multidimensional Arrays
as parameters, Array Parameters
multiple files, Makefile, The Makefile for Multiple Files–The Makefile for Multiple Files
multiplication (*) operator, Simple Expressions, Binary Arithmetic Operators
multiply by (*=) operator, Operators for Performing Shortcuts, Shortcut Operators
multiplying
floating-point numbers, Multiplication and Division
versus shifting, The Left and Right Shift Operators (<<, >>)
multisets, Multisets
mutable qualifiers, The mutable Qualifier

N

namespaces, Namespaces–The problem with the using statement
declarations, Namespaces
file-specific, File-Specific Namespace
and functions, Namespaces and Functions
global, Global Namespace
nested, Nested Namespaces
std, Namespace std
using statement, The using Statement–The problem with the using statement
naming
class destructors, Destructors
constants, Naming Style, Constant and Reference Declarations
functions, Function Overloading
member functions, Derived Classes
preprocessor directives, #define Statement
variables, C++ Code, Variables and Storage, Declarations
negative (-) operator, Unary Operators
negatives, Sign
nested include files, #include Files
nested namespaces, Nested Namespaces
new function, malloc and free
new operator, new and delete, Pointers, Structures, and Classes–Pointers, Structures, and Classes
newline character, Basic Program Structure
newline character ( ), Characters
next command (debugger), Basic Debugging Commands, Basic Debugging Commands
(see also gdb debugger)
nodes, trees, Trees
normal execution, applying try blocks for, Using a Try Block for Normal Execution–Using a Try Block for Normal Execution
NOT (!) operator, logical, if Statement, Logical Operators
NOT (~) operator, binary, The Ones Complement Operator (NOT) (~), Unary Operators
not equal to (!=) operator, if Statement, Relational Operators
NUL character, C-Style Strings, Splitting a C-Style String
null effect warning, Simple Expressions
NULL pointers, Simple Pointers
number-to-character (<<) operator, Conversion Routines
numbers
converting, Conversion Routines–Conversion Routines
determining parity of, with &, The AND Operator (&)
fixed point (see fixed point numbers)
floating-point (see floating-point numbers)
hexadecimal (see hexadecimal numbers)
inputting, Reading Data
number of decimal places for, Types of Floats
octal (see octal numbers)
reading, C++ File I/O
sign of, Sign

O

%o conversion, The std::printf Family of Output Functions
object files, Programs from Conception to Execution, Unix CC Compiler (Generic Unix)
object-oriented design (OOD), A Brief History of C++, A Brief History of C++
objects, A Brief History of C++
constant, The mutable Qualifier
procedures, Objects–Objects
oct I/O manipulator, Conversion Routines
octal character codes, Characters
octal numbers, Hexadecimal and Octal Constants, Conversion Routines
ofstream class, C++ File I/O
open flags, Output Files
ones complement operator ~ (see NOT operator, binary)
OOD (object-oriented design), A Brief History of C++
open flags, Output Files, Unbuffered I/O
open member function, C++ File I/O
open system call, Unbuffered I/O
operation cost, How to Optimize
operators
+ (string concatenation), Strings
binary (see binary operators)
bitwise
<< (left shift), The Left and Right Shift Operators (<<, >>)
>> (right shift), The Left and Right Shift Operators (<<, >>)
^ (exclusive OR), The Bitwise Exclusive OR (^)
| (OR), Bitwise OR (|)
~ (NOT), The Ones Complement Operator (NOT) (~)
casts, Converting Between C-Style and C++ Strings
comma (,), The Comma Operator
delete, delete Operator–delete Operator
dynamic_cast, The dynamic_cast Operator–The dynamic_cast Operator
functions, Operator Functions–Exotic Operators
I/O (see I/O operators)
logical (see logical operators)
member functions, Operator Member Functions–Casting
new, Pointers, Structures, and Classes–Pointers, Structures, and Classes
overloading, Answers to Chapter Questions
pointers, Simple Pointers
precedence, Operator Precedence Rules
relational (see relational operators)
simple, Simple Expressions
unary (see unary operators)
bitwise, Bit Operators
(see also binary operators)
optimizing programs, Optimization–Case Study: Optimizing a Color-Rendering Algorithm
calculation speed, Precision and Speed
considering operation costs, How to Optimize
considering powers of two, The power of powers of 2–Using the System Library
integers versus floating-point numbers, Case Study: Optimizing a Color-Rendering Algorithm
loop order, Loop ordering, How to Optimize
pointers versus arrays, How to Optimize
options, command-line command, Command-Line Arguments
OR (^) operator, exclusive, The Bitwise Exclusive OR (^)
OR (|) operator, binary, Bitwise OR (|), Binary Arithmetic Operators
to merge flags, Unbuffered I/O
OR (||) operator, logical, if Statement, Logical Operators
OR into (|=) operator, Shortcut Operators
order of operations, Side Effects–Side Effects
ordered linked lists, Ordered Linked Lists
ordering loops, How to Optimize
ostream
class, C++ File I/O
parameter, I/O Operators
::read, Binary I/O–Binary I/O
::write, Binary I/O–Binary I/O
Oualline’s law of documentation, Comments
output (<<) operator, The std::cout Output Object, C-Style Conversion Routines, Operator Functions, I/O Operators
output files, Output Files
output redirection, Going Through the Output
overflow
errors, Scope and Storage Class
floating-point, Overflow and Underflow
overloading
( ) (default class function) operator, Overloading the ( ) Operator
class constructors, Parameterized Constructors
functions, Function Overloading
operators, Answers to Chapter Questions
overriding virtual functions, Virtual Functions
O_APPEND open flag, Unbuffered I/O
O_BINARY open flag, Unbuffered I/O
O_CREAT open flag, Unbuffered I/O
O_EXCL open flag, Unbuffered I/O
O_RDONLY open flag, Unbuffered I/O
O_RDWR open flag, Unbuffered I/O
O_TRUNC open flags, Unbuffered I/O
O_WRONLY open flag, Unbuffered I/O

P

packed structures, Bit Members or Packed Structures–Bit Members or Packed Structures
parameters
in class constructors, Parameterized Constructors
default, Default Arguments
function, Functions–Summary of Parameter Types
arrays as, Array Parameters–Array Parameters
call by address, Summary of Parameter Types
call by value, Functions, Reference Parameters and Return Values, Summary of Parameter Types
constant call by value, Summary of Parameter Types
reference, Reference Parameters and Return Values–Dangling References
void, Functions
in macros, Parameterized Macros–Parameterized Macros Versus Inline Functions
macros, defining, Templates: The Hard Way–Templates: The Hard Way
types of, Summary of Parameter Types
unused, Unused Parameters
parentheses ( )
with macro parameters, Parameterized Macros
in simple operators, Simple Expressions
paren_counter class, paren_counter Class
parity, determining with &, The AND Operator (&)
partial specialization, Partial Specialization–Partial Specialization
PASCAL, The Basics of Program Writing
peer reviews, Code Reviews–Metrics
metrics, Metrics–Metrics
planning, Planning the Review–The Review Meeting
permanent variables, Scope and Storage Class–Scope and Storage Class
placing words into trees, The Rest of the Program–The Rest of the Program
planning code reviews, Planning the Review–The Review Meeting
pointers, Simple Pointers–Answers to Chapter Questions, Advanced Pointers–Answers to Chapter Questions
->* operator, Exotic Operators
and arrays, Pointers and Arrays–Pointers and Arrays
optimizing, How to Optimize
and classes, Pointers, Structures, and Classes
constant, const Pointers–const Pointers
converting to integers, The reinterpret_cast
declaring, Simple Pointers
to members, Pointers to Members–Pointers to Members
NULL, Simple Pointers
operators, Simple Pointers
to other pointers, Simple Pointers
printing value of, Pointers and Printing
and structures, Pointers and Structures, Pointers, Structures, and Classes
pop function, Improved Stack, Adding Exceptions to the Stack Class–Exceptions Versus assert
popping stacks (removing data), Stacks
portability of templates, Writing Portable Templates
positive (+) operator, Unary Operators
power series, Power Series
powers of two, The power of powers of 2–Using the System Library
precedence, operator, Operator Precedence Rules
precision (decimal places) of numbers, Types of Floats
precision of floating-point arithmetic, Accuracy–Power Series, Precision and Speed
prefix operator (see decrement operator increment operator)
Preliminary Users’ Specification, The Specification
preprocess (#) operator, The # Operator
preprocessor directives, C++, The C++ Preprocessor–Answers to Chapter Questions
backslash () in, #define Statement
#define, #define Statement–#define Versus const
#include, #include Files
naming conventions, #define Statement
parentheses ( ) with, Preprocessor
semicolons (;) with, #define Statement
print command (debugger), Basic Debugging Commands, Basic Debugging Commands
(see also gdb command)
printf functions, The std::printf Family of Output Functions
printing
binary trees, Printing a Tree
debugging information, Going Through the Output
pointer values, Pointers and Printing
trees, Printing a Tree
private member variables, Improved Stack
private module parts, Public and Private
procedures
do_file, do_file Procedure
interfaces, Procedure interface
variables, Global variables
programming, history of, The Basics of Program Writing–The Basics of Program Writing
programs, C++ Organization, Programs from Conception to Execution
assembly language, The Basics of Program Writing
basic structure of, Basic Program Structure–Basic Program Structure
changing control variables, for Statement
chess, Data Structures for a Chess Program–Data Structures for a Chess Program
commenting, How to Learn C++, Add Comments–Add Comments, General
compilers, Programs from Conception to Execution
creating directories, Setting Up Your Work Area–Setting Up Your Work Area
debugging, Style, The Programming Process, Debugging–Debugging, Debugging and Optimization–The Confessional Method of Debugging
debugger as browser, Use the Debugger
switch for, Debug Command-Line Switch
text editor as browser, Use the Text Editor as a Browser–Use the Text Editor as a Browser
decision-making in (see branching statements)
defining special datatypes, typedef
design goals, Design Goals–Design Factors
design principles, Design Principles–Coding
designing, Code Design–Statistics Class, Design
for different machines, Conditional Compilation–Conditional Compilation
executable, Programs from Conception to Execution
files, Program Files–Programming Exercises
format of, Indentation and Code Format–Clarity
handling errors in, Exceptions–Programming Exercises
histogram (hist), Using the Infinite Array
instructions, C++ Organization
machine language, The Basics of Program Writing
maintenance, Maintenance
minimizing roundoff error, Minimizing Roundoff Error
optimizing, Optimization–Case Study: Optimizing a Color-Rendering Algorithm
calculation speed, Precision and Speed
placement of assignment statements, The Assignment Anywhere Side Effect
procedures, Coding–Coding details
interfaces, Interfaces and C++ Classes–Interfaces and C++ Classes
modules, Modules and Structured Programming–Module Summary
objects, Objects–Objects
requirements, Requirements–Requirements
revising and updating, The Programming Process, Revisions, Revisions
single-function, Basic Program Structure
specifications for, The Programming Process, The Specification–The Specification
splitting into modules, Modular Programming–Programming Exercises
templates, What Is a Template?–Programming Exercises
testing, The Programming Process, Testing, Design Factors, Testing
tools for, Electronic Archaeology–Electronic Archaeology
transforming from high-level languages to machine code, Programs from Conception to Execution–Programs from Conception to Execution
troubleshooting, General–Final Note
wrapper, Programs from Conception to Execution, Programs from Conception to Execution
writing style (see design style programming)
protecting
data in stacks, Improved Stack
member variables, Improved Stack
prototypes, Prototypes
pseudocode, Code Design
_ptr extension (see pointers)
public
member functions, Module Design Guidelines
member variables, Improved Stack
module parts, Public and Private
pure virtual functions, Virtual Functions, stat Class
push function, Improved Stack, Adding Exceptions to the Stack Class–Exceptions Versus assert
pushing stacks (entering data), Stacks
put member function, The End-of-Line Puzzle

Q

qsort function, C++ Organization
qualifiers, Qualifiers
auto, Scope and Storage Class
mutable, The mutable Qualifier
' quotation mark, Characters
quotation mark ', Characters
" quotation mark, Characters
with include files, #include Files
for strings, Characters, C-Style Strings
quotation mark ", Characters
with include files, #include Files
for strings, C-Style Strings
quotation mark (“)
for strings, Characters

R

ranges of, Ranges–Ranges
read member function, Binary I/O–Binary I/O
reading
numbers, C++ File I/O
strings, Reading C-Style Strings, C-Style I/O Routines
real numbers (see floating-point numbers)
recursion, Recursion–Recursion
with binary trees, Trees
infinite, Recursion
redirecting output, Going Through the Output
redirection, I/O, C++ File I/O
reference parameters, Reference Parameters and Return Values–Dangling References
const, Reference Parameters and Return Values
dangling, Dangling References–Dangling References
reference variables, Constant and Reference Declarations
references in comments, Comments
register qualifier, Register Declarations
register variable class, Storage Class
reinterpret_cast, The reinterpret_cast
relational operators, if Statement, Relational Operators
!= (not equal to), if Statement, Relational Operators
< (less than), if Statement, Relational Operators
<= (less than or equal to), if Statement, Relational Operators
== (equal to), if Statement, Relational Operators
> (greater than), if Statement, Relational Operators
>= (greater than or equal to), if Statement, Relational Operators
and logical operators, if Statement
reliability, Design Goals
remainder (see modulus)
replacement macros, #define Statement
representations, fixed-point numbers, Fixed Point Basics
requirements, design, Requirements–Requirements
reserved words, Variables and Storage
resetiosflags I/O manipulator, Conversion Routines
return character ( ), Characters
return statement, Functions–Reference Parameters and Return Values, Functions
(see also functions)
return(0), Basic Program Structure
reusability as a design goal, Design Factors
reviews
code, Code Reviews–Metrics
metrics, Metrics–Metrics
planning, Planning the Review–The Review Meeting
revising programs, Comments, The Programming Process, Revisions, Revisions
right shift (>>) operator, The Left and Right Shift Operators (<<, >>), Binary Arithmetic Operators, Binary Arithmetic Operators
roots, trees, Trees
roundoff error (floating-point), Roundoff Error, Minimizing Roundoff Error
routines, conversion, Conversion Routines–Conversion Routines
rules
coding, Coding details
modules, Module Design Guidelines
run command (debugger), Basic Debugging Commands, Basic Debugging Commands
(see also gdb debugger)
runtime
errors, Runtime Errors–Runtime Errors
exceptions, Exceptions Versus assert

S

%s conversion, The std::printf Family of Output Functions
scanf function, The std::scanf Family of Input Functions
scientific notation, Floating-Point Numbers
scope (::) operator, Derived Classes, Pointers to Members
scope, variable, Scope and Storage Class–Scope and Storage Class
search, binary, Debugging a Binary Search
searching
binary trees, Trees
member functions, Virtual Functions
virtual functions, Virtual Functions
segmentation fault (core dumped), The First Bug, a Segmentation Fault
Segmentation Violation error, Runtime Errors
semicolon (;), Basic Program Structure
with if-else statements, else Statement
and preprocessor directives, #define Statement
sentry class function, I/O Operators
serial debugging, Serial Debugging–Debug Command-Line Switch
set container, Class List—A Set of Students–Multisets
setbase I/O manipulator, Conversion Routines
setf member function, Conversion Routines
setfill I/O manipulator, Conversion Routines
setiosflags I/O manipulator, Conversion Routines
setjmp function (C language), setjmp and longjmp
setprecision I/O manipulator, Conversion Routines
setting bits, Setting, Clearing, and Testing Bits–Setting, Clearing, and Testing Bits
setw I/O manipulator, Conversion Routines
sharing modules, Headers–Headers
shift operators
left (<<), The Left and Right Shift Operators (<<, >>)
left (<<=) shortcut, Shortcut Operators
right (>>), The Left and Right Shift Operators (<<, >>)
right (>>=) shortcut, Shortcut Operators
short int type, Types of Integers, Summary of Integer Types
short qualifier, Size
side effects, Side Effects
signed integers, Types of Integers
signed qualifier, Sign
simple variables, C++ Organization
simplicity, as a design goal, Design Factors
sine function, power series, Computing Sine Using a Power Series, Compilers
single quote (see quotation mark)
size qualifiers, Size
sorting qsort function, C++ Organization
source files (source code), Programs from Conception to Execution
special characters, Characters, Characters
specialization, Function Specialization
specialized class templates, Class Specialization
specialized template functions, Function Specialization
specifications, program, The Programming Process, The Specification–The Specification
speed of floating-point calculations, Precision and Speed
splitting strings, Splitting a C-Style String–Splitting a C-Style String
square.cpp file, Implementation Details
square.h file, Implementation Details
sscanf function, The std::scanf Family of Input Functions
stacks, Scope and Storage Class, Stacks–Improved Stack, Derived Classes
allocating, Derived Classes
class datatype (see classes)
designing, Designing a Stack–Designing a Stack
exceptions for, Adding Exceptions to the Stack Class
initializing, Designing a Stack, Improved Stack
overflow errors, Runtime Errors
protecting data, Improved Stack
structures versus classes, Improved Stack
trace, The First Bug, a Segmentation Fault
standard classes, Basic Program Structure
cout (see cout object)
standard files
C, C-Style I/O Routines
unbuffered, Unbuffered I/O
standard functions, C++, C++ Organization
standard libraries, Programs from Conception to Execution, Basic Program Structure
standard objects, cin (console input), Reading Data–Reading Data
Standard Template Library (STL), Advanced Pointers, STL Basics–Algorithms
algorithms, Algorithms–Algorithms
containers, Containers–Containers
iterators, Iterators
lists, Putting It All Together–Putting It All Together
maps, Storing Grades in a STL Map
set container, Class List—A Set of Students–Multisets
troubleshooting, Practical Considerations When Using the STL–Error Messages
waiting list, Creating a Waiting List with the STL List–Creating a Waiting List with the STL List
stat class, stat Class–stat Class
statements
asm (assembly), The asm Statement
assert, Adding Exceptions to the Stack Class–Exceptions Versus assert
assignment (see assignment statements)
branching (see branching statements)
catch, Using a Try Block for Normal Execution
control, C++ Organization
declaration (see declaring variables)
for, C++ Organization
if, C++ Organization
labeling, goto
looping (see looping statements)
switch, C++ Organization
throw, Throwing an Exception–Throwing an Exception
while, C++ Organization
static
definition of, The Meaning of static
keywords, The Meaning of static, The extern Storage Class
member functions, Static Member Functions
member variables, Static Member Variables–Static Member Variables
modifiers, The extern Storage Class
variable class, Storage Class
variables, Scope and Storage Class
static_cast operator, Converting Between C-Style and C++ Strings
statistics
line_counter class, line_counter Class
stat class, stat Class–stat Class
std namespace, Namespace std
stderr (standard error) file, C-Style I/O Routines
stdin (standard input) file, C-Style I/O Routines
stdio.h include file, C-Style I/O Routines
stdout (standard output) file, C-Style I/O Routines
step command (debugger), Basic Debugging Commands, Basic Debugging Commands
(see also gdb debugger)
STL (Standard Template Library), Advanced Pointers, STL Basics–Algorithms
algorithms, Algorithms–Algorithms
containers, Containers–Containers
iterators, Iterators
lists, Putting It All Together–Putting It All Together
maps, Storing Grades in a STL Map
set container, Class List—A Set of Students–Multisets
troubleshooting, Practical Considerations When Using the STL–Error Messages
waiting list, Creating a Waiting List with the STL List–Creating a Waiting List with the STL List
storage
class variable, Scope and Storage Class–Scope and Storage Class
extern storage class, The extern Storage Class–The extern Storage Class
strchr function, Splitting a C-Style String
strcmp (string compare) function, C-Style Strings, How Not to Use std::strcmp
strcopy (string copy) function, C-Style Strings, Safety and C Strings–Safety and C Strings
streams, C++ File I/O
strings, Characters, Strings–Wide Strings, C-Style Strings
C-style, C-Style Strings–The Differences Between C++ and C-Style Strings
converting to, Converting Between C-Style and C++ Strings
versus C++ strings, The Differences Between C++ and C-Style Strings
comparing (see strcmp function)
concatenating, Strings
strcat function, C-Style Strings
strncat function, C-Style Strings
copying (see strcpy function)
declarations, Strings
end-of-string character, Splitting a C-Style String
end-of-string markers, C-Style Strings
extracting substrings, Strings
functions for, C-Style Strings
getting length of (see length function)
initializing, C-Style Strings
inputting, Reading Data
length, determining, Strings
reading, Reading C-Style Strings, C-Style I/O Routines
splitting, Splitting a C-Style String–Splitting a C-Style String
variable-length, C-Style Strings
wide, Wide Strings
wstring data type, Wide Strings
struct keyword, Structures
in C versus C++, struct
structure pointer (->) operator, Linked Lists
structured programming techniques, Structured Programming Basics
structures, C++ Organization, Structures–Structures, Unions, Pointers, Structures, and Classes
(see also unions)
arrays of, Arrays of Structures–Arrays of Structures
and classes, Turning Structures into Classes
declaring, Structures
defining variables with, Structures
infinite arrays, A Program to Use Infinite Arrays–A Program to Use Infinite Arrays
initializing, Structures
packed, Bit Members or Packed Structures–Bit Members or Packed Structures
and pointers, Pointers and Structures, Pointers, Structures, and Classes
procedures, Modules and Structured Programming–Module Summary
stacks (see stacks)
versus classes, Improved Stack, Structures Versus Classes
style, programming, Style, The Programming Process–Programming Exercises, General–Answers to Chapter Questions
classes, Style–Style
commenting, Comments
structured programming techniques, Structured Programming Basics
subscript, array, Arrays
substr member function, Strings
subtracting floating-point numbers, Floating Addition/Subtraction
subtraction (-) operator, Simple Expressions, Binary Arithmetic Operators
suffix operator (see decrement operator increment operator)
switch statements, C++ Organization, switch Statement–switch, break, and continue, switch Statement
and break statements, switch Statement, switch Statement
switches, command-line command, Command-Line Arguments

T

tab character ( ), Characters
targets, Makefiles, The Makefile for Multiple Files
Teletype, The End-of-Line Puzzle
templates, What Is a Template?–Programming Exercises
of classes, Class Templates–Class Specialization
customizing, Function Specialization–Function Specialization
defining parameterized macros, Templates: The Hard Way–Templates: The Hard Way
of functions, Templates: The C++ Way
generic functions, Templates: The C++ Way
implementing, Implementation Details–Writing Portable Templates
lists, Default Parameters
partial specialization, Partial Specialization–Partial Specialization
portable, Writing Portable Templates
specialized, Function Specialization
STL, STL Basics–Algorithms
algorithms, Algorithms–Algorithms
containers, Containers–Containers
iterators, Iterators
lists, Putting It All Together–Putting It All Together
maps, Storing Grades in a STL Map
set container, Class List—A Set of Students–Multisets
troubleshooting, Practical Considerations When Using the STL–Error Messages
waiting list, Creating a Waiting List with the STL List–Creating a Waiting List with the STL List
temporary variables, Scope and Storage Class–Scope and Storage Class
testing, Real-Life Module Organization
bits, Setting, Clearing, and Testing Bits–Setting, Clearing, and Testing Bits
expressions, do/while
programs, The Programming Process, Testing, Design Factors, Testing
text
debugging, Going Through the Output
troubleshooting, Callbacks–Callbacks
things, Simple Pointers
this keyword, Operator Member Functions
throwing exceptions, Throwing an Exception–Throwing an Exception
tilde (~) in class destructor names, Destructors
token class, token Class
token modules, Token Module
top-down programming, Structured Programming Basics
touch command, The Makefile for Multiple Files
tracking braces, brace_counter Class
trees, Trees–Printing a Tree
nodes, Trees
placing words into, The Rest of the Program–The Rest of the Program
printing, Printing a Tree
recursion with, Trees
trigonometry functions, Power Series
trigraphs, Trigraphs
troubleshooting, Roundoff Error
(see also errors)
callbacks, Callbacks–Callbacks
debugging (see debugging)
handling errors, Exceptions–Exceptions Versus assert
interfaces, Decoupling the Interface and Implementation–Decoupling the Interface and Implementation
linked lists, The Linked List Problem–The Linked List Problem
modules, Callbacks–Callbacks
programs, General–Final Note
roundoff error, Roundoff Error
STL, Practical Considerations When Using the STL–Error Messages
try blocks, Using a Try Block for Normal Execution–Using a Try Block for Normal Execution
normal execution, Using a Try Block for Normal Execution–Using a Try Block for Normal Execution
try keyword, Using a Try Block for Normal Execution
Turbo-C++ compiler, Borland’s Turbo C++
typedef statements, typedef
typeid function, Run Time Type Identification
types, Type
casting, Casting
classes, Improved Stack–Structures Versus Classes
declaring, typedef
defining special, typedef
enum (enumerated), enum Type–enum Type
partial specialization, Partial Specialization–Partial Specialization
pointers, Simple Pointers–Answers to Chapter Questions
stacks, Stacks–Improved Stack
structures, Structures–Structures
unions, Unions–Unions
of variables, Variables and Storage

U

%u conversion, The std::printf Family of Output Functions
unary operators, Binary Arithmetic Operators, Unary Operators
& (address of), Unary Operators
* (dereference), Unary Operators
+ (positive), Unary Operators
- (negative), Unary Operators
~ (ones complement), Unary Operators
unbuffered I/O, Unbuffered I/O–Unbuffered I/O
#undef directive, Preprocessor
underflow, floating-point, Overflow and Underflow
unequal to (!=) operator, if Statement, Relational Operators
unexpected exceptions, Using a Try Block for Normal Execution
unions, Unions–Unions
units for variables, C++ Code
Unix
CC compiler, Unix CC Compiler (Generic Unix)
-D switch, Conditional Compilation
online help for, Getting Help in Unix
unpacked structures (see packed structures)
unsetf member function, Conversion Routines
unsigned integers, Types of Integers, Summary of Integer Types
unsigned qualifier, Sign
unused parameters, Unused Parameters
updating programs, The Programming Process, Revisions
upgrading programs, Style
use phase, Templates: The Hard Way
using statement, The using Statement–The problem with the using statement

V

variable-length strings, C-Style Strings
variables, C++ Code
addresses of, Simple Pointers
automatic, Scope and Storage Class
characters, Types of Integers
classes of, Storage Class
control (see control variables)
conversions for numbers, Conversion Routines
declaring, Variable Declarations, Scope and Storage Class, Scope and Storage Class
defining special datatypes, typedef
defining with structures, Structures
for files, C-Style I/O Routines
float, Precision and Speed
global, Scope and Storage Class–Scope and Storage Class
initializing, Initializing Variables–Initializing Variables
integers, Types of Integers
local, Scope and Storage Class–Scope and Storage Class
member (see member variables)
modifying datatypes, Casting
namespaces, Namespaces–The problem with the using statement
naming, Variables and Storage, Variables and Storage, Declarations
permanent versus temporary, Scope and Storage Class–Scope and Storage Class
pointers, Simple Pointers–Answers to Chapter Questions
procedures, Global variables
reference, Constant and Reference Declarations
and reserved words, Variables and Storage
scope of, Scope and Storage Class–Scope and Storage Class
signed versus unsigned, Sign
simple, C++ Organization
size qualifiers, Size
static, Scope and Storage Class
storage class of, Scope and Storage Class–Scope and Storage Class
strings, Strings–Wide Strings
types of, Variables and Storage, Type
version information in data files, Designing File Formats
virtual
classes, Virtual Classes–Virtual Classes
destructors, Constructors and Destructors in Derived Classes
functions, Virtual Functions–Virtual Functions
called from destructor, Constructors and Destructors in Derived Classes
pure, Virtual Functions, stat Class
search order, Virtual Functions
keywords, Virtual Functions, Constructors and Destructors in Derived Classes
void keyword, Functions, Returning void
in constructor declarations, Introduction to Constructors and Destructors
volatile keyword, Special

W

waiting list, Creating a Waiting List with the STL List–Creating a Waiting List with the STL List
walkthrough debugging, The Confessional Method of Debugging
warning, null effect, Simple Expressions
where command (debugger), Basic Debugging Commands, Basic Debugging Commands
(see also gdb debugger)
while loops, while Statement–The Assignment Anywhere Side Effect, do/while
and assignment statements, The Assignment Anywhere Side Effect
and break statements, break Statement
and continue statements, continue Statement
versus for statements, for Statement
while statements, C++ Organization
whitespace, Indentation and Code Format, Indentation and Code Format, Reading Data, Conversion Routines, Conversion Routines
(see also formatting programs)
wide strings, Wide Strings
wildcards, command-line, Command-Line Arguments
wrapper programs, Programs from Conception to Execution, Programs from Conception to Execution
write member function, Binary I/O–Binary I/O
write system call, Unbuffered I/O
writing programs (see programs)
ws I/O manipulator, Conversion Routines
wstring data type, Wide Strings

X

%x conversion, The std::printf Family of Output Functions
XOR operator, The Bitwise Exclusive OR (^)
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.116.80.34