Thinking in C++
Prev	Contents / Index	Next

Index

---

! , # , $ , % , & , > , < , ( , * , + , - , . , / , : , = , A , B , C , D , E , F , G , H , I , J , K , L , M , N , O , P , Q , R , S , T , U , V , W , X , Z , [ , ^ , | , ~

---

!, 1
!=, 1
#, preprocessor stringize operator, 1
#define, 1, 2, 3, 4
#endif, 1, 2
#ifdef, 1, 2
#ifndef, 1
#include , 1
#undef, 1
$<, in makefiles, 1
%, 1
&, 1, 2
&&, logical and, 1, 2
&, bitwise and, 1
&= bitwise, 1
>, 1

>>, 1

iostreams

operator, 1
overloading, 1

>>=, 1
>=, 1
<, 1

<<, 1

overloading for iostreams, 1

<<=, 1
<=, 1
( ), overloading the function call operator, 1

*, 1

overloaded operator, 1, 2
pointer dereference, 1

+, 1, 2

with pointers, 1

++, 1

with pointers, 1

-, 1, 2

->

overloading the smart pointer operator, 1
struct member selection via pointer, 1

->*, overloading, 1
-, with pointers, 1
--, 1
--, with pointers, 1
. member selection operator, 1

... variable argument list, 1

varargs, 1

/, 1
: ternary if-else, 1

::, 1, 2

scope resolution operator, and namespaces, 1

=, 1

operator

as a private function, 1
automatic creation, 1

operator, as a private function, 1
overloading, 1

==, 1, 2
abort( ), 1

abstract

base classes and pure virtual functions, 1
data type, 1, 2

abstraction, 1

access

control, 1

run-time, 1

function, 1

specifiers, 1, 2

and object layout, 1
order for, 1

accessors, 1
actor, in use cases, 1
addition (+), 1

address

const, 1
each object must have a unique address, 1
element, 1
function, 1, 2
memory, 1
object, 1
pass as const references, 1
passing and returning with const, 1
struct object, 1

address-of (&), 1

aggregate, 1

const aggregates, 1

initialization, 1, 2

and structures, 1

aggregation, 1
algorithms, Standard C++ Library, 1

aliasing

namespace, 1
solving with reference counting and copy-on-write, 1

Allison, Chuck, 1, 2, 3

allocation

dynamic memory allocation, 1, 2
memory, and efficiency, 1
storage, 1

alternate linkage specification, 1

ambiguity, 1

during automatic type conversion, 1
with namespaces, 1

analysis

and design, object-oriented, 1
paralysis, 1
requirements analysis, 1

and

& bitwise, 1, 2
&& logical, 1, 2
&& logical and, 1

and_eq, &= (bitwise and-assignment), 1
anonymous union, 1
ANSI Standard C++, 1
argc, 1

arguments

argument-passing guidelines, 1
command line, 1, 2
const, 1
constructor, 1

default, 1, 2, 3

argument as a flag, 1

destructor, 1
empty argument list, C vs. C++, 1
function, 1, 2
indeterminate list, 1
macro, 1
mnemonic names , 1
name decoration, 1
overloading vs. default arguments, 1
passing, 1
placeholder, 1
preferred approach to argument passing, 1
references, 1
return values, operator overloading, 1
trailing and defaults, 1
unnamed, 1
variable argument list, 1, 2
without identifiers, 1

argv, 1
arithmetic, pointer, 1

array, 1

automatic counting, 1
bounds-checked, using templates, 1
calculating size, 1
definition, limitations, 1
indexing, overloaded operator [], 1
initializing to zero, 1
inside a class, 1
making a pointer look like an array, 1
new & delete, 1
of pointers, 1
of pointers to functions , 1
off-by-one error, 1
overloading new and delete for arrays, 1
pointers and, 1
static, 1
static initialization, 1

asctime( ), 1

assembly-language

asm in-line assembly-language keyword, 1
CALL, 1
code for a function call, 1
code generated by a virtual function, 1
RETURN, 1

assert( )

macro in Standard C, 1

assert( )

macro in Standard C, 1, 2

assignment, 1, 2

disallowing, 1
memberwise, 1, 2
operator, 1
overloading, 1
pointer, const and non-const, 1
self-assignment in operator overloading, 1

assure( ), 1

from require.h, 1

atexit( ), 1
atof( ), 1, 2
atoi( ), 1
atol( ), 1
auto keyword, 1, 2
auto-decrement operator, 1
auto-increment operator, 1, 2

automatic

counting, and arrays, 1
creation of operator=, 1
destructor calls, 1

type conversion, 1, 2

pitfalls, 1
preventing with the keyword explicit, 1

variable, 1, 2, 3

backslash, 1
backspace, 1
bad_alloc, 1

base

abstract base classes and pure virtual functions, 1
base-class interface, 1
fragile base-class problem, 1
types, 1
virtual keyword in derived-class declarations, 1

basic concepts of object-oriented programming (OOP), 1
BASIC language, 1, 2
Beck, Kent, 1
behavior, 1

binary operators, 1

examples of all overloaded, 1
overloaded, 1

binding

dynamic binding, 1
early, 1, 2
function call binding, 1, 2
late, 1, 2
run-time binding, 1

bit bucket, 1
bit-shifting, 1
bitand, & (bitwise and), 1
bitcopy, 1
bitcopy, vs. initialization, 1
bitor, | (bitwise or), 1

bitwise

and operator &, 1, 2
const, 1
exclusive-or, xor ^, 1
explicit bitwise and logical operators, 1
not ~, 1
operators, 1
or operator |, 1, 2

bloat, code, 1

block

access, 1
and storage allocation, 1
definition, 1

Booch, Grady, 1

book

design & production, 1
errors, reporting, 1

bool, 1, 2

Boolean, 1, 2, 3

algebra, 1
and floating point, 1
bool, true and false, 1

bounds-checked array, with templates, 1
break, keyword, 1
bucket, bit, 1

bugs

common pitfalls with operators, 1
finding, 1
from casts, 1
with temporaries, 1

built-in type, 1

basic, 1
initializer for a static variable , 1

pseudoconstructor

calls for, 1
form for built-in types, 1

byte, 1

C, 1

#define, 1
backward compatibility, 1
C programmers learning C++, 1
C++ compatibility, 1
compiling with C++, 1
concepts, 1
const, 1
converting from C to C++, 1, 2
difference with C++ when defining variables, 1
empty argument list, C vs. C++, 1
finding problems in old code, 1
function library, 1
fundamentals, 1
heap, 1
hole in the type system, via void*, 1
ISO Standard C, 1
libraries, 1, 2
linkage, 1
linking compiled C code with C++, 1
name collisions, 1
operators and their use, 1
passing and returning variables by value, 1
pitfalls, 1
preprocessor, 1
safety hole during linking, 1

Standard library function

abort( ), 1
atexit( ), 1
exit( ), 1

Thinking in C CD ROM, 1

C++

automatic typedef for struct and class, 1
C compatibility, 1
C programmers learning C++, 1
cfront, original C++ compiler, 1
compiling C, 1
converting from C to C++, 1, 2
data, 1
difference with C when defining variables, 1
efficiency, 1
empty argument list, C vs. C++, 1
explicit casts, 1
finding C errors by recompiling in C++, 1
first program, 1
GNU Compiler, 1
hybrid object-oriented language, and friend, 1
implicit structure address passing, 1
linking compiled C code with C++, 1
major language features, 1
meaning of the language name, 1
object-based C++, 1
one definition rule, 1
operators and their use, 1
programming guidelines, 1
Standard C++, 1
Standards Committee, 1
strategies for transition to, 1
stricter type checking, 1
strongly typed language, 1
why it succeeds, 1

c-v qualifier, 1
calculating array size, 1
CALL, assembly-language, 1
calling a member function for an object , 1
calloc( ), 1, 2, 3
Carolan, John, 1
Carroll, Lewis, 1
case, 1
cassert standard header file, 1

cast, 1, 2, 3, 4, 5, 6

C++ explicit casts, 1
casting away constness, 1
casting void pointers, 1
const_cast, 1
explicit cast for upcasting, 1
explicit keyword, 1
operators, 1
pointer assignment, 1
reinterpret cast, 1
static_cast, 1

cat, Cheshire, 1
catch clauses, 1

CD ROM

seminars on CD-ROM from MindView, 1
Thinking in C, Foundations for Java & C++ (packaged with book), 1, 2, 3

cfront, original C++ compiler, 1
chapter overviews, 1

char, 1, 2, 3

sizeof, 1

character, 1

array literals, 1
character array concatenation, 1
constants, 1

characteristics, 1
check for self-assignment in operator overloading, 1
Cheshire cat, 1
cin, 1
clashes, name, 1

class, 1, 2, 3

abstract base classes and pure virtual functions, 1
adding new virtual functions in the derived class, 1
aggregate initialization, 1
class definition and inline functions, 1
compile-time constants inside, 1, 2, 3
composition, and copy-constructor, 1
const and enum in, 1
container class templates and virtual functions, 1
creators, 1

declaration, 1

of a nested friend class, 1

defining the interface, 1
definition, 1
difference between a union and a class, 1
duplicate class definitions and templates, 1
fragile base-class problem, 1
generated by macro, 1
generated classes for templates, 1
handle class, 1

inheritance

and copy-constructor, 1
diagrams, 1

initialization, memberwise, 1
instance of, 1
keyword, 1
local, 1

nested, 1

iterator, 1, 2

overloading new and delete for a class, 1
pointers in, and overloading operator=, 1
static class objects inside functions, 1
static data members, 1
static member functions, 1
templates, 1
using const with, 1

class-responsibility-collaboration (CRC) cards, 1

cleanup, 1, 2

automatic destructor calls with inheritance and composition, 1
initialization and cleanup on the heap, 1

client programmer, 1, 2

code

source availability, 1
table-driven, 1
assembly for a function call, 1
bloat, 1
comment tags in listings, 1
consulting, mentoring, and design and code walkthroughs from MindView, 1
generator, 1

organization, 1

header files, 1

program structure when writing code, 1
re-use, 1

collection, 1, 2
collector, garbage, 1
collision, linker, 1
comma operator, 1, 2

command line, 1

arguments, 1

comment tag

for linking, 1
in source-code listings, 1

comments, makefile, 1
committee, C++ Standards, 1
common interface, 1
compaction, heap, 1

compatibility

C & C++, 1
with C, 1

compilation

needless, 1
process, 1
separate, 1
separate, and make, 1

compile time constants, 1

compiler, 1, 2

creating default constructor, 1
original C++ compiler cfront, 1
running, 1
support, 1

compiling C with C++, 1
compl, ~ ones complement, 1

complicated

declarations & definitions, 1
expressions, and operator overloading, 1

composite

array, 1
type creation, 1

composition, 1, 2, 3

combining composition & inheritance, 1
copy-constructor, 1
member object initialization, 1
vs. inheritance, 1, 2, 3

concatenation, character array, 1
concept, high, 1
conditional operator, 1
conditional, in for loop, 1

const, 1, 2

address of, 1
aggregates, 1
casting away, 1
character array literals, 1
compile-time constants in classes, 1
const reference function arguments, 1
correctness, 1
enum in classes, 1
evaluation point of, 1
extern, 1
function arguments and return values, 1
in C, 1
initializing data members, 1
logical, 1

member function, 1

and objects, 1

mutable, 1
pass addresses as const references, 1
pointer to const, 1
pointers, 1

reference, 1, 2

and operator overloading, 1

return by value as const, 1

and operator overloading, 1

safety, 1
temporaries are automatically const, 1

constant, 1

character, 1

compile-time, 1

inside classes, 1

folding, 1, 2
named, 1
templates, constants in, 1
values, 1

constructor, 1, 2, 3, 4

arguments, 1
automatic type conversion, 1
behavior of virtual functions inside constructors, 1

copy-constructor, 1, 2, 3, 4, 5

alternatives to, 1
vs. operator=, 1

creating a new object from an existing object, 1

default, 1, 2, 3, 4, 5

inheritance, 1
synthesized by the compiler, 1

doesn’t automatically inherit, 1
efficiency, 1
global object, 1
initialization and cleanup on the heap, 1

initializer list, 1, 2, 3

pseudoconstructors, 1

inline, 1
installing the VPTR, 1
memberwise initialization, 1
name, 1
new operator, memory exhaustion, 1
order of construction with inheritance, 1

order of constructor calls, 1

and destructor calls, 1

overloading, 1, 2
private, 1
pseudo-constructor, 1
return value, 1
tracking creations and destructions, 1
virtual functions & constructors, 1

const_cast, 1
consulting, mentoring, and design and code walkthroughs from MindView, 1

container, 1, 2

container class templates and virtual functions, 1
delete, 1
iterators, 1
new, delete, and containers, 1
ownership, 1, 2, 3
polymorphism , 1
Standard C++ Library, 1
vector, 1

context, and overloading, 1
continuation, namespace, 1
continue, keyword, 1

control

access, 1, 2

run-time, 1

access specifiers, 1
expression, used with a for loop, 1

controlling

execution, 1
linkage, 1

conversion

automatic type conversion, 1
narrowing conversions, 1
pitfalls in automatic type conversion, 1
preventing automatic type conversion with the keyword explicit, 1
to numbers from char*, 1

converting from C to C++, 1, 2

copy-constructor, 1, 2, 3, 4, 5, 6, 7

alternatives, 1
composition, 1
default, 1
inheritance, 1
private, 1, 2
upcasting and the copy-constructor, 1
vs. operator=, 1

copy-on-write (COW), 1
copying pointers inside classes, 1
copyright notice, source code, 1
correctness, const, 1
costs, startup, 1

counting

automatic, and arrays, 1
reference, 1

cout, 1, 2
cover design, book, 1
CRC, class-responsibility-collaboration cards, 1

creating

functions in C and C++, 1
new object from an existing object, 1
objects on the heap, 1

crisis, software, 1
cstdlib standard header file, 1
cstring standard header file, 1

data

defining storage for static members, 1
initializing const members, 1
static area, 1
static members inside a class, 1

data type

abstract, 1, 2
built-in, 1
equivalence to class, 1
user-defined, 1

debugging, 1

assert() macro, 1
flags, 1
preprocessor flags, 1
require.h, 1
run-time, 1
using the preprocessor, 1

decimal, 1

declaration, 1, 2

all possible combinations, 1
analyzing complex, 1
and definition, 1

class, 1

nested friend, 1

const, 1
forward, 1

function, 1, 2, 3

declaration syntax, 1
not essential in C, 1

header files, 1, 2
structure, 1
using, for namespaces, 1

variable

declaration syntax, 1
point of declaration & scope, 1

virtual, 1

base-class declarations, 1
derived-class declarations, 1

decoration, name, 1, 2, 3, 4

overloading, 1

decoupling, 1

via polymorphism, 1

decrement, 1, 2

and increment operators, 1
overloading operator, 1

default

argument, 1, 2, 3

as a flag, 1
vs. overloading, 1

constructor, 1, 2, 3, 4, 5

inheritance, 1

copy-constructor, 1
default values in templates, 1
keyword, 1

defining

function pointer, 1
initializing at the same time, 1
initializing variables, 1

variable, 1

anywhere in the scope, 1

definition, 1

array, 1
block, 1
class, 1
complex function definitions, 1
const, 1
declaration, 1
duplicate class definitions and templates, 1
formatting pointer definitions, 1
function, 1
non-inline template member function definitions, 1
object, 1
pure virtual function definitions, 1
storage for static data members, 1
structure definition in a header file, 1

delete, 1, 2, 3

calling delete for zero, 1
delete-expression, 1, 2
keyword, 1
multiple deletions of the same object, 1

new

and containers, 1
for arrays, 1

overloading new and delete, 1

array, 1
class, 1
global, 1

void*, deleting is a bug, 1
zero pointer, 1

Demarco, Tom, 1

dependency

makefile, 1
static initialization, 1

deprecation, of ++ with a bool flag, 1

dereference

*, 1
dereferencing function pointers, 1
pointer, 1

derived

adding new virtual functions in the derived class, 1
types, 1
virtual keyword in derived-class declarations, 1

design

analysis and design, object-oriented, 1

book

cover, 1
design and production, 1

consulting, mentoring, and design and code walkthroughs from MindView, 1
five stages of object design, 1
inlines, 1
mistakes, 1
pattern, iterator, 1
patterns, 1, 2

destructor, 1

automatic destructor calls, 1

with inheritance and composition, 1

doesn’t automatically inherit , 1
explicit destructor call, 1
initialization and cleanup on the heap, 1
inlines, 1
order of constructor and destructor calls, 1
pure virtual destructor, 1
scope, 1
static objects, 1
tracking creations and destructions, 1
virtual destructor, 1, 2, 3, 4
virtual function calls in destructors, 1

development, incremental, 1

diagram

class inheritance diagrams, 1
inheritance, 1
use case, 1

directive

preprocessor, 1

using, namespaces, 1, 2

header files, 1

directly accessing structure, 1
disallowing assignment, 1
dispatching, double/multiple, 1
division (/), 1
do-while, 1

double, 1

dispatching, and multiple dispatching, 1
double precision floating point, 1
internal format, 1

downcast

static_cast, 1
type-safe, 1

duplicate class definitions and templates, 1

dynamic

binding, 1
memory allocation, 1, 2
object creation, 1, 2, 3, 4
type checking, 1

dynamic_cast, 1
early binding, 1, 2, 3, 4
edition, 2nd, what’s new in, 1

efficiency, 1

C++, 1
constructor, 1
creating and returning objects, 1
inlines, 1
memory allocation, 1
references, 1
trap of premature optimization, 1
virtual functions, 1

elegance, in programming, 1
Ellis, Margaret, 1
else, 1

embedded

object, 1
systems, 1

encapsulation, 1, 2
end sentinel, iterator, 1, 2, 3

enum

and const in classes, 1
clarifying programs with, 1
hack, 1
incrementing, 1
keyword, 1
type checking, 1
untagged, 1, 2

equivalence, 1

==, 1

error

exception handling, 1
off-by-one, 1
preventing with common header files, 1
reporting errors in book, 1
structure redeclaration, 1

escape sequences, 1
evaluation order, inline, 1
evolution, in program development, 1

exception handling, 1, 2

simple use, 1

executing code

after exiting main( ), 1, 2
before entering main( ), 1

execution

controlling, 1
point, 1

exercise solutions, 1
exit( ), 1, 2

explicit

cast, 1

C++, 1
for upcasting, 1

keyword to prevent automatic type conversion, 1

exponential, 1

notation, 1

exponentiation, no operator, 1
expressions, complicated, and operator overloading, 1
extending a class during inheritance, 1
extensible program, 1

extern, 1, 2, 3, 4, 5, 6, 7

const, 1, 2
to link C code, 1

external

linkage, 1, 2, 3, 4
references, during linking, 1

extractor and inserter, overloading for iostreams, 1
Extreme Programming (XP), 1, 2, 3
factory, design pattern, 1

false, 1, 2, 3

and true, in conditionals, 1
bool, true and false, 1

fan-out, automatic type conversion, 1
Fibonacci, 1
fibonacci( ), 1

file

header, 1, 2, 3

code organization, 1
const, 1
namespaces, 1

names, 1
reading and writing, 1
scope, 1, 2, 3
static, 1, 2, 3, 4
structure definition in a header file, 1

flags, debugging, 1

floating point

float, 1, 2
float.h, 1
internal format, 1
number size hierarchy, 1
numbers, 1, 2
true and false, 1

for

defining variables inside the control expression, 1
loop, 1, 2
loop counter, defined inside control expression, 1
variable lifetime in for loops, 1

formatting pointer definitions, 1

forward

declaration, 1
reference, inline, 1

Fowler, Martin, 1, 2, 3
fragile base-class problem, 1
fragmentation, heap, 1, 2
free store, 1
free( ), 1, 2, 3, 4, 5
free-standing reference, 1

friend, 1, 2

declaration of a nested friend class, 1
global function, 1
injection into namespace, 1
member function, 1
nested structure, 1
structure, 1

fstream, 1

function, 1

abstract base classes and pure virtual functions, 1
access, 1
adding more to a design, 1
adding new virtual functions in the derived class, 1
address, 1, 2

argument, 1

const, 1
const reference , 1
reference, 1

array of pointers to, 1

assembly-language code generated

function call, 1
virtual function call, 1

binding, for a function call, 1, 2
body, 1
C library, 1
call operator( ), 1
call overhead, 1, 2
called for side effect, 1
complicated function definitions, 1
constructors, behavior of virtual functions inside, 1
creating, 1

declaration, 1, 2, 3

not essential in C, 1
required, 1
syntax, 1

definition, 1
empty argument list, C vs. C++, 1
expanding the function interface, 1

global, 1

friend, 1

helper, assembly, 1

inline, 1, 2, 3

header files, 1

local class (class defined inside a function), 1

member function, 1, 2

calling

a member function, 1
another member function from within a member function, 1
base-class functions, 1

const, 1, 2
friend, 1
inheritance and static member functions, 1
overloaded operator, 1
selection, 1

objects, 1

overloading, 1

operator, 1
using declaration, namespaces, 1

overriding, 1
pass-by reference & temporary objects, 1

pointer

defining, 1
to member function, 1
using a function pointer, 1

polymorphic function call, 1
prototyping, 1
pure virtual function definitions, 1
redefinition during inheritance, 1

return value

by reference, 1
returning a value, 1
type, 1
void, 1

signature, 1
stack frame for a function call , 1

static

class objects inside functions, 1
member, 1, 2, 3
objects inside functions, 1
variables inside functions, 1

templates, 1
type, 1
unique identifier for each, 1
variable argument list, 1

virtual function, 1, 2

constructor, 1
overriding, 1
picturing, 1

garbage collector, 1, 2
generic algorithm, 1
get and set functions, 1
get( ), 1

getline( )

and string, 1
from iostreams library, 1

Glass, Robert, 1

global

friend function, 1
functions, 1
new and delete, overloading, 1
object constructor, 1
operator, overloaded, 1
scope resolution, 1
static initialization dependency of global objects, 1
variables, 1

GNU C++, 1
Gorlen, Keith, 1

goto, 1, 2, 3

non-local, 1

greater than

>, 1
or equal to (>=), 1

guaranteed initialization, 1, 2
guards, include, on header files, 1

guidelines

argument passing, 1
C++ programming guidelines, 1
object development, 1

hack, enum, 1
handle classes, 1, 2

has-a, 1

composition, 1

header file, 1, 2, 3, 4, 5, 6, 7

code organization, 1
enforced use of in C++, 1
formatting standard, 1
include guards, 1
inline definitions, 1
internal linkage, 1
namespaces, 1
new file include format, 1
order of inclusion, 1
templates, 1, 2
using directives, 1
importance of using a common header file, 1
multiple inclusion, 1
structure definition in a header file, 1

heap, 1, 2

C heap, 1
compactor, 1
creating objects, 1
fragmentation, 1, 2
guaranteeing that all objects are created on the heap, 1

storage allocation, 1

simple example system, 1

helper function, assembly, 1
hexadecimal, 1

hiding

function names inside a struct, 1
implementation, 1, 2, 3, 4

names

during inheritance, 1
during overloading, 1

variables from the enclosing scope, 1

hierarchy, singly-rooted/object-based, 1, 2
high concept, 1
high-level assembly language, 1
hostile programmers, 1

hybrid

C++, hybrid object-oriented language, and friend, 1
object-oriented programming language, 1

identifier

unique for each function, 1
unique for each object, 1

IEEE standard for floating-point numbers, 1, 2

if-else, 1

defining variables inside the conditional, 1
statement, 1
ternary ?:, 1

ifstream, 1, 2

implementation, 1, 2

and interface, separating, 1, 2, 3, 4

hiding, 1, 2, 3, 4

compile-time only, 1

implicit type conversion, 1
in situ inline functions, 1
in-memory compilation, 1

include, 1

include guards, in header files, 1, 2
new include format, 1

incomplete type specification, 1, 2

increment, 1, 2

and decrement operators, 1
incrementing and enumeration, 1
overloading operator ++, 1

incremental

development, 1
programming, 1

indeterminate argument list, 1

indexing

array, using [ ], 1, 2
zero, 1

inheritance, 1, 2, 3, 4

choosing composition vs. inheritance, 1
class inheritance diagrams, 1
combining composition & inheritance, 1
copy-constructor, 1
diagram, 1
extending a class during, 1
extensibility, 1
function redefinition, 1
initialization, 1
is-a, 1, 2
multiple, 1, 2, 3, 4, 5
name hiding, 1
operator overloading & inheritance, 1
order of construction, 1
private inheritance, 1
protected inheritance, 1
public inheritance, 1
static member functions, 1
subtyping, 1
virtual function calls in destructors, 1
vs. composition, 1, 2
VTABLE, 1

initialization, 1, 2

aggregate, 1, 2

array

elements, 1
to zero, 1

const data members, 1
const inside class, 1
constructor, 1
constructor initializer list, 1, 2, 3
definition, simultaneous, 1
for loop, 1, 2

guaranteed, 1, 2

during inheritance, 1

initialization and cleanup on the heap, 1
initializer for a static variable of a built-in type, 1
lazy, 1
member object initialization, 1
memberwise, 1, 2
object using =, 1

static

array, 1
const, 1
dependency, 1
member , 1
zero initialization by the linking-loading mechanism, 1

variables at point of definition, 1
vs. bitcopy, 1

injection, friend into namespace, 1

inline, 1, 2

class definition, 1
constructor efficiency, 1
constructors, 1
convenience, 1
definitions and header files, 1
destructors, 1
effectiveness, 1
efficiency, 1
function, 1, 2, 3
header files, 1
in situ, 1
limitations, 1
non-inline template member function definitions, 1
order of evaluation, 1
templates, 1

input

reading by words, 1
standard, 1

insert( ), 1
inserter and extractor, overloading for iostreams, 1
instance of a class, 1
instantiation, template, 1
int, 1

interface, 1

base-class interface, 1
common interface, 1
defining the class, 1
expanding function interface, 1
for an object, 1
implementation, separation of, 1, 2, 3, 4
implied by a template, 1
user, 1

internal linkage, 1, 2, 3, 4, 5
interpreters, 1
interrupt service routine (ISR), 1, 2

iostreams, 1

get( ), 1
getline( ), 1

global overloaded new & delete

interaction with, 1
limitations of, 1

manipulators, 1
overloading << and >>, 1
reading and writing files, 1
reading input, 1
setf( ), 1
strings with iostreams, 1
width( ), 1

is-a

inheritance, 1, 2
vs. is-like-a relationships, 1

ISO Standard

C, 1

fundamentals, 1

C++, 1

header files, 1

istream, overloading operator >>, 1
iteration, in program development, 1

iterator, 1, 2, 3

containers, 1
motivation, 1
nested class, 1
Standard C++ Library, 1

Jacobsen, Ivar, 1
Java, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
K&R C, 1

keywords

#define, 1, 2
#endif, 1, 2
#ifdef, 1
#include , 1
‘.’ (member selection operator), 1
&, 1
( ), function call operator overloading, 1
*, 1, 2

->, 1

overloading, 1
struct member selection via pointer, 1

->*, 1

overloading, 1

.*, 1
::, 1, 2

=, 1

overloading, 1, 2

asm, for in-line assembly language , 1
auto, 1, 2

bool, 1

true and false, 1

break, 1
case, 1
catch, 1
char, 1, 2, 3
class, 1, 2, 3
const, 1, 2, 3
const_cast, 1
continue, 1
default , 1
delete, 1, 2
do, 1
double, 1, 2
dynamic_cast, 1
else, 1

enum, 1, 2

untagged, 1

explicit, 1

extern, 1, 2, 3, 4, 5, 6

for alternate linkage, 1

false, 1, 2
float, 1, 2
for, 1, 2
friend, 1
goto, 1, 2, 3
if, 1
inline, 1, 2
int, 1
long, 1
long double, 1
long float (not legal), 1
mutable, 1
namespace, 1, 2, 3
new, 1, 2
operator, 1
private, 1, 2, 3, 4
protected, 1, 2, 3
public, 1
register, 1, 2
reinterpret_cast, 1
return, 1
short, 1
signed, 1
signed char, 1

sizeof, 1, 2, 3

with struct, 1

static, 1, 2, 3
static_cast, 1, 2
struct, 1, 2
switch, 1, 2
template, 1, 2
this, 1, 2, 3, 4, 5