The index that appeared in the print version of this title was intentionally removed from the eBook. Please use the search function on your eReading device to search for terms of interest. For your reference, the terms that appear in the print index are listed below.
Symbols
- - (double minus). See decrement operators (- -)
# (pound sign), directive syntax
% (modulus) operator
& (ampersand)
for declaring reference parameters
for passing arrays by reference
&& (AND operator)
/* */, comment syntax
*this
:: (double colon), scope resolution operator
@entry, function documentation
_ (underscore), identifiers beginning with
{ } (braces)
block syntax
C++ functions
|| (OR operator)
} (right brace), C++ functions
< > angle brackets, header syntax
<< (left arrows)
bitwise operator
insertion operator. See insertion operator (<<)
>> (right arrows)
bitwise operator
extraction operator. See extraction operator (>>)
= (equals). See assignment operators (=)
== (double equals). See relational operators (==)
\ (backslash), printing strings
?: (conditional operator)
/ (forward slash), division operator
− (minus) sign, in integral types
! (NOT operator)
. (period), member selector
; (semicolon)
blocks and
Do-While statement ending in
expression statements and
function prototype ending with
infinite loops and
For statements and
" (double quotes), printing strings
( ) (parentheses)
overriding order or evaluation in expression
testing and debugging hints
A
abstract data structures
abstract data types (ADTs)
array-based lists. See array-based lists
dynamic lists. See dynamic ADT lists
implementation of
operation categories
overview of
specification of
abstract steps
abstraction
abstract data types. See abstract data types (ADTs)
class design and
control abstraction
data abstraction
modifiability and reuse and
abstraction barrier. See also information hiding
access
to components of one-dimensional arrays
in inheritance
to one-dimensional arrays
action responsibilities
public methods of objects
transformers as example of
actions
algorithms as logical sequence of
control unit controlling other component
means-end analysis of
active error detection
address-of operators
ADTs. See abstract data types (ADTs)
aggregate operations
Aggregate I/O
one-dimensional arrays
on structs
air traffic control simulation
Algol 60
algorithms
analysis of
coding
generic functions
overview of
problem-solving case study. See leap year program (case study)
problem-solving using
responsibility
using control structures to express
allocating dynamic data
ALU (arithmetic/logic unit)
American National Standards Institute (ANSI)
American Standard Code for Information Interchange (ASCII)
characters
defined
analogy, problem-solving using
analysis, in problem-solving phase
Analytical Engine, Babbage
AND operator (&&)
angle arrays
anonymous data types
ANSI (American National Standards Institute)
appointment calendar creation (case study)
attributes in, internal representation of
constructors in
CRC cards in
filtering in
responsibilities in
scenario explorations in
appointment calendar using STL list (case study)
argument lists
defined
parameter lists and
testing and debugging tips
testing functions
voiding function
arguments
C+, C++, and arrays and
defined
functions and
mechanisms for passing
one-dimensional arrays as
parameters and
type coercion in passing of
voiding function
arithmetic expressions
compound
mixed type expressions
relational operators for comparing values of
simple
type coercion in
arithmetic operators
overview of
precedence rules for
arithmetic/logic unit (ALU)
array identifiers
array-based lists
as abstract data types
of classes, generally
creating empty
data representation in
defined
example program for
insertion
iterators
List, enhancing with sorts
overview of
responsibilities of
sequential searches of
sorted. See sorted lists
arrays
abstract form vs. implementation of
complex structures of
defined
elements of
indexes with semantic content
multidimensional
one-dimensional. See one-dimensional arrays
overview of
processing, special kinds of
of records
as structured data type
subarray processing
testing and debugging
two-dimensional. See two-dimensional arrays
ASCII (American Standard Code for Information Interchange)
characters
defined
assembler program
assembly languages
assert library function
assertions
asking questions as
as logical expressions
writing as function documentation
assignment expressions
common mistake when using
overview of
assignment operators (=)
built-in operations on objects
combined
common mistakes
enumeration types and
overview of
placing declarations and
simple arithmetic expressions
type casting
type coercion in
writing If statements
writing While statements
associative containers
associative lookups
atomic data types. See simple (atomic) data types
attributes
internal representation of
of objects
automatic variables
auxiliary (storage) devices
defined
input data coming from
B
Babbage, Charles
Backus-Naur Form (BNF) metalanguage
base addresses
base cases
base classes
batch processing, as noninteractive I/O
batch systems
BCPL (Basic Combined Programming Language)
bidirectional linear structures
bidirectional lists
Big-O notation
binary codes, data stored as
binary operators
binary representation of data
approximating floating-point values
overview of
binary search algorithms
binary search trees
binary searches
linear searches vs.
logarithmic order of
in sorted lists
binary trees
binding like items, structs
bits, of data
overview of
specialized
black boxes
black-box testing
blank lines, creating
blanks
extraction operator (>>) skipping
output formatting using
blocks (compound statements). See also scope, identifier
body of loop as
braces and
declaring automatic variables within
overview of
using in If statements
BMI calculator (case study)
changing loop implementation (case study) and
BNF (Backus-Naur Form) metalanguage
body, of function
body, of loop
bool data type
domain of
overview of
simulating
Boole, George
Boolean algebra
Boolean expressions. See logical (Boolean) expressions
Boolean functions
LessThan operation
naming
overview of
Boolean operators. See logical (Boolean) operators
brainstorming
defined
in object-oriented design
branching control structure. See selection (branching) control structure
Break statement
flow of control using
overview of
testing and debugging
building-block approach, to problem-solving
built-in data types
built-in operations, on objects
built-in simple types
characters
numeric types
overview of
Byron, Anna Isabella (Annabella)
Byron, Lord (George Gordon)
bytecode, Java
bytes
C
C language
C strings
C++ origins
CAD (computer-aided) design
calculators, Pascal
case labels, Switch statement
case studies. See problem-solving case studies
case-sensitivity
in C++
enumerators
using capitalization of identifiers
cast operator ( )
defined
overview of
catching exceptions
defined
try-catch statement for
central processing unit (CPU)
cfloat header file
chained hash tables
char data type
concatenation working with
defined
domain of
as integral type
measuring sizes in multiples of
overview of
storing character data
char literal
character data
input streams and extraction operator
overview of
reading marker and new line
reading with get function
skipping characters with ignore function
character sets
adding to string value
defined
testing and debugging hints
chessboard program (case study)
children (of tree node)
cin variable
example of
input failure
inputting data from
mistaken use of
reading string data with
class constructors
class design
abstraction
encapsulation
modifiability and reuse
mutability
class members
class scope
classes
built-in operations on objects
class objects (class instances)
composition
constructors
design specification
information hiding. See information hiding
instantiating
member functions
members
objects and members and
overview of
scope
as structured data type
syntax template for
in templates
testing and debugging
UML diagrams
clients, class
climits header file
clock
clones
closing files
COBOL (Common Business-Oriented Language)
code coverage
developing test plan with
testing using
code editors
defined
entering program using
code walk-through
coding
algorithms
binary representations of data and
collaborations
collating sequence
collisions
column processing
comments
assertions as function documentation
on constant and variable declarations
creating from debug output statements
in one-dimensional arrays
program construction using
on programs
pseudocode from design process as
communication complexity
ComparedTo
in binary searches
in dynamic binding
comparison operations
ADT operations
enumeration types and
compilation/compilers
computer speed and
defined
interpretation vs. compilation
multifile program compilation
program compilation
testing automatically during compilation
compile time
compile-time binding
complexity, of algorithm
composition, class
diagramming
overview of
compound arithmetic expressions
precedence rules
type coercion and type casting
compound statements. See blocks (compound statements)
computer programming
compilation vs. interpretation
defined
how it works
programming language instructions
software maintenance study
writing
computer-aided (CAD) design
computers
components of
defined
designing world’s first
factors affecting speed of
von Neumann’s role in development of
resources and ethics
concatenation
conceptual hiding, of function implementation
concrete steps, hierarchical solution tree
conditional (short-circuit) evaluation
conditional operator (?:)
conditions
bool data type
logical (Boolean) expressions
overview of
postconditions. See postconditions
preconditions. See preconditions
const references
constant pointers
constants
adding comments to declarations
Boolean
declaring
dynamic data and
global
identifiers
as member functions
program construction using
relational operators for comparing
constant-time complexity, of algorithm
ConstIntExpression, enumerators
constructor execution orders
constructor initializers
constructors
in ADT operations
class
for dynamic linked lists
implementing class member functions with
for instances of objects
constructs
container adapters
containers
content addressable access
Continue statement
control abstraction. See also abstraction
control structures
additional C++ operators
algorithms and
assignment operators and expressions
bitwise operators
Break statement
cast operation
conditional operator (?:)
Continue statement
Do-While statement
increment and decrement operators
looping. See loops/looping
nested
operator precedence
programming languages and
For statement
Switch statement
testing and debugging
type coercion and
control unit
copy-constructors
count-controlled loops
defined
designing flow of control
implementing with For statement
overview of
test plan for
counters, variables as
counting, looping and
cout variable
denoting output stream with
example of
mistaken use of
outputting values to
CRC (classes, responsibilities, and collaborations) cards
as notational device
overview of
in scenario explorations
cubic expressions
D
dangling pointers
data
binary representation of
defined
input failure from invalid
privacy of
separating/combining with operations
storage
data abstraction. See also abstraction
data coverage
data flow, for parameters
data objects
data representation, of abstract data
data representation of objects
data structures
abstract date structures vs. implementations
associative containers
bidirectional linear structures
bidirectional lists
binary trees
deques
dynamic
hash tables
linear structures, additional
map template
nonlinear
overview of
priority queues
queues
set template
stacks
Standard Template Library for. See Standard Template Library (STL)
testing and debugging
data types
abstract
arrays. See arrays
built-in simple types
char data type
classes. See classes
information hiding. See information hiding
numeric. See numeric data types
overview of
string. See string data type
type coercion and
user-defined. See user-defined data types
data[length]
in sorted lists
Date class, adding to (case study)
debug output statements
debugging. See also testing
array-based lists
C++ syntax and semantics and
classes
compiling and running program and
control structures
data structures
defined
functions
loops
modular design and
Null pointers
numeric types, expressions and output
object-oriented designs
pointers
process of elimination and
program input
recursion
templates
user-defined data types
deck of cards creation (case study)
declarations
assignment operations and
classes
constants
defined
definitions vs.
file streams
functions
initialization in
mixing with executable statements in blocks
numeric data types
overview of
program construction using
structs
variables
void functions
decrement operators (- -)
overview of
specialized
unary operators
deep copy operations
default constructor
default labels, Switch statement
default parameters
definitions
declarations vs.
function
namespace
variable
deleting
delete operators for
dynamic data
from dynamic linked lists
from sorted linked lists
from sorted lists
DeMorgan, Augustus
demotion (narrowing)
deque template
deques
derived classes
Descartes, René
design
of classes. See class design
computer-aided
documentation of
of interfaces. See interface design
loops
module interface
in problem-solving phase
of recording studios
of software. See software design methodologies
structured. See functional decomposition
design specification, classes
destructors
in ADT operations
closing files
for dynamic linked lists
development models, software
development process
compiling and running program
constructing program
data and data types
declarations
entering program
executable statements
identifiers
output
program structure
syntax and semantics
syntax templates
testing and debugging
diagrams, UML (Unified Modeling Language)
of classes, generally
Difference Engine, Babbage
direct addressing
directives
disk drives
divide and conquer problem-solving
division (/) operator
documentation
defined
function
tips for
dot notation
overview of
using get function with
double data type
doubly nested loops
Do-While statement
Break statement with
guidelines for choosing
overview of
testing and debugging
drivers
duplicate keys
dynamic ADT lists. See also array-based lists
creating empty
deleting from
implementing generally
inserting into
resetting
retrieving items
searching
testing for full
traversals of
dynamic binding
overview of
slicing issues in
virtual functions in
dynamic data
allocating
constants and
deleting
in linked lists. See dynamic linked lists
overview of
dynamic data structures
dynamic linked lists
constructors for
copy-constructors for
copying
creating
creating empty
deleting from
destructors for
implementing generally
inserting into
printing in reverse order
resetting
retrieving items
searching
shallow vs. deep copying of
testing for full
traversals of
E
echo printing
interactive I/O using
noninteractive I/O using
testing and debugging
editors
defined
entering existing code
electric circuits
binary representations of data and
clock generating
elements, C++ programs
data and data types
declarations
executable statements
identifiers
program structure
syntax and semantics
syntax templates
else clause
defined
nested If statements and
encapsulation
abstraction and
class design and
modifiability and reuse and
mutability of objects and
overview of
endl manipulator
creating blank lines
generating newline character in output statement
inserting blanks within line
ofstream data type
output formatting using
terminating output line
end-of-file (EOF)-controlled loops
end-of-file errors
English statements, changing into logical expressions
Entry class
deriving classes from other classes and
expanded. See ExpandedEntry class
inheritance and object-oriented design for
overview
Entry objects (case study)
EntryWithDate class
enumeration data types
assignment
comparison
defining own simple types with
incrementation
input and output
overview of
returning function value
EOF (end-of-file)-controlled loops
Equal operation, class member functions
errors
coping with input
function
messages
side effects in
software engineering tip for handling
syntactic or semantic tests
ethical issues
privacy of data
software piracy
evaluate
event counter
event-controlled loops
defined
end-of-file-controlled loops
flag-controlled loops
guidelines for choosing looping statement
sentinel-controlled loops
test plan for
exam statistics (case study)
exception handlers
defined
formal parameters in
nonlocal
exceptions
defined
exception handlers, formal parameters in
exception handlers, nonlocal
overview of
rethrowing
standard
in starship weight and balance (case study). See starship weight and balance (case study)
throw statements for
thrown by language
thrown by standard library routines
try-catch statements for
executable assertions
executable statements
mixing with declarations in blocks
overview of
program construction using
execution
overview of
programs
testing automatically during
execution (hand) trace
exit status
exiting loops
ExpandedEntry class. See also Entry class
constructor execution order in
deriving classes from other classes with
implementation of
specifications for
explicit matching
explicit type casts
exponentiation program
exponents, floating-point values an
expressions
arithmetic. See arithmetic expressions
assignment
avoiding using side effects in
compound arithmetic
defined
library functions in
logical
parameters in
performing calculations with
of pointers
relational
simple arithmetic
string
switch
external declaration
external pointers
in copying dynamic linked lists
in empty linked lists
in linked lists
in recursion
external representation, character
extraction operator (>>)
ifstream data type
and input streams
reading string data with getline function vs.
review
skipping characters with ignore function
skipping newline characters
using get function with
in dynamic binding generally
slicing issues in
virtual functions with
F
factorials
fail state
failure, input
causes of
overview of
false value, bool type
familiarity, problem-solving and
fear of starting, as mental block to problem solving
fetch-execute cycle
computer speed and
overview of
field, of record
fieldwidth specification
floating-point values
integer values
FIFO (first in, first out)
file input/output (I/O)
declaring file streams
including header file fstream
input failure from
opening files
reading data from files
runtime input of file names
specifying file streams in I/O statements
testing and debugging
files
closing
defined
opening
filtering
defined
in object-oriented design
first in, first out (FIFO)
fixed manipulator, output formatting using
flag-controlled loops
flash memory
flat (inline) implementation
float data type
in class templates
constructing complex arithmetic expressions
defined
domain of
as floating type
in function overloading
floating data types
division and
output formatting
overview of
relational operators with
flow of control
conditions and logical expressions and
defined
English statements changed into logical expressions
in function calls
If statements
logical operators. See logical (Boolean) operators
loop design and
nested If statements
selection (branching) control structure
Switch statements
test plan for
testing state of I/O stream
tests performed automatically during compilation and execution
While and Do-While loops
For loops
in multidimensional arrays
summing rows with
For statement
Break statement used with
guidelines for choosing
overview of
testing and debugging
formal interfaces, encapsulation and
formatting output. See output formatting
Fortran language
forward declarations
forward iterators
free format language
free store
fstream header file
file I/O and
function calls (invocation)
abstraction and
defined
for void vs. value-returning functions
function definitions
defined
flow of control in
function declarations vs.
as heading followed by block
overview of
program construction using
scope rules for
testing and debugging tips
for void functions
function overloading
function prototypes
defined
testing and debugging tips
for void functions
function templates
outside classes
overview of
function value (return or result) type
functional cohesion
functional decomposition
design perspective
developing test plan with
documentation in
implementing design
modules
object-oriented design vs.
overview of
review
software design using
tree structure in
with void functions
functional equivalence, modules
functional notation, cast operation
functions
arguments and
capitalization of
conceptual vs. physical hiding of
declarations
functional decomposition with void
interface design
library
modules implemented as
naming void
parameters. See parameters
scope of identifiers
specification and implementation
string data type
as subprograms
syntax and semantics of void
testing and debugging
type coercion and
user-defined
value-returning. See value-returning functions
variable lifetime and
void
when to use
writing assertions as documentation of
G
general cases
generated classes
generic algorithms
generic data type
generic functions
algorithms
function overloading
function templates, defining outside classes
get function
accepting only variable as argument
ifstream data type
in loops controlled by newline character
reading character data with
getline function
GetNextItem
iterators and
overview of
GHz (gigahertz)
GList class template. See also List class
cautions regarding
const references and
defining
instantiating
in program code organization
global constants
defined
example using
interface design and
defined
namespaces
using directives and
global variables
defined
example using
local variables vs.
scope rules for
side effects in
as static variables
Goldstine, Herbert
grade record arrays
implementing
subarray processing of
using
grammar. See syntax (grammar)
graphs
grouping order (associativity), arithmetic expressions
H
hardware
hash function
hash tables
hashing
head pointers
header files
defined
file I/O with
user-written
health profile program (case study)
follow-up
overview of
testing and debugging
heaps
hiding, name precedence or
hiding, of function implementation
hierarchical implementation
hierarchical records
hierarchical solution tree
high-level languages
Hoare, Sir Charles Anthony Richard
Hopper, Admiral Grace Murray
I
identifiers
capitalization of
declaring
meaningful, readable
naming memory locations with
overview of
scope of. See scope, identifier
self-documenting code using meaningful
IDEs (integrated development environments)
If statements
blocks
Break statement used with
common mistake
If-Then
If-Then-Else
logical order vs. physical order and
nested
overview of
testing and debugging
While statement vs.
ifstream data type
closing files
defined
opening files
testing state of I/O stream
If-Then statement
If-Then-Else statement
If-Then-Else-If control structure
ignore function
ifstream data type
skipping characters with
immutable objects
implementation
conceptual vs. physical hiding of functions and
defined
differences in
of dynamic linked lists
functional decomposition and
functions
information hiding and
overview
program life cycle and
testing during
implicit matching
inaccessible objects
#include directive
preprocessors and
include statement, adding titles to names
incoming parameters
incomplete declarations
incorrect output (case study)
Increment function, class member functions
increment operators (++)
enumeration types and
incrementing variables using
overview of
specialized
unary operators
increment variable, loop control
index values
indexes
as constants, variables, and complex expressions
defined
out-of-bounds array
with semantic content
indirect addressing
indirection operators
infinite loop
Break statement with
defined
testing and debugging
infinite recursion
information
information hiding
compiling and linking multifile programs
implementation file and
overview of
specification file and
user-written header files and
inheritance
constructor execution order in
deriving classes from other classes
in ExpandedEntry class
object-oriented design and
overview of
TimeOfDay, extending with time zone support
initialization
in declarations
loop control variable
of one-dimensional arrays
of two-dimensional arrays
initializer, defined
InitStatement, For statement
in-order traversals
input
compilation and execution of
error handling
failure
file I/O
If-Then-Else for checking validity of
input devices for
interactive I/O
manipulators for
noninteractive I/O
operating system carrying out
source program as
storing in auxiliary storage device
testing and debugging
input, into programs
input streams and extraction operator
reading character data with get function
reading marker and newline character
reading string data
skipping characters with ignore function
input prompts
input streams
input values, of enumerated types
input/output. See I/O (input/output)
inserting
into dynamic linked lists
into sorted lists
insertion operator (<<)
extraction operator compared with
ofstream data type
output statements and
insertion sorts
instances
constructing
object
instantiation, object
int data type
constructing complex arithmetic expressions
defined
domain of
input failure from
as integral type
syntax template for main function
integers
converting to strings
output formatting
testing and debugging
integral data types
division and
overview of
integrated development environments (IDEs)
integrated environment, C++
interactive I/O
defined
overview of
interactive systems
interface design
global constants
modules
overview of
side effects
value-returning functions and
interfaces
defined
encapsulation and
user/computer
internal representation, characters
International Standards Organization (ISO)
Internet
interpretation, compilation vs.
invalid data
coping with input errors
as source of input failure
An Investigation of the Laws of Thought… (Boole)
invocation. See function calls (invocation)
I/O (input/output)
devices
file I/O. See file input/output (I/O)
program I/O
iostream header file
ISO (International Standards Organization)
IsThere
in binary searches
in searching and sorting
istream data type
extraction operator. See extraction operator (>>)
get function
ignore function
managing program I/O with
testing state of I/O stream
iteration
in ADT operations
defined
recursion vs.
iteration counter
iterators
in array-based lists
in Standard Template Library
J
Java
compiler and interpreter
Unicode and
JVM (Java Virtual Machine)
K
keyboard
as input device
input failure
reading data from files vs.
keys
keyword cast
knowledge responsibilities, public methods of objects
L
LAN (local area network)
last in, first out (LIFO)
lawn care application (case study)
leaf nodes
leap year program (case study)
follow-up
overview of
reserved words in
left children
length of lists
library functions
life cycle, program
lifetime, variable
LIFO (last in, first out)
linear relationships
linear searches. See sequential searches
linear structures
linear-time complexity, of algorithm
linked lists
bidirectional
defined
dynamic. See dynamic linked lists
overview of
pointers and. See pointers
sequential structures vs.
sorted. See sorted linked lists
linking multifile programs
List class
class templates for
sorts, enhancing with
list template
lists
abstract form vs. implementation of
argument. See argument lists
array-based. See array-based lists
bidirectional
dynamic. See dynamic linked lists
length of
linked. See linked lists
parameter. See parameter lists
sorted. See sorted lists
unsorted
literal strings
concatenation working with
output formatting
output statements printing
literal values
defined
enumeration types and
literals, named constants instead of
local area network (LAN)
local constants, access rules for
local scope
defined
rules for
local variables
access rules for
scope rules for
static reserved word for declaring
void functions and
writing function documentation
logarithmic order
logic errors, handling
logical (Boolean) expressions
Boolean variables and constants
conditions in While statement as
English statements converted to
If statements. See If statements
relational operators
string comparison
testing and debugging
logical (Boolean) operators
overview of
precedence rules for
short-circuit evaluation
logical order
long data type
long double data type
loop control pointers
loop control variables
loop implementation (case study)
loop termination condition
defined
designing flow of control
loop exit and
nested logic
testing and debugging hints
loop test
loops/looping
analysis of algorithms
Break statements
Continue statements
as control structure of programming language
count-controlled
count-controlled loops. See count-controlled loops
counting and
Do-While statements
entry
event-controlled. See event-controlled loops
exit
flow of control design
For statements
guidelines for choosing statement for
keeping track of previous value
nested logic
overview of
phases of loop execution
process design
sentinel-controlled loops. See sentinel-controlled loops
summing and
testing and debugging
While statements
Lovelace, Ada
Lovelace, Lord William
Lucas, John
M
machine language (code)
defined
translating assembly language into
translating high-level languages into
main function
constructing programs
executing programs
overview of
syntax template for
writing modules as void functions
maintenance phase
effort expended in
overview
program life cycle and
software
malware
manipulators
defined
specifying for floating-point values
specifying for integer values
map template
markers, reading
The Mathematical Analysis of Logic (Boole)
meaning. See semantics (meaning)
means-end analysis, for problem-solving
member functions, const
member selector
members, class
declaring public and private members
implementing functions
objects and
memory leaks
memory unit (RAM)
affecting computer speed
defined
mental blocks, to problem solving
merging solutions, for problem-solving
message passing, objects
metalanguages
defined
overview of
using identifiers to name things
methods, object
minimum complete coverage
minus sign (-), in integral types
mixed type (mode) expressions
mnemonic
modifiability, class design
modular programming. See functional decomposition
modularizing programs
modules
coding as functions
documentation of
functional decomposition and
hierarchical solution tree
implementing functional decomposition
interface design for
summary
testing separately
writing as void functions
modulus (%) operator
mortgage program (case study)
expanding capabilities in
functional decomposition implementation for
incorrect output in
refactoring in
mouse, as input device
multidimensional arrays
multifile programs
compiling and linking
defined
multiway branches
defined
nested If statements for coding
Switch statement as control structure for
Murray (Hopper), Grace Brewster
mutability, class design
mutators. See transformers
N
\n (newline character)
defined
get function in loops controlled by
reading
review
sentinel-controlled loops
named (symbolic) constants
capitalization of identifiers representing
declarations for
defined
named data types
named matching
names
clashes
elements
memory locations
precedence (hiding)
program elements, using identifiers
run time input of file
user-defined types
value-returning functions
void functions
namespace keyword
namespaces
NDEBUG
nested For statements
nested If statements
dangling else and
overview of
Switch statement similar to
nested logic
analysis of algorithms
designing nested loops
overview of
networks
Neumann, John von
new operators
nodes
copying
deallocating
deleting from linked lists
in dynamic implementation of ADT lists
in inserting into linked lists
leaf
in linked lists
in sorted link lists. See sorted linked lists
in traversals of linked lists
noninteractive I/O
nonlinear data structures
nonlocal identifier
NOT operator (!)
flag-controlled loops using
overview of
null (empty) string
Null pointers
in copying dynamic linked lists
in deleting from linked lists
in dynamic implementation of ADT lists
in dynamic linked lists
in empty linked lists
in inserting into linked lists
introducing
in recursion
reference types and
in sorted link lists
testing and debugging
in traversals of linked lists
numeric data types. See also arithmetic expressions; output formatting
as built-in simple types
declarations for
floating
integral
named constants vs. literals
object program
object-oriented design (OOD)
in appointment calendar creation. See appointment calendar creation (case study)
brainstorming in
dynamic binding and
filtering in
focus of
functional decomposition in
generally
implementing
inheritance and. See inheritance
object-oriented programming and
overview of
responsibility algorithms in
scenario exploration in
software design using
solutions, assessing
testing and debugging
object-oriented programming languages
object-oriented programming (OOP)
C++ equivalents of OOP terms
in object-oriented design
overview of
objects
attributes of
built-in operations on
as class values
instances of
mutability of
OOP and
overview of
OBOBs (off-by-one bugs)
observer operations, ADTs
octal number system
off-by-one bugs (OBOBs)
ofstream data type
closing files
defined
opening files
testing state of I/O stream
O(N) algorithms
one-dimensional arrays
accessing components of
accessing generally
aggregate operations in
as arguments
commenting
declaring
defined
initializing, in declarations
introducing
modularizing programs with
out-of-bounds indexes and
passing as arguments
testing and debugging
Typedef with
OOD (object-oriented design). See object-oriented design (OOD)
OOP (object-oriented programming). See object-oriented programming (OOP)
open function
input failure from
opening files
testing and debugging
opening files
preparing for reading or writing
operating systems
calling main function
computer speed and
defined
operations
ADT categories
built-in operations on objects
separating/combining with data
of sorted lists
operator functions
operator overloading
*this for
overview of
review, programming warm-up exercises
review, summary
operators
arithmetic
assignment expressions and
bitwise
cast operation
conditional
increment and decrement
logical. See logical (Boolean) operators
overview of
precedence
relational. See relational operators (==)
sizeof
specialized
OR operator (||)
order of magnitude
ostream data type
managing program I/O with
testing state of I/O stream
ostringstream class
out-of-bounds indexes
output
enumerated type output values
file. See file input/output (I/O)
interactive I/O
noninteractive I/O
output formatting
creating blank lines
floating-point numbers
inserting blanks within line
integers and strings
matters of style
output stream
denoting with cout variable
terminating
Oxford University
P
parameter lists
modules
testing and debugging
testing functions
parameters
argument-passing and
arguments matched with
cautions regarding argument and parameter lists
declaring
defined
expressions and
incoming
overview of
reference
scope rules for
user-defined functions and
value
writing function documentation
Pascal, Blaise
pass by reference. See also reference parameters
pass by value. See also value parameters
passing as arguments
one-dimensional arrays
two-dimensional arrays
passive error detection
peripheral devices, computers
physical hiding, of function implementation
physical order, of functions
physical order of statements
flow of control vs.
If statements and
piracy, software
pointer variables
pointers
dynamic data and. See dynamic data
expressions of
linked lists and. See linked lists
overview of
reference types vs.
testing and debugging
types of
variables of
polymorphic operations
polymorphism. See dynamic binding
polynomial expressions
pop operations
in deques
in priority queues
in priority_queue templates
in queues
in stacks
portable (machine-independent) code
positional matching
postconditions
assertions as function documentation
developing test plan with
problem-solving phase and
testing functions
writing function documentation
postfix operators
posttest loop
precedence rules
arithmetic expressions
operators
preconditions
developing test plan with
testing functions
testing problem-solving phase by determining
writing assertions as function documentation
writing function documentation
prefix notation, cast operation
prefix operators
pre-order traversals
preprocessor
preprocessor directive
defined
file I/O and
stream I/O and
pretest loops
priming read
printing
echo. See echo printing
two-dimensional arrays
priority queues
priority_queue template
privacy of data
private, declaring private class member
problem-solving case studies
adding to Date class
appointment calendar creation
appointment calendar using STL list. See appointment calendar using STL list (case study)
BMI calculator
chessboard program
deck of cards creation
displaying name in multiple formats
Entry objects
exam statistics
health profile program
Hello Universe!
lawn care company billing
leap year program. See leap year program (case study)
mortgage payment calculator
Quicksort algorithm
recording studio design
refactoring program
RichUncle program
rock group
software maintenance. See software maintenance (case study)
starship weight and balance. See starship weight and balance (case study)
stylistic analysis of text
TimeOfDay objects
problem-solving phase
analysis and design in
computer programming
testing in
problem-solving techniques
algorithms
analogies
building-block approach
divide and conquer
fear of starting
looking for familiar things
means-end analysis
merging solutions
questions
procedural programming
processing arrays
program code organization
programming languages
assembly languages
control structures and
high-level languages
metalanguages
OOP and
overview of
selection (branching) control structure and
programs/programming. See also problem-solving techniques
algorithms
binary representations of data and
computer components
computer programs. See computer programs
definition of
developing programs. See development process
entering programs
ethics and responsibilities of
executing programs
linking multifile programs
programming languages and
running and compiling programs
stages in writing
structure of programs
project files, in integrated environment
promotion (widening)
prompts, input
Provincial Letters (Pascal)
pseudocode
ptr (pointer)
in copying dynamic linked lists
in printing dynamic linked lists in reverse order
public, declaring public class member
push operations
in deques
in priority queues
in priority_queue templates
in queues
in stacks
Q
quadratic expressions
qualified names, namespaces
questions
asking as assertions in C++
programming and
queue template
queues
Quicksort algorithm (case study)
R
raising exceptions
RAM (memory unit)
affecting computer speed
defined
range of values, numeric data types
reading
character data with get function
marker and newline character
string data
recording studio design (case study)
records (structs)
accessing individual components
aggregate operations on
of arrays
binding like items
declarations
defined
hierarchical
overview of
recursion
defined
dynamic linked lists, copying
dynamic linked lists, printing in reverse order
iteration vs.
overview of
pointer variables in
recursive algorithms with simple variables
recursive algorithms with structured variables
testing and debugging
in Towers of Hanoi game
recursive algorithms
defined
with simple variables
with structured variables
recursive calls
recursive definitions
refactoring program (case study)
reference parameters
avoiding side effects in value-returning module
coding outgoing and incoming/outgoing data as
const
defined
overview of
pass by address mechanism
testing and debugging tips
usage
reference types
relational expressions
relational operators
common mistake
If statements
overview of
precedence rules for
While statements
relative matching
reliable, software unit
reserved words
defined
public and private
resetting dynamic linked lists
resources, ethics and
responsibilities
algorithms for
assigning to classes
defined
in public methods of objects
responsibility algorithms
rethrowing exceptions
retrieving items
Return statement
value-returning functions
void functions
reuse, class design and
reverse iterators
ReverseNumbers program
right children
right subtrees
Ritchie, Dennis
rock group (case study)
row processing
rowsFilled
run time
running pointers
run-time
binding. See dynamic binding
input of file names
lifetime as issue of
S
sales array
scenario explorations
defined
in object-oriented design
scientific notation
scope, class
scope, identifier
namespaces
overview of
scope rules
variable declarations and definitions
scope resolution operator (::)
scope rules
names of user-defined types obeying
overview of
searching
binary search trees in
dynamic linked lists
sorted lists
selection (branching) control structure
overview of
programming languages and
Switch statement as
testing
self-documenting code
semantics (meaning)
assignment operators and
overview of
semantic (logic) errors
semihierarchical implementation
sentinel (trailer) value
sentinel-controlled loops
designing flow of control
end-of-file-controlled loops vs.
overview of
sequence, as control structure
sequence containers
sequential searches
sequential structures
set template
setprecision manipulator
ofstream data type
output formatting using
setw manipulator
ofstream data type
output formatting using
shallow copy operations
Shickard, Wilhelm
short data type
short-circuit (conditional) evaluation
showpoint manipulator
siblings
side effects
avoiding using in expressions
functions and
interface design and
simple (atomic) data types
built-in
defined
enumerating. See enumeration data types
vs. structured data types
user-defined
simple arithmetic expressions
size of arrays
sizeof operator
defined
measuring in multiples of char
overview of
slicing issues
Smalltalk programming language
software
affecting computer speed
defined
maintenance
piracy
waterfall model of developing
software design methodologies
documentation
functional decomposition
object-oriented design
testing and debugging
software engineering
conceptual vs. physical hiding of functions
documentation
English statements converted to logical expressions
named constants vs. literals
overview of
understanding errors before changing
software maintenance (case study)
adding file I/O to program
adding titles to names
changing loop implementation
in changing loop implementation (case study)
in creating general program (case study)
debugging simple program
essential steps of
incorrect output in
modularizing programs with arrays in
precedence error in
refactoring program in
solutions, problem-solving by merging
sorted linked lists
deleting from
of Entry objects (case study)
overview of
sorted lists
binary searches and
of classes, generally
defined
Delete
deletions generally
Insert
insertions generally
IsThere operation
linked. See sorted linked lists
operations generally
overview of
searching
sequential searches
sorting
sorting
complexity of
defined
lists. See sorted lists
source program
defined
using editor to create or modify
special characters
specialization of templates
specification, of function
specification files
ADTs and
information hiding and
speed, factors affecting computer
spiral model, of software development
splitting data
stack template
stacks
stand-alone computers
standard (built-in) data types
standard exceptions
Standard Template Library (STL)
appointment calendar using. See appointment calendar using STL list (case study)
data structures using. See data structures
deque template in
iterators in
list template in
priority_queue template in
queue template in
stack template in
vector template in
starship weight and balance (case study)
statement flow control
static binding
static variables
static_cast
std namespace
stepwise refinement. See functional decomposition
STL (Standard Template Library). See Standard Template Library (STL)
storage
data
storage (auxiliary) devices
Strachey, Christopher
straight selection sorts
stream input/output (I/O)
string class
string constants
string data type. See strings
string expressions
string variables
strings
character operations
comparison of
concatenation of
find function
at function
integers converted to
length and size functions
null (empty) string
output formatting
overview of
reading character string into
reading data into
substr function
stringstream class
Stroustrup, Bjarne
struct data type. See records (structs)
structural programming
structure
C++ program
programming language control
structured data types
arrays. See arrays
classes. See classes
vs. simple
structured design. See functional decomposition
stubs
style
braces and blocks
function documentation
naming value-returning functions
program formatting
stylistical analysis of text (case study)
subarray processing
subclasses
subprograms
C++ program structure
as control structure
subtrees
summing
columns
columns as functions
rows
superclasses
switch expression
Switch statement
overview of
testing and debugging
using Break statement with
SwitchLabel
syntax (grammar)
assignment operators
blocks
C++ (generally)
compound statements
Do-While statements
enumeration types
errors
function call to void function
If-Then
If-Then-Else
input statements
overview of
programs
For statements
Switch statements
value-returning functions
void functions
While statements
T
tall recursions
team programming
template arguments
template class
templates
cautions regarding
class, defining
class, instantiating
const references and
exceptions and. See exceptions
function, defining outside classes
generic functions and. See generic functions
operator overloading and. See operator overloading
overview of
parameters of
in program code organization
testing and debugging
templates, C++
test plans
defined
implementation
for loops
testing
array-based lists
arrays
automatically during compilation and execution
classes
control structures
data structures
dynamic linked lists
functions
in implementation phase
loops
modular design
multidimensional arrays
Null pointers
numeric types, expressions and output
object-oriented designs
one-dimensional arrays
plan for
pointers
problem-solving phase and
program input
recursion
starship weight and balance
stream state
syntax and semantics
templates
user-defined data types
then-clauses
theoretical foundations, of algorithm
throw statements
throwing exceptions
defined
by language
rethrowing
by standard library routines
thunk, defined
TimeOfDay class
assigning responsibilities to
in dynamic binding generally
implementing ExpandedEntry class with
slicing issues in
virtual functions with
TimeOfDay objects (case study)
top-down design. See functional decomposition
touch screens, as pointing device
Towers of Hanoi game
trackpads, as pointing device
trailing pointers
transformers
in ADT operations
as example of action responsibility
traversals
of dynamic linked lists
in-order
post-order
pre-order
Treatise on Differential Equations (Boole)
Treatise on the Calculus of Finite Differences (Boole)
tree structure
functional decomposition and
implementing
triply nested loops
try-catch statements
Turing, Alan
two-dimensional arrays
defining, alternate method for
initializing
introducing
passing as arguments
printing
processing
summing columns as functions
summing columns, generally
summing rows
type casting (conversion)
type coercion
in arithmetic and relational expressions
in assignments, in argument passing, and in return of function values
overview of
Typedef statement
TypeName, record data type
U
UML (Unified Modeling Language)
unary operators
defined
increment and decrement
Unicode
characters
defined
union data types
overview of
as structured data type
unique keys
unsigned reserved word
defined
numeric data types
unsorted lists
user friendly
user/computer interface
user-defined data types
built-in simple types
capitalization of
defined
hierarchical records
records (structs)
simple types
simple vs. structured data types
testing and debugging
unions
user-defined functions
flow of control
parameters
user-written header files
using declaration, namespaces
using directive
adding titles to names
namespaces
V
value parameters
arguments
coding incoming data as
defined
overview of
pass by value mechanism
testing and debugging tips
usage
value-returning functions
Boolean functions
complete example of
enumerated types as
ignoring value returned by
interface design and side effects
invoking void functions vs.
naming
overview of
testing and debugging
type coercion in
void functions vs.
when to use
values
atomic
of enumerated types
literal. See literal values
range of
variable definition
variables
assignment statements and
Boolean
capitalization of identifiers
comments added to declarations
as counters
declaring
declaring numeric
defined
in function headings, as parameters
global
identifiers
input statements and
keeping track of previous value of
lifetime of
of pointers
program construction using
relational operators for comparing
vector template
virtual functions
viruses
void functions
declarations and definitions
function call to
functional decomposition with
local variables
naming
overview of
return statement and
when to use
W
WAN (wide area network)
waterfall model, of software development
wchar_t data type, Unicode
While statement
Break statement with
defined
Do-While statement vs.
For statement for writing
guidelines for choosing
white-box (clear-box) testing
whitespace characters
wide area network (WAN)
worms
Y
Y2K problem
Z
ZeroOut function
zombies