ZeePedia

Index

<< C: Recommended Reading:Depth & dark corners, Analysis & design
img
Index
- · 156, 163
<< · 160; overloading for iostreams · 518
-- · 164
<<= · 160
! · 163
<= · 158
!= · 158
= · 166; operator; as a private function ·
#, preprocessor stringize operator · 196
533; automatic creation · 532; operator,
#define · 194, 245, 335, 353
as a private function · 709; overloading ·
#endif · 245, 757
521
#ifdef · 194, 245
== · 158, 166
#ifndef · 246
> · 158
#include · 85
->: overloading the smart pointer operator
#undef · 194
· 509; struct member selection via
$<, in makefiles · 206
pointer · 178
% · 156
->*, overloading · 514
& · 134, 164
>= · 158
&&, logical and · 158
>> · 160; iostreams; operator · 106;
&, bitwise and · 159
overloading · 518
>>= · 160
&= bitwise · 160
( ), overloading the function call operator ·
514
A
* · 156; overloaded operator · 727, 730;
pointer dereference · 136
-, with pointers · 192
abort( ) · 409
--, with pointers · 192
abstract: base classes and pure virtual
. member selection operator · 237
functions · 646; data type · 129, 239
... variable argument list · 114; varargs ·
abstraction · 22
243
access: control · 260; run-time · 275;
/ · 156
function · 379; specifiers · 29, 261; and
:: · 232, 429; scope resolution operator, and
object layout · 269; order for · 263
namespaces · 417
accessors · 380
?: ternary if-else · 164
actor, in use cases · 50
[ ]: array indexing · 105; overloaded
addition (+) · 156
indexing operator · 519, 698
address: const · 339; each object must have
^ bitwise exclusive-or · 159
a unique address · 241; element · 134;
^= bitwise · 160
function · 198, 391; memory · 133; object
|, bitwise or · 159
· 265; pass as const references · 473;
||, logical or · 158
passing and returning with const · 349;
|= bitwise · 160
struct object · 178
~ bitwise not/ones complement · 159
address-of (&) · 164
~, destructor · 287
aggregate · 105; const aggregates · 337;
+ · 156, 163; with pointers · 192
initialization · 201, 301; and structures ·
++ · 164; with pointers · 190
302
< · 158
aggregation · 30
823
img
for arrays · 573; pointers and · 184;
algorithms, Standard C++ Library · 742
static · 692; static initialization · 425
aliasing: namespace · 415; solving with
asctime( ) · 384
reference counting and copy-on-write ·
assembly-language: asm in-line assembly-
527
language keyword · 173; CALL · 458;
Allison, Chuck · 2, 776
code for a function call · 456; code
allocation: dynamic memory allocation ·
generated by a virtual function · 642;
223, 548; memory, and efficiency · 566;
RETURN · 458
storage · 292
assert( ): macro in Standard C · 197, 223,
alternate linkage specification · 442
396
ambiguity · 244; during automatic type
assignment · 156, 301; disallowing · 533;
conversion · 540; with namespaces · 420
memberwise · 532, 600; operator · 505;
analysis: and design, object-oriented · 44;
overloading · 521; pointer, const and
paralysis · 45; requirements analysis ·
non-const · 343; self-assignment in
48
operator overloading · 523
and: & bitwise · 159, 166; && logical · 158,
166; && logical and · 173
assure( ) · 757; from require.h · 237
and_eq, &= (bitwise and-assignment) · 173
atexit( ) · 409
atof( ) · 188, 189
anonymous union · 320
atoi( ) · 188
ANSI Standard C++ · 14
atol( ) · 188
argc · 187
auto keyword · 149, 414
arguments: argument-passing guidelines ·
auto-decrement operator · 128
455; command line · 187, 252; const ·
auto-increment operator · 106, 128
344; constructor · 286; default · 310, 311,
automatic: counting, and arrays · 301;
321; argument as a flag · 329; destructor
creation of operator= · 532; destructor
· 287; empty argument list, C vs. C++ ·
calls · 297; type conversion · 228, 533;
114; function · 81, 138; indeterminate
pitfalls · 539; preventing with the
list · 114; macro · 374; mnemonic names
keyword explicit · 534; variable · 42,
· 83; name decoration · 312; overloading
149, 153
vs. default arguments · 324; passing ·
450; placeholder · 323; preferred
approach to argument passing · 351;
B
references · 451; return values, operator
overloading · 505; trailing and defaults ·
322; unnamed · 114; variable argument
backslash · 95
list · 114, 243; without identifiers · 323
backspace · 95
argv · 187
bad_alloc · 572
arithmetic, pointer · 190
base: abstract base classes and pure virtual
array · 182; automatic counting · 301;
functions · 646; base-class interface ·
bounds-checked, using templates · 697;
633; fragile base-class problem · 276;
calculating size · 302; definition,
types · 32; virtual keyword in derived-
limitations · 338; indexing, overloaded
class declarations · 632
operator [] · 698; initializing to zero ·
basic concepts of object-oriented
301; inside a class · 353; making a
programming (OOP) · 22
pointer look like an array · 564; new &
BASIC language · 68, 77
delete · 563; of pointers · 187; of
Beck, Kent · 779
pointers to functions · 201; off-by-one
behavior · 219
error · 301; overloading new and delete
binary operators · 160; examples of all
overloaded · 493; overloaded · 487
824
img
problems in old code · 70; function
binding: dynamic binding · 631; early · 38,
library · 116; fundamentals · 112; heap ·
644; function call binding · 631, 641; late
550; hole in the type system, via void* ·
· 38, 631; run-time binding · 631
450; ISO Standard C · 14; libraries · 89,
bit bucket · 162
bitand, & (bitwise and) · 173
219; linkage · 338; linking compiled C
code with C++ · 442; name collisions ·
bitcopy · 468
68; operators and their use · 156;
bitcopy, vs. initialization · 460
bitor, | (bitwise or) · 173
passing and returning variables by
value · 455; pitfalls · 227; preprocessor ·
bit-shifting · 162
bitwise: and operator & · 159, 166; const ·
334; safety hole during linking · 314;
362; exclusive-or, xor ^ · 159; explicit
Standard library function; abort( ) · 409;
bitwise and logical operators · 173; not
atexit( ) · 409; exit( ) · 409; Thinking in C
~ · 159; operators · 159; or operator | ·
CD ROM · 776
C++: automatic typedef for struct and
159, 166
class · 231; C compatibility · 235; C
bloat, code · 391
programmers learning C++ · 628;
block: access · 269; and storage allocation ·
cfront, original C++ compiler · 237;
292; definition · 289
compiling C · 305; converting from C to
Booch, Grady · 779
C++ · 230, 760; data · 129; difference
book: design & production · 18; errors,
with C when defining variables · 145;
reporting · 16
efficiency · 66; empty argument list, C
bool · 125, 195
vs. C++ · 114; explicit casts · 167;
Boolean · 117, 158, 163; algebra · 159; and
finding C errors by recompiling in C++
floating point · 159; bool, true and false
· 314; first program · 90; GNU Compiler
· 131
· 71; hybrid object-oriented language,
bounds-checked array, with templates ·
and friend · 269; implicit structure
697
address passing · 231; linking compiled
break, keyword · 122
C code with C++ · 442; major language
bucket, bit · 162
features · 682; meaning of the language
bugs: common pitfalls with operators ·
name · 129; object-based C++ · 628; one
166; finding · 292; from casts · 168; with
definition rule · 244; operators and their
temporaries · 348
use · 156; programming guidelines ·
built-in type · 129; basic · 129; initializer for
760; Standard C++ · 14; Standards
a static variable · 408;
Committee · 14; strategies for transition
pseudoconstructor; calls for · 589; form
to · 68; stricter type checking · 227;
for built-in types · 381
strongly typed language · 450; why it
byte · 133
succeeds · 64
calculating array size · 302
C
CALL, assembly-language · 458
calling a member function for an object ·
239
C · 289; #define · 340; backward
calloc( ) · 223, 550, 554
compatibility · 73; C programmers
Carolan, John · 277
learning C++ · 628; C++ compatibility ·
Carroll, Lewis · 277
235; compiling with C++ · 305; concepts
case · 124
· 2; const · 338; converting from C to
cassert standard header file · 197
C++ · 230, 760; difference with C++
cast · 40, 135, 164, 276, 552, 630; C++
when defining variables · 145; empty
explicit casts · 167; casting away
argument list, C vs. C++ · 114; finding
825
img
overloading operator= · 524; static class
constness · 363; casting void pointers ·
objects inside functions · 408; static data
235; const_cast · 170; explicit cast for
members · 423; static member functions
upcasting · 681; explicit keyword · 678;
· 429; templates · 742; using const with ·
operators · 166; pointer assignment ·
352
343; reinterpret cast · 171; static_cast ·
class-responsibility-collaboration (CRC)
169
cards · 52
cat, Cheshire · 277
cleanup · 227, 666; automatic destructor
catch clauses · 572
calls with inheritance and composition ·
CD ROM: seminars on CD-ROM from
592; initialization and cleanup on the
MindView · 16; Thinking in C,
heap · 548
Foundations for Java & C++ (packaged
client programmer · 28, 260
with book) · 2, 15, 112
code: assembly for a function call · 456;
cfront, original C++ compiler · 237
bloat · 391; comment tags in listings ·
chapter overviews · 7
750; consulting, mentoring, and design
char · 96, 130, 132; sizeof · 173
and code walkthroughs from
character · 154; array literals · 343;
MindView · 16; generator · 79;
character array concatenation · 96;
organization · 248; header files · 244;
constants · 155
program structure when writing code ·
characteristics · 219
93; re-use · 583; source availability · 12;
check for self-assignment in operator
table-driven · 201
overloading · 505
collection · 510, 719
Cheshire cat · 277
collector, garbage · 42
cin · 97
collision, linker · 244
clashes, name · 229
comma operator · 165, 508
class · 25, 76, 271; abstract base classes and
command line · 252; arguments · 187
pure virtual functions · 646; adding
comment tag: for linking · 148; in source-
new virtual functions in the derived
code listings · 750
class · 652; aggregate initialization · 302;
comments, makefile · 204
class definition and inline functions ·
committee, C++ Standards · 14
378; compile-time constants inside ·
common interface · 647
353, 356, 358; composition, and copy-
compaction, heap · 225
constructor · 469; const and enum in ·
compatibility: C & C++ · 235; with C · 98
353; container class templates and
compilation: needless · 276; process · 79;
virtual functions · 743; creators · 28;
separate · 78; separate, and make · 202
declaration · 277; of a nested friend
compile time constants · 335
class · 514; defining the interface · 62;
compiler · 76, 77; creating default
definition · 277; difference between a
constructor · 304; original C++ compiler
union and a class · 319; duplicate class
cfront · 237; running · 95; support · 15
definitions and templates · 699; fragile
compiling C with C++ · 305
base-class problem · 276; generated by
compl, ~ ones complement · 173
macro · 594; generated classes for
complicated: declarations & definitions ·
templates · 699; handle class · 275;
199; expressions, and operator
inheritance; and copy-constructor · 471;
overloading · 488
diagrams · 617; initialization,
composite: array · 182; type creation · 174
memberwise · 471; instance of · 24;
composition · 30, 584, 607; combining
keyword · 31; local · 428; nested · 428;
composition & inheritance · 591; copy-
iterator · 512, 721; overloading new and
constructor · 469; member object
delete for a class · 570; pointers in, and
826
img
inheritance · 665; order of constructor
initialization · 589; vs. inheritance · 604,
calls · 663; and destructor calls · 592;
620, 740
overloading · 310, 319; private · 709;
concatenation, character array · 96
pseudo-constructor · 562; return value ·
concept, high · 48
287; tracking creations and destructions
conditional operator · 164
· 709; virtual functions & constructors ·
conditional, in for loop · 121
662
const · 153, 334; address of · 339;
consulting, mentoring, and design and
aggregates · 337; casting away · 363;
code walkthroughs from MindView ·
character array literals · 343; compile-
16
time constants in classes · 356; const
container · 510, 719; container class
reference function arguments · 351;
templates and virtual functions · 743;
correctness · 367; enum in classes · 353;
delete · 671; iterators · 690; new, delete,
evaluation point of · 337; extern · 339;
and containers · 692; ownership · 555,
function arguments and return values ·
671, 713; polymorphism · 738; Standard
344; in C · 338; initializing data
C++ Library · 104; vector · 102
members · 355; logical · 362; member
context, and overloading · 310
function · 352; and objects · 359;
continuation, namespace · 415
mutable · 362; pass addresses as const
continue, keyword · 122
references · 473; pointer to const · 171;
control: access · 29, 260; run-time · 275;
pointers · 340; reference · 345, 453; and
access specifiers · 261; expression, used
operator overloading · 505; return by
with a for loop · 106
value as const · 345; and operator
controlling: execution · 117; linkage · 412
overloading · 507; safety · 336;
conversion: automatic type conversion ·
temporaries are automatically const ·
533; narrowing conversions · 170;
347
pitfalls in automatic type conversion ·
const_cast · 170
539; preventing automatic type
constant · 153; character · 155; compile-
conversion with the keyword explicit ·
time · 335; inside classes · 358; folding ·
534; to numbers from char* · 188
335, 339; named · 153; templates,
converting from C to C++ · 230, 760
constants in · 703; values · 154
copy-constructor · 432, 450, 455, 463, 508,
constructor · 285, 548, 551, 665; arguments
657, 730; alternatives · 471; composition
· 286; automatic type conversion · 534;
· 469; default · 468; inheritance · 471;
behavior of virtual functions inside
private · 471, 709; upcasting and the
constructors · 664; copy-constructor ·
copy-constructor · 617; vs. operator= ·
432, 450, 455, 463, 657; alternatives to ·
521
471; vs. operator= · 521; creating a new
copying pointers inside classes · 524
object from an existing object · 462;
copy-on-write (COW) · 527
default · 304, 327, 408, 470, 563;
copyright notice, source code · 12
inheritance · 663; synthesized by the
correctness, const · 367
compiler · 304; doesn't automatically
costs, startup · 71
inherit · 600; efficiency · 663; global
counting: automatic, and arrays · 301;
object · 410; initialization and cleanup
reference · 526
on the heap · 548; initializer list · 353,
cout · 90, 91
589, 664; pseudoconstructors · 589;
cover design, book · 17
inline · 392; installing the VPTR · 643;
CRC, class-responsibility-collaboration
memberwise initialization · 600; name ·
cards · 52
285; new operator, memory exhaustion
· 576; order of construction with
827
img
variables · 130; variable · 145; anywhere
creating: functions in C and C++ · 112;
in the scope · 145
new object from an existing object · 462;
definition · 81; array · 338; block · 289; class
objects on the heap · 554
· 277; complex function definitions ·
crisis, software · 8
198; const · 340; declaration · 243;
cstdlib standard header file · 188
duplicate class definitions and
cstring standard header file · 269
templates · 699; formatting pointer
c-v qualifier · 366
definitions · 342; function · 83; non-
inline template member function
D
definitions · 699; object · 285; pure
virtual function definitions · 651;
storage for static data members · 424;
data: defining storage for static members ·
structure definition in a header file · 234
424; initializing const members · 355;
delete · 164, 223, 553; calling delete for zero
static area · 406; static members inside a
· 327; delete-expression · 553, 566;
class · 423
keyword · 42; multiple deletions of the
data type: abstract · 129, 239; built-in · 129;
same object · 553; new; and containers ·
equivalence to class · 26; user-defined ·
692; for arrays · 563; overloading new
129
and delete · 566; array · 573; class · 570;
debugging · 78; assert() macro · 197; flags ·
global · 568; void*, deleting is a bug ·
194; preprocessor flags · 194; require.h ·
555; zero pointer · 553
396; run-time · 195; using the
Demarco, Tom · 781
preprocessor · 395
dependency: makefile · 204; static
decimal · 154
initialization · 432
declaration · 81; all possible combinations ·
deprecation, of ++ with a bool flag · 131
141; analyzing complex · 199; and
dereference: * · 164; dereferencing function
definition · 243; class · 277; nested
pointers · 200; pointer · 137
friend · 514; const · 340; forward · 151;
derived: adding new virtual functions in
function · 116, 233, 313; declaration
the derived class · 652; types · 32;
syntax · 82; not essential in C · 228;
virtual keyword in derived-class
header files · 242, 244; structure · 265;
declarations · 632
using, for namespaces · 421; variable;
design: analysis and design, object-
declaration syntax · 83; point of
oriented · 44; book; cover · 17; design
declaration & scope · 145; virtual · 632;
and production · 18; consulting,
base-class declarations · 632; derived-
mentoring, and design and code
class declarations · 632
walkthroughs from MindView · 16; five
decoration, name · 230, 231, 237, 442;
stages of object design · 54; inlines · 380;
overloading · 311
mistakes · 279; pattern, iterator · 719;
decoupling · 628; via polymorphism · 39
patterns · 59, 70
decrement · 128, 164; and increment
destructor · 287; automatic destructor calls
operators · 506; overloading operator ·
· 297; with inheritance and composition
493
· 592; doesn't automatically inherit ·
default: argument · 310, 311, 321; as a flag ·
600; explicit destructor call · 579;
329; vs. overloading · 324; constructor ·
initialization and cleanup on the heap ·
304, 327, 408, 470, 563; inheritance · 663;
548; inlines · 392; order of constructor
copy-constructor · 468; default values in
and destructor calls · 592; pure virtual
templates · 703; keyword · 124
destructor · 668; scope · 288; static
defining: function pointer · 198; initializing
objects · 410; tracking creations and
at the same time · 290; initializing
828
img
error: exception handling · 43; off-by-one ·
destructions · 709; virtual destructor ·
301; preventing with common header
665, 707, 736, 740; virtual function calls
files · 244; reporting errors in book · 16;
in destructors · 670
structure redeclaration · 245
development, incremental · 614
escape sequences · 94
diagram: class inheritance diagrams · 617;
evaluation order, inline · 391
inheritance · 40; use case · 49
evolution, in program development · 58
directive: preprocessor · 79; using,
exception handling · 43, 565; simple use ·
namespaces · 92, 418; header files · 247
572
directly accessing structure · 240
executing code: after exiting main( ) · 411;
disallowing assignment · 533
before entering main( ) · 411
dispatching, double/multiple · 675
execution: controlling · 117; point · 549
division (/) · 156
exercise solutions · 12
double · 155; dispatching, and multiple
exit( ) · 397, 409
dispatching · 675; double precision
explicit: cast · 678; C++ · 167; for upcasting
floating point · 130; internal format ·
· 681; keyword to prevent automatic
189
type conversion · 534
do-while · 120
exponential · 154; notation · 130
downcast: static_cast · 681; type-safe · 678
exponentiation, no operator · 517
duplicate class definitions and templates ·
expressions, complicated, and operator
699
overloading · 488
dynamic: binding · 631; memory allocation
extending a class during inheritance · 34
· 223, 548; object creation · 42, 547, 732,
extensible program · 633
738; type checking · 80
extern · 84, 147, 151, 335, 339, 412; const ·
dynamic_cast · 678
335, 340; to link C code · 442
external: linkage · 152, 338, 339, 412;
E
references, during linking · 228
extractor and inserter, overloading for
iostreams · 518
early binding · 38, 631, 641, 644
Extreme Programming (XP) · 61, 615, 779
edition, 2nd, what's new in · 2
efficiency · 371; C++ · 66; constructor · 663;
creating and returning objects · 507;
F
inlines · 392; memory allocation · 567;
references · 455; trap of premature
optimization · 329; virtual functions ·
factory, design pattern · 712
645
false · 158, 163, 246; and true, in
elegance, in programming · 60
conditionals · 117; bool, true and false ·
Ellis, Margaret · 433
131
else · 118
fan-out, automatic type conversion · 540
embedded: object · 585; systems · 577
Fibonacci · 725
encapsulation · 239, 270
fibonacci( ) · 691
end sentinel, iterator · 724, 728, 736
file: header · 233, 242, 323; code
enum: and const in classes · 353; clarifying
organization · 248; const · 335;
programs with · 179; hack · 358;
namespaces · 423; names · 749; reading
incrementing · 180; keyword · 179; type
and writing · 100; scope · 150, 152, 412;
checking · 180; untagged · 320, 358
static · 150, 244, 414; structure definition
equivalence · 166; == · 158
in a header file · 234
flags, debugging · 194
829
img
defined inside a function) · 428;
floating point: float · 130, 155; float.h · 129;
member function · 28, 230; calling; a
internal format · 189; number size
member function · 239; another
hierarchy · 132; numbers · 130, 154; true
member function from within a
and false · 159
member function · 234; base-class
for: defining variables inside the control
functions · 588; const · 352, 359; friend ·
expression · 145; loop · 106, 121; loop
264; inheritance and static member
counter, defined inside control
functions · 604; overloaded operator ·
expression · 291; variable lifetime in for
487; selection · 234; objects · 515;
loops · 292
overloading · 310; operator · 486; using
formatting pointer definitions · 342
declaration, namespaces · 421;
forward: declaration · 151; reference, inline
overriding · 35; pass-by reference &
· 391
temporary objects · 453; pointer;
Fowler, Martin · 45, 58, 779
defining · 198; to member function ·
fragile base-class problem · 276
475; using a function pointer · 200;
fragmentation, heap · 225, 567
polymorphic function call · 637;
free store · 549
prototyping · 113; pure virtual function
free( ) · 223, 550, 553, 555, 569
definitions · 651; redefinition during
free-standing reference · 451
inheritance · 588; return value; by
friend · 263, 554; declaration of a nested
reference · 451; returning a value · 115;
friend class · 514; global function · 264;
type · 597; void · 115; signature · 597;
injection into namespace · 417; member
stack frame for a function call · 458;
function · 264; nested structure · 266;
static; class objects inside functions ·
structure · 264
408; member · 366, 429, 465; objects
fstream · 100
inside functions · 437; variables inside
function · 81; abstract base classes and
functions · 406; templates · 742; type ·
pure virtual functions · 646; access · 379;
390; unique identifier for each · 310;
adding more to a design · 280; adding
variable argument list · 114; virtual
new virtual functions in the derived
function · 627, 629; constructor · 662;
class · 652; address · 198, 391; argument
overriding · 632; picturing · 639
· 138; const · 344; const reference · 351;
reference · 451; array of pointers to ·
201; assembly-language code
G
generated; function call · 456; virtual
function call · 642; binding, for a
function call · 631, 641; body · 83; C
garbage collector · 42, 566
library · 116; call operator( ) · 514; call
generic algorithm · 742
overhead · 372, 377; called for side
get and set functions · 381
effect · 313; complicated function
get( ) · 472
definitions · 198; constructors, behavior
getline( ): and string · 562; from iostreams
of virtual functions inside · 664;
library · 100
creating · 112; declaration · 116, 245,
Glass, Robert · 780
313; not essential in C · 228; required ·
global: friend function · 264; functions ·
233; syntax · 82; definition · 83; empty
234; new and delete, overloading · 568;
argument list, C vs. C++ · 114;
object constructor · 410; operator,
expanding the function interface · 330;
overloaded · 487; scope resolution · 253;
global · 234; friend · 264; helper,
static initialization dependency of
assembly · 457; inline · 372, 377, 646;
global objects · 432; variables · 147
header files · 396; local class (class
GNU C++ · 71
830
img
Gorlen, Keith · 694
I
goto · 125, 288, 293; non-local · 288
greater than: > · 158; or equal to (>=) · 158
identifier: unique for each function · 310;
guaranteed initialization · 294, 548
unique for each object · 238
guards, include, on header files · 757
IEEE standard for floating-point numbers ·
guidelines: argument passing · 455; C++
130, 189
programming guidelines · 760; object
if-else · 118; defining variables inside the
development · 56
conditional · 145; statement · 164;
ternary ?: · 164
ifstream · 100, 606
H
implementation · 27, 241; and interface,
separating · 29, 261, 271, 380; hiding ·
hack, enum · 358
28, 260, 270, 275; compile-time only ·
handle classes · 275, 277
275
has-a · 30; composition · 604
implicit type conversion · 154
header file · 85, 116, 129, 233, 242, 323, 335;
in situ inline functions · 394
code organization · 248; enforced use of
include · 85; include guards, in header files
in C++ · 243; formatting standard · 246;
· 246, 757; new include format · 86
importance of using a common header
incomplete type specification · 265, 277
file · 242; include guards · 246; inline
increment · 128, 164; and decrement
definitions · 377; internal linkage · 412;
operators · 506; incrementing and
multiple inclusion · 244; namespaces ·
enumeration · 180; overloading
423; new file include format · 86; order
operator ++ · 493
of inclusion · 756; structure definition in
incremental: development · 614;
a header file · 234; templates · 700, 707;
programming · 614
using directives · 248
indeterminate argument list · 114
heap · 42, 223; C heap · 550; compactor ·
indexing: array, using [ ] · 105, 183; zero ·
225; creating objects · 554;
183
fragmentation · 225, 567; guaranteeing
inheritance · 31, 584, 586, 615; choosing
that all objects are created on the heap ·
composition vs. inheritance · 604; class
712; storage allocation · 549; simple
inheritance diagrams · 617; combining
example system · 570
composition & inheritance · 591; copy-
helper function, assembly · 457
constructor · 471; diagram · 40;
hexadecimal · 154
extending a class during · 34;
hiding: function names inside a struct ·
extensibility · 633; function redefinition
230; implementation · 28, 260, 270, 275;
· 588; initialization · 663; is-a · 600, 615;
names; during inheritance · 595; during
multiple · 586, 613, 621, 673, 695; name
overloading · 658; variables from the
hiding · 658; operator overloading &
enclosing scope · 292
inheritance · 612; order of construction ·
hierarchy, singly-rooted/object-based ·
665; private inheritance · 609; protected
672, 694
inheritance · 611; public inheritance ·
high concept · 48
587; static member functions · 604;
high-level assembly language · 113
subtyping · 606; virtual function calls in
hostile programmers · 276
destructors · 670; vs. composition · 620,
hybrid: C++, hybrid object-oriented
740; VTABLE · 652
language, and friend · 269; object-
initialization · 227, 356; aggregate · 201,
oriented programming language · 7
301; array; elements · 301; to zero · 301;
831
img
interaction with · 572; limitations of ·
const data members · 355; const inside
569; manipulators · 96; overloading <<
class · 353; constructor · 285; constructor
and >> · 518; reading and writing files ·
initializer list · 353, 589, 664; definition,
100; reading input · 97; setf( ) · 466;
simultaneous · 290; for loop · 106, 121;
strings with iostreams · 100; width( ) ·
guaranteed · 294, 548; during
466
inheritance · 663; initialization and
is-a: inheritance · 604, 615; vs. is-like-a
cleanup on the heap · 548; initializer for
relationships · 35
a static variable of a built-in type · 408;
ISO Standard: C · 14; fundamentals · 112;
lazy · 704; member object initialization ·
C++ · 14; header files · 245
589; memberwise · 471, 600; object
istream, overloading operator >> · 520
using = · 521; static; array · 425; const ·
iteration, in program development · 57
356; dependency · 432; member · 425;
iterator · 509, 719, 730; containers · 690;
zero initialization by the linking-
motivation · 738; nested class · 512;
loading mechanism · 433; variables at
Standard C++ Library · 724
point of definition · 130; vs. bitcopy ·
460
injection, friend into namespace · 417
J
inline · 394, 662; class definition · 378;
constructor efficiency · 663;
constructors · 392; convenience · 393;
Jacobsen, Ivar · 779
definitions and header files · 377;
Java · 3, 15, 65, 71, 74, 588, 645, 694, 816
destructors · 392; effectiveness · 390;
efficiency · 392; function · 372, 377, 646;
K
header files · 396; in situ · 394;
limitations · 390; non-inline template
member function definitions · 699;
K&R C · 112
order of evaluation · 391; templates ·
keywords: #define · 245, 335; #endif · 245,
707
757; #ifdef · 245; #include · 85; & · 134; (
in-memory compilation · 78
), function call operator overloading ·
input: reading by words · 106; standard ·
514; * · 136, 164; .* · 474; :: · 232, 253; `.'
97
(member selection operator) · 237; = ·
insert( ) · 104
156; overloading · 505, 521; -> · 164;
inserter and extractor, overloading for
overloading · 509; struct member
iostreams · 518
selection via pointer · 178; ->* · 474;
instance of a class · 24
overloading · 514; asm, for in-line
instantiation, template · 699
assembly language · 173; auto · 149, 414;
int · 130
bool · 125; true and false · 131; break ·
interface · 241; base-class interface · 633;
122; case · 124; catch · 572; char · 96, 130,
common interface · 647; defining the
132; class · 25, 31, 271; const · 153, 333,
class · 62; expanding function interface ·
453; const_cast · 170; continue · 122;
330; for an object · 25; implementation,
default · 124; delete · 42, 223; do · 120;
separation of · 29, 261, 271, 380; implied
double · 130, 132; dynamic_cast · 678;
by a template · 701; user · 51
else · 118; enum · 179, 358; untagged ·
internal linkage · 152, 335, 339, 412
320; explicit · 534; extern · 84, 147, 151,
interpreters · 77
335, 339, 412; for alternate linkage · 442;
interrupt service routine (ISR) · 366, 458
false · 117, 131; float · 130, 132; for · 106,
iostreams · 90; get( ) · 472; getline( ) · 100;
121; friend · 263; goto · 125, 288, 293; if ·
global overloaded new & delete;
118; inline · 394, 662; int · 130; long ·
832
img
linkage · 152, 406; alternate linkage
132; long double · 132; long float (not
specification · 442; controlling · 412;
legal) · 132; mutable · 363; namespace ·
external · 338, 339, 412; internal · 335,
91, 414, 757; new · 42, 223; operator ·
339, 412; no linkage · 153, 412; type-safe
486; private · 262, 270, 380, 610;
· 313
protected · 263, 270, 610; public · 261;
linked list · 248, 275, 298
register · 149, 414; reinterpret_cast · 171;
linker · 78, 79, 87; collision · 244; external
return · 115; short · 132; signed · 132;
references · 228; object file order · 88;
signed char · 132; sizeof · 132, 172, 587;
pre-empting a library function · 89;
with struct · 240; static · 149, 350, 406;
searching libraries · 88, 117; unresolved
static_cast · 169, 679; struct · 175, 260;
references · 88
switch · 123, 293; template · 689, 696;
Lippman, Stanley · 776
this · 234, 286, 363, 380, 429; throw · 572;
list: constructor initializer · 353, 589; linked
true · 117, 131; try · 572; typedef · 174;
· 248, 275, 298
typeid · 680; union · 181, 318;
Lister, Timothy · 781
anonymous · 320; unsigned · 132; using
local: array · 186; classes · 428; static object
· 92, 417; virtual · 39, 595, 627, 632, 637,
· 410; variable · 138, 149
646, 665; void · 114; void& (illegal) ·
logarithm · 466
143; void* · 142, 450; volatile · 155;
logical: and && · 166; const · 362; explicit
while · 101, 119
bitwise and logical operators · 173; not !
Koenig, Andrew · 376, 762, 778
· 163; operators · 158, 505; or || · 166
long · 132, 135
L
long double · 132, 155
longjmp( ) · 288
loop: for · 106; loop counter, defined inside
Lajoie, Josee · 776
control expression · 291; variable
Lakos, John · 756, 778
lifetime in for loops · 292; while · 101
language: C++ is a more strongly typed
Love, Tom · 781
language · 450; C++, hybrid object-
lvalue · 156, 346, 698
oriented language, and friend · 269;
hybrid object-oriented programming
language · 7
M
large programs, creation of · 78
late binding · 38, 631; implementing · 636
layout, object, and access control · 269
machine instructions · 76
lazy initialization · 704
macro: argument · 374; makefile · 205;
leading underscore, on identifiers
preprocessor · 158, 192, 372; macros for
(reserved) · 381
parameterized types, instead of
leaks, memory · 224, 300
templates · 696; unsafe · 399; to generate
left-shift operator << · 160
classes · 594
less than: < · 158; or equal to <= · 158
magic numbers, avoiding · 334
library · 76, 80, 88, 218; C · 219; code · 78;
main( ): basic form · 93; executing code
creating your own with the librarian ·
after exiting · 411; executing code
117; issues with different compilers ·
before entering · 411
312; Standard C function; abort( ) · 409;
maintenance, program · 58
atexit( ) · 409; exit( ) · 409
make · 202; dependencies · 204; macros ·
lifetime: for loop variables · 292; object · 42,
205; suffix rules · 205; SUFFIXES · 206
547; temporary objects · 468
makefile · 203, 750
limits.h · 129
833
img
MindView: public hands-on training
malloc( ) · 223, 550, 552, 554, 569; behavior,
seminars · 16; seminars-on-CD-ROM ·
not deterministic in time · 555
16
management obstacles · 71
minimum size of a struct · 241
mangling, name · 230, 231, 237; and
mission statement · 47
overloading · 311
mistakes, and design · 279
mathematical operators · 156
modulus (%) · 156
Matson, Kris C. · 126
Moo, Barbara · 778
member: defining storage for static data
Mortensen, Owen · 477
member · 424; initializing const data
multiparadigm programming · 24
members · 355; member function · 28,
multiple: dispatching · 675; inclusion of
230; calling · 239; calling another
header files · 244; inheritance · 586, 613,
member function from within a
621, 673, 695; multiple-declaration
member function · 234; const · 352, 359;
problem · 244
four member functions the compiler
multiplication (*) · 156
synthesizes · 619; friend · 264; non-
multitasking and volatile · 365
inline template member function
multi-way selection · 124
definitions · 699; return type · 597;
Murray, Rob · 520, 760
selection · 234; signature · 597; static ·
mutable · 363; bitwise vs. logical const ·
366, 429, 465; and inheritance · 604;
362
object · 30; object initialization · 589;
mutators · 380
overloaded member operator · 487;
pointers to members · 473; selection
operator · 237; static data member
N
inside a class · 423; vs. non-member
operators · 518
memberwise: assignment · 532, 600; const ·
name: clashes · 229; collisions, in C · 68;
362; initialization · 471, 600
decoration · 230, 231, 237, 442; no
memcpy( ) · 560; standard C library
standard for · 312; overloading and ·
function · 326
311; file · 749; hiding, during
memory · 133; allocation and efficiency ·
inheritance · 595; mangling · 230, 231,
566; dynamic memory allocation · 223,
237; and overloading · 311
548; leak · 224, 300; finding with
named constant · 153
overloaded new and delete · 573; from
namespace · 91, 414, 757; aliasing · 415;
delete void* · 557; management;
ambiguity · 420; continuation · 415;
example of · 324; reference counting ·
header files · 399; injection of friends ·
526; memory manager overhead · 554;
417; referring to names in · 417; single
read-only (ROM) · 364; simple storage
name space for functions in C · 229; std
allocation system · 570
· 92; unnamed · 416; using · 417;
memset( ) · 269, 326, 356, 560
declaration · 421; and overloading · 422;
mentoring: and training · 71, 73;
directive · 418; and header files · 247
consulting, mentoring, and design and
naming the constructor · 285
code walkthroughs from MindView ·
narrowing conversions · 170
16
NDEBUG · 198
message, sending · 25, 239, 636
needless recompilation · 276
methodology, analysis and design · 44
nested: class · 428; friend structure · 266;
Meyers, Scott · 28, 760, 778
iterator class · 512, 721; scopes · 144;
structures · 248
834
img
object-based/singly-rooted hierarchy · 672,
new · 164, 223; and delete for arrays · 563;
694
array of pointers · 558; delete and
object-oriented: analysis and design · 44;
containers · 692; keyword · 42; new-
basic concepts of object-oriented
expression · 223, 552, 566; new-handler ·
programming (OOP) · 22; C++, hybrid
565; operator new · 552; constructor,
object-oriented language, and friend ·
memory exhaustion · 576; exhausting
269; hybrid object-oriented
storage · 565; placement specifier · 577;
programming language · 7
overloading; can take multiple
obstacles, management · 71
arguments · 577; new and delete · 566;
octal · 154
for a class · 570; for arrays · 573; global ·
off-by-one error · 301
568
ofstream · 100, 594; as a static object · 411
newline · 94
one-definition rule · 82, 244
no linkage · 153, 412
ones complement operator · 159
non-local goto · 288
OOP · 271; analysis and design · 44; basic
not: bitwise · 159; equivalent != · 158;
logical not ! · 173
characteristics · 24; basic concepts of
object-oriented programming · 22;
not_eq, != (logical not-equivalent) · 173
Simula programming language · 25;
nuance, and overloading · 310
substitutability · 24; summarized · 239
NULL references · 451, 479
operator · 156; & · 134; ( ), function call ·
number, conversion to numbers from
514; * · 136, 727, 730; ?: ternary if-else ·
char* · 188
164; [ ] · 508, 559, 698; ++ · 493; <<
overloading to use with ostream · 554;
O
= · 505; as a private function · 533;
automatic creation · 532; behavior of ·
522; doesn't automatically inherit · 600;
object · 23, 79; address of · 265; const
memberwise assignment · 600; private ·
member functions · 359; creating a new
709; vs. copy-constructor · 521; -> smart
object from an existing object · 462;
pointer · 509; ->* pointer to member ·
creating on the heap · 554; definition of
514; >> and iostreams · 106; assignment
· 238; definition point · 285; destruction
· 505; auto-increment ++ · 106; binary;
of static · 410; dynamic object creation ·
operators · 160; overloaded · 487;
42, 738; file · 228; order during linking ·
overloading examples · 493; bitwise ·
88; five stages of object design · 54;
159; bool behavior with built-in
function objects · 515; global
operators · 131; C & C++ · 127; casting ·
constructor · 410; guidelines for object
166; choosing between member and
development · 56; interface to · 25;
non-member overloading, guidelines ·
layout, and access control · 269; lifetime
520; comma · 165, 508; complicated
of an object · 42, 547; local static · 410;
expressions with operator overloading ·
member · 30; module · 79; object-based ·
488; explicit bitwise and logical
238; object-based C++ · 628; outside ·
operators · 173; fan-out in automatic
139; pass by value · 462; passing and
type conversion · 540; global;
returning large objects · 457; scope,
overloaded · 487; scope resolution :: ·
going out of · 143; size · 554; forced to
253; increment ++ and decrement -- ·
be non-zero · 639; slicing · 650, 655;
506; logical · 158, 505; member selection
static; class objects inside functions ·
· 237; member vs. non-member · 518;
408, 437; initialization dependency ·
new · 552; exhausting storage · 565;
432; temporary · 347, 453, 468, 535;
new-expression · 552; placement
unique address, each object · 241
835
img
namespaces, using declaration · 421;
specifier · 577; no exponentiation · 517;
new & delete · 566; new and delete;
no user-defined · 517; ones-complement
array · 573; class · 570; global · 568; on
· 159; operators you can't overload ·
return values · 312; operator · 91; [ ] ·
517; overloading · 91, 450, 485, 732; [ ] ·
519; ++ · 493; << to use with ostream ·
519; arguments and return values · 505;
554; -> smart pointer operator · 509; ->*
check for self-assignment · 505;
pointer-to-member · 514; inheritance ·
inheritance · 612; member function ·
612; operators that can be overloaded ·
487; operators that can be overloaded ·
488; operators that can't be overloaded ·
488; reflexivity · 536; return type · 488;
517; overloading reflexivity · 536; type
virtual functions · 675; pitfalls · 166;
conversion · 535; virtual functions · 675;
postfix increment & decrement · 493;
operator · 450; overriding, difference ·
precedence · 127; prefix increment &
658; pitfalls in automatic type
decrement · 493; preprocessor stringize
conversion · 539
operator # · 196; relational · 158; scope
overriding · 632; and overloading · 658;
resolution :: · 232, 253, 429; and
during inheritance · 595; function · 35
namespaces · 417; for calling base-class
overview, chapters · 7
functions · 588; shift · 160; sizeof · 172;
ownership · 599, 709, 713, 730; and
type conversion overloading · 535;
containers · 299, 555, 671, 705
unary · 159, 163; overloaded · 487;
overloading examples · 489; unusual
overloaded · 508
P
optimization: inlines · 379; return value
optimization · 507
optimizer: global · 79; peephole · 79
pair programming · 63
or: | bitwise · 159; || logical · 158, 166, 173
paralysis, analysis · 45
or_eq, |= (bitwise or-assignment) · 173
parsing · 79; parse tree · 79
order: access specifiers · 263; constructor
pass-by-reference · 140
and destructor calls · 592; constructor
pass-by-value · 137, 462; and arrays · 186
calls · 663
passing: and returning; addresses · 344;
organization, code · 248; header files · 244
addresses, with const · 349; by value, C
ostream · 327; overloading operator << ·
· 455; large objects · 457; by value · 344,
520, 554
450, 657; temporaries · 351
output, standard · 90
patterns, design · 59, 70; iterator · 719
outside object · 139
performance issues · 72
overhead: assembly-language code
Perl · 89
generated by a virtual function · 642;
pitfall: automatic type conversion · 539; C ·
function call · 372, 377; memory
227; operators · 166; preprocessor · 372
manager · 554; size overhead of virtual
placeholder arguments · 323
functions · 637
placement, operator new placement
overloading · 95; << and >> for iostreams ·
specifier · 577
518; assignment · 521; choosing
planning, software development · 47
between members and non-members,
Plauger, P.J. · 780
guidelines · 520; constructor · 319;
Plum, Tom · 394, 751, 760
default arguments, difference with
point, sequence · 286, 293
overloading · 324; fan-out in automatic
pointer · 136, 153, 164, 276, 450; argument
type conversion · 540; function · 310;
passing, vs. references · 351; arithmetic ·
function call operator( ) · 514; global
190; array · 184; making a pointer look
operators vs. member operators · 536;
like an array · 564; of pointers · 187;
836
img
program: maintenance · 58; structure when
assignments, const and non-const · 343;
writing code · 93
classes containing, and overloading
programmer, client · 28, 260
operator= · 524; const · 171, 340;
programming: basic concepts of object-
formatting definitions · 342;
oriented programming (OOP) · 22;
introduction · 133; member, pointer to ·
Extreme Programming (XP) · 61, 615,
473; function · 475; overloading · 514;
779; in the large · 68; incremental
pointer & reference upcasting · 622;
process · 614; multiparadigm · 24; pair ·
pointer to function; array of · 201;
63
defining · 198; using · 200; reference to
programs, calling other · 98
pointer · 454; reference, difference · 140;
project building tools · 203
smart pointer · 730; square brackets ·
promotion · 228; automatic type
185; stack · 294; struct, member
conversion · 533
selection with -> · 178; upcasting · 631;
protected · 29, 263, 270, 610; inheritance ·
void · 450, 555, 559, 562; void* · 142; vs.
611
reference when modifying outside
prototyping: function · 113; rapid · 59
objects · 472
pseudoconstructor, for built-in types · 381,
polymorphism · 37, 597, 627, 681, 713, 741;
562, 589
containers · 738; polymorphic function
public · 29, 261; inheritance · 587; seminars
call · 637; vs. downcasting · 678
·5
postconditions · 758
pure: abstract base classes and pure virtual
post-decrement -- · 128
functions · 646; C++, hybrid object-
postfix operator increment & decrement ·
oriented language, and friend · 269;
493
substitution · 35; virtual destructor ·
post-increment ++ · 128
668; virtual function definitions · 651
precedence, operator · 127
push_back( ), for vector · 104
preconditions · 758
push-down stack · 275
pre-decrement -- · 128
putc( ) · 376
prefix operator increment & decrement ·
puts( ) · 569
493
Python · 54, 74, 77, 78, 89, 645, 702
pre-increment ++ · 128
preprocessor · 79, 85, 153; #define, #ifdef
and #endif · 245; and scoping · 376;
Q
debugging flags · 194; macro · 158, 192,
372; unsafe · 399; pitfall · 372; problems
· 372; string concatenation · 395;
qualifier, c-v · 366
stringizing · 395; token pasting · 395;
value substitution · 334
R
prerequisites, for this book · 22
preventing automatic type conversion
with the keyword explicit · 534
ranges, used by containers and iterators in
printf( ) · 569
the Standard C++ Library · 728
private · 29, 262, 270, 377, 380, 610; copy-
rapid prototyping · 59
constructor · 471; private inheritance ·
reading: files · 100; input by words · 106
609
read-only memory (ROM) · 364
problem space · 23
realloc( ) · 223, 550, 554
process · 365
recompiling C programs in C++ · 236
production, and book design · 18
recursion · 126, 459; and inline functions ·
392
837
img
reuse · 55; code reuse · 583; existing class
re-declaration of classes, preventing · 244
libraries · 70; source code reuse with
redefining during inheritance · 595
templates · 696; templates · 689
reducing recompilation · 276
right-shift operator (>>) · 160
re-entrant · 458
ROM, read-only memory, ROMability ·
refactoring · 58
364
reference · 153, 450, 451; C++ · 140; const ·
rotate · 162; bit manipulation · 162
345, 453; and operator overloading ·
RTTI, run-time type identification · 655,
505; for argument passing · 351;
680
efficiency · 455; external, during linking
rule, makefile · 204
· 228; free-standing · 451; function · 452;
Rumbaugh, James · 779
NULL · 451, 479; passing const · 473;
run-time: access control · 275; binding ·
pointer & reference upcasting · 622;
631; debugging flags · 195; type
pointer, reference to a pointer · 454;
identification (RTTI) · 655, 680
reference counting · 526, 714; rules ·
rvalue · 156, 698
451; upcasting · 630; void reference
(illegal) · 143; vs. pointer when
modifying outside objects · 472
S
reflexivity, in operator overloading · 536
register · 414; variables · 149
reinterpret_cast · 171
safe union · 319
relational operators · 158
Saks, Dan · 66, 394, 751, 760
reporting errors in book · 16
scenario · 49
request, in OOP · 25
scheduling · 51
require( ) · 698, 711, 757
Schwarz, Jerry · 434
require.h · 237, 252, 756, 757; function
scope · 143, 288, 339, 554; consts · 337; file ·
definitions · 396
339, 412; going out of · 143; hide
requireArgs( ), from require.h · 252
variables from the enclosing scope ·
requirements analysis · 48
292; preprocessor · 376; resolution;
resolution, scope: global · 253; nested
global · 253; nested structures · 278;
structures · 278; operator :: · 232
operator :: · 232, 429; and namespaces ·
resolving references · 80
417; for calling base-class functions ·
return: by value · 450; by value as const,
588; scoped variable · 42; static member
and operator overloading · 507; const
initialization · 425; storage allocation ·
value · 345; constructor return value ·
549; use case · 57
287; efficiency when creating and
second edition, what's new · 2
returning objects · 507; function return
security · 276
values, references · 451; keyword · 115;
selection: member function · 234; multi-
operator; overloaded return type · 488;
way · 124
overloading arguments and return
self-assignment, checking for in operator
values · 505; overloading on return
overloading · 505, 523
values · 312; passing and returning by
semantics, return value · 350
value, C · 455; passing and returning
seminars: on CD-ROM, from MindView ·
large objects · 457; references to local
16; public · 5; training seminars from
objects · 452; type · 597; value · 81; from
MindView · 16
a function · 115; optimization · 507;
sending a message · 25, 239, 636
semantics · 350; void · 115
sentinel, end · 728, 736
RETURN, assembly-language · 458
separate compilation · 78, 80; and make ·
reusability · 29
202
838
img
Standard C++ Library: algorithms · 742;
separation of interface and
insert( ) · 104; push_front( ) · 104;
implementation · 29, 261, 271
ranges, used by containers and iterators
sequence point · 286, 293
· 728
set: <set> standard header file · 711; and
standard for each class header file · 246
get functions · 381; container class from
standard input · 97
the Standard C++ Library · 711
standard library · 89
setf( ), iostreams · 466
standard library header file: cassert · 197;
setjmp( ) · 288
cstdlib · 188; cstring · 269; set · 711;
SGI (Silicon Graphics) STL project · 103
sstream · 520; typeinfo · 680
shape: example · 32; hierarchy · 682
standard output · 90
shift operators · 160
Standard Template Library (STL) · 103
short · 132
standards, C++ Committee · 14
side effect · 156, 164
startup costs · 71
signature · 597
startup module · 89
signed · 132; char · 132
Stash example class · 219, 230, 274, 294,
Silicon Graphics (SGI) STL project · 103
314, 322, 385, 558, 707
Simula programming language · 25, 271
statement: continuation over several lines ·
single-precision floating point · 130
97; mission · 47
singly-rooted/object-based hierarchy · 672,
static · 149, 406, 711; array · 692;
694
initialization · 425; class objects inside
size: built-in types · 129; object · 554; forced
functions · 408; confusion when using ·
to be nonzero · 639; size_t · 568; storage
412; const · 356; data; area · 406;
· 220; struct · 240; word · 133
members inside a class · 423, 430;
sizeof · 132, 172, 302, 587; char · 173; struct
defining storage for · 424; destruction of
· 240
objects · 410; file · 414; initialization
slicing: object slicing · 655
dependency · 432; initialization to zero ·
Smalltalk · 24, 80, 645, 694, 702
433; initializer for a variable of a built-
smart pointer operator -> · 509, 730
in type · 408; local object · 410; member
software: crisis · 8; development
functions · 366, 429, 465; inheritance
methodology · 45
and · 604; objects inside functions · 437;
solution space · 23
storage · 41, 406; area · 549; type
solutions, exercise · 12
checking · 80; variables in functions as
source code availability · 12
return values · 350; variables inside
source-level debugger · 78
functions · 406
space: problem · 23; solution · 23
static_cast · 169, 679; downcast · 681
specification: incomplete type · 265, 277;
std namespace · 92
system specification · 48
step, in for loop · 121
specifier: access specifiers · 29, 261; no
STL: Silicon Graphics (SGI) STL project ·
required order in a class · 263; to
103; Standard Template Library · 103
modify basic built-in types · 132
storage: allocation · 292; const and extern ·
specifying storage allocation · 147
336; auto storage class specifier · 414;
sstream standard header file · 520
const, in C vs. C++ · 339; defining
stack · 41, 248, 294, 549; function-call stack
storage for static data members · 424;
frame · 458; pointer · 406; push-down ·
extern storage class specifier · 412;
275; storage allocation · 549; variable on
register storage class specifier · 414;
the stack · 225
running out of · 565; simple allocation
Stack example class · 248, 274, 298, 388,
system · 570; sizes · 220; static · 41, 406;
597, 672, 690, 705, 728
839
img
area · 549; storage class specifier · 412;
T
storage class · 412
storing type information · 637
tab · 95
Straker, David · 755
table-driven code · 201
string · 94, 227; class, Standard C++ · 99;
tag name · 220
concatenation · 96; copying a file into ·
tag, comment for linking · 148
102; getline( ) · 562; preprocessor # to
template · 689, 696; argument list · 700;
turn a variable name into a string · 196;
basic usage · 104; class · 742; constants
preprocessor string concatenation · 395
and default values in templates · 703;
stringizing, preprocessor · 395; macros ·
container class templates and virtual
192; operator # · 196
functions · 743; function · 742;
stringstream · 520
generated classes · 699; header file · 700,
strong typing, C++ is a more strongly
707; implies an interface · 701; inline ·
typed language · 450
707; instantiation · 699; multiple
Stroustrup, Bjarne · 4, 433, 696, 748, 776,
definitions · 700; non-inline template
779
member function definitions · 699;
struct · 175, 219, 238, 260; aggregate
preprocessor macros for parameterized
initialization · 302; array of · 183; hiding
types, instead of templates · 696;
function names inside · 230; minimum
Standard Template Library (STL) · 103;
size · 241; pointer selection of member
Stash and Stack examples as templates ·
with -> · 178; size of · 240
705; weak typing · 701
structure: aggregate initialization and
temporary object · 347, 468, 535; bugs · 348;
structures · 302; declaration · 245, 265;
function references · 453; passing a
definition in a header file · 234; friend ·
temporary object to a function · 351;
264; nested · 248; redeclaring · 245
return value · 508
subobject · 585, 587, 588, 604
ternary operator · 164
substitutability, in OOP · 24
testing: automated · 62; Extreme
substitution: principle · 35; value · 334
Programming (XP) · 61
subtraction (-) · 156
Thinking in C: Foundations for Java and
subtyping · 606
C++ CD ROM · 2, 112, 776
suffix rules, makefile · 205
Thinking in C++ Volume 2, what's in it
SUFFIXES, makefile · 206
and how to get it · 3
sugar, syntactic · 485
this · 286, 363, 380, 429, 468, 552, 642;
switch · 123, 293; defining variables inside
address of current object · 234
the selector statement · 145
throw · 572
syntax: function declaration syntax · 82;
time, Standard C library · 384
operator overloading · 487; sugar, with
time_t · 384
operator overloading · 485; variable
token pasting, preprocessor · 395
declaration syntax · 83
toupper( ), unexpected results · 376
synthesized: default constructor, behavior
trailing arguments only can be defaults ·
of · 305; member functions that are
322
automatically created by the compiler ·
training · 69; and mentoring · 71, 73;
600, 619
seminars from MindView · 16
system specification · 48
translation unit · 228, 432
system() · 98
true · 158, 163, 166, 246; and false, in
conditionals · 117; bool, true and false ·
131
840
img
unsigned · 132
try block · 572
untagged enum · 320, 358
type: abstract data type · 239; automatic
unusual operator overloading · 508
type conversion · 533; preventing with
upcasting · 40, 615, 629, 636, 678, 738; by
the keyword explicit · 534; with
value · 644; copy-constructor · 617;
operator overloading · 535; base · 32;
explicit cast for upcasting · 681; pointer
basic built-in · 129; cast · 135; checking ·
· 631; and reference upcasting · 622;
80, 83, 153, 167; stricter in C++ · 227;
reference · 630; type information, lost ·
conversion · 228; implicit · 154; creation,
622
composite · 174; data type equivalence
use case · 49; iteration · 57; scope · 57
to class · 26; derived · 32; function type ·
user interface · 51
390; improved type checking · 236;
user-defined data type · 76, 129, 239
incomplete type specification · 265, 277;
using keyword, for namespaces · 92, 417;
inheritance, is-a · 615; initialization of
declaration · 421, 757; directive · 92, 418,
built-in types with `constructors' · 354;
757; header files · 247; namespace std ·
run-time type identification (RTTI) ·
247
655, 680; storing type information · 637;
type checking; for enumerations · 180;
for unions · 181; type-safe linkage · 313;
V
user-defined · 76, 239; weak typing · 38,
702; C++ via templates · 701
typedef · 174, 177, 220, 231, 414
value: constant · 154; minimum and
typefaces, book · 18
maximum for built-in types · 129; pass-
typeid · 680
by-value · 137; preprocessor value
typeinfo standard header file · 680
substitution · 334; return · 81; returning
type-safe downcast · 678
by value · 352
varargs · 243; variable argument list · 243
variable: argument list · 114; varargs · 243;
U
automatic · 42, 149, 153; declaration
syntax · 83; defining · 145; file scope ·
150; global · 147; going out of scope ·
UML · 54; indicating composition · 30;
143; hide from the enclosing scope ·
Unified Modeling Language · 27, 779
292; initializer for a static variable of a
unary: examples of all overloaded unary
built-in type · 408; lifetime, in for loops ·
operators · 489; minus - · 163; operators
292; local · 138, 149; point of definition ·
· 159, 163; overloaded · 487; plus + · 163
289; register · 149; scoped · 42; stack ·
underscore, leading, on identifiers
225; turning name into a string · 196
(reserved) · 381
vector · 740; assignment · 108; of change ·
Unified Modeling Language (UML) · 27,
59; push_back( ) · 104; Standard C++
779
Library · 102
union: additional type checking · 181;
virtual destructor · 665, 707, 736, 740; pure
anonymous · 320; file scope · 321;
virtual destructor · 668
difference between a union and a class ·
virtual function · 595, 627, 629, 646, 741;
319; member functions and access
adding new virtual functions in the
control · 318; safe · 319; saving memory
derived class · 652; and dynamic_cast ·
with · 181
679; assembly-language code generated
unit, translation · 228
by a virtual function · 642; constructors,
unnamed: arguments · 114; namespace ·
behavior of virtual functions inside ·
416
662, 664; destructors, behavior of
unresolved references, during linking · 88
841
img
virtual functions inside · 670; efficiency
W
· 645; late binding · 637; operator
overloading and virtual functions · 675;
Waldrop, M. Mitchell · 781
overriding · 632; picturing virtual
weak: typing · 702; in C++ via templates ·
functions · 639; pure virtual function;
701; weakly typed language · 38
and abstract base classes · 646;
while loop · 101, 119; defining variables
definitions · 651; size overhead of
inside the control expression · 145
virtual functions · 637; virtual keyword
width( ), iostreams · 466
· 39, 632; in base-class declarations · 632;
wild-card · 46
in derived-class declarations · 632
Will-Harris, Daniel · 17, 18
virtual memory · 552
word size · 133
visibility · 406
writing files · 100
void: argument list · 114; casting void
pointers · 235; keyword · 114; pointer ·
220, 450, 555, 559, 562; reference
X
(illegal) · 143
void* · 142, 170, 220; bugs · 235; containers
xor ^ bitwise exclusive-or · 159, 173
and ownership · 671; delete, a bug · 555
xor_eq, ^= bitwise exclusive-or-
volatile · 155, 365; casting with const_cast ·
assignment · 173
170
XP, Extreme Programming · 61
Volume 2, Thinking in C++ · 3
vpointer, abbreviated as VPTR · 637
VPTR · 637, 640, 642, 662, 665; installation
Z
by the constructor · 643
VTABLE · 637, 640, 642, 648, 653, 662, 665;
zero indexing · 183
inheritance and the VTABLE · 652
842
img
Public
C++ Seminars
Check
for in-depth details and the date
and location of the next:
Hands-On C++ Seminar
· Based on this book
· Get a solid grounding in Standard C++ fundamentals
· Includes in-class programming exercises
· Personal attention during exercises
Intermediate C++ Seminar
· Based on Volume 2 of this book (downloadable at
)
· In-depth coverage of the Standard C++ Library
· Strings, containers, iterators, algorithms
· In-depth templates & exception handling
Advanced C++ Topics
· Based on advanced topics in Volume 2 of this book
· Design patterns
· Building robust systems
· Creating testing & debugging frameworks
Subscribe to the free newsletter
to be automatically informed
of upcoming seminars
Also visit www.BrucEckel.com for:
Consulting Services
!"
!"
Exercise solutions for this book
844
img
Seminars-on-CD-ROM
If you like theThinking in C
Seminar-on-CD packaged with
this book, then you'll also like:
Bruce Eckel's
Hands-On C++ Seminar
Multimedia CD ROM
It's like coming to the seminar!
Available at
·
Overhead slides and synchronized audio recorded by Bruce Eckel
·
All the lectures from the Hands-On C++ Seminar
·
Based on this book
·
Get a solid grounding in Standard C++ Fundamentals
·
Just play it to see and hear the lectures!
·
Lectures are indexed so you can rapidly locate the discussion
of any subject
·
Details and sample lecture can be found on the Web site
See
for other Seminars-on-CD ROM
· The Intermediate C++ Seminar
· Advanced C++ Topics
845
img
End-User License Agreement for Microsoft Software
IMPORTANT-READ CAREFULLY: This Microsoft End-User License
Agreement ("EULA") is a legal agreement between you (either an
individual or a single entity) and Microsoft Corporation for the
Microsoft software product included in this package, which includes
computer software and may include associated media, printed
materials, and "online" or electronic documentation ("SOFTWARE
PRODUCT"). The SOFTWARE PRODUCT also includes any updates and
supplements to the original SOFTWARE PRODUCT provided to you by
Microsoft. By installing, copying, downloading, accessing or otherwise
using the SOFTWARE PRODUCT, you agree to be bound by the terms
of this EULA. If you do not agree to the terms of this EULA, do not
install, copy, or otherwise use the SOFTWARE PRODUCT.
SOFTWARE PRODUCT LICENSE
The SOFTWARE PRODUCT is protected by copyright laws and
international copyright treaties, as well as other intellectual property
laws and treaties. The SOFTWARE PRODUCT is licensed, not sold.
1. GRANT OF LICENSE. This EULA grants you the following rights:
1.1 License Grant. Microsoft grants to you as an individual, a personal
nonexclusive license to make and use copies of the SOFTWARE
PRODUCT for the sole purposes of evaluating and learning how to use
the SOFTWARE PRODUCT, as may be instructed in accompanying
publications or documentation. You may install the software on an
unlimited number of computers provided that you are the only
individual using the SOFTWARE PRODUCT.
1.2 Academic Use. You must be a "Qualified Educational User" to use
the SOFTWARE PRODUCT in the manner described in this section. To
determine whether you are a Qualified Educational User, please
contact the Microsoft Sales Information Center/One Microsoft
Way/Redmond, WA 98052-6399 or the Microsoft subsidiary serving
your country. If you are a Qualified Educational User, you may either:
(i) exercise the rights granted in Section 1.1, OR
(ii) if you intend to use the SOFTWARE PRODUCT solely for
instructional purposes in connection with a class or other educational
program, this EULA grants you the following alternative license
models:
(A) Per Computer Model. For every valid license you have acquired for
the SOFTWARE PRODUCT, you may install a single copy of the
SOFTWARE PRODUCT on a single computer for access and use by an
unlimited number of student end users at your educational institution,
846
img
provided that all such end users comply with all other terms of this
EULA, OR
(B) Per License Model. If you have multiple licenses for the SOFTWARE
PRODUCT, then at any time you may have as many copies of the
SOFTWARE PRODUCT in use as you have licenses, provided that such
use is limited to student or faculty end users at your educational
institution and provided that all such end users comply with all other
terms of this EULA. For purposes of this subsection, the SOFTWARE
PRODUCT is "in use" on a computer when it is loaded into the
temporary memory (i.e., RAM) or installed into the permanent memory
(e.g., hard disk, CD ROM, or other storage device) of that computer,
except that a copy installed on a network server for the sole purpose
of distribution to other computers is not "in use". If the anticipated
number of users of the SOFTWARE PRODUCT will exceed the number
of applicable licenses, then you must have a reasonable mechanism or
process in place to ensure that the number of persons using the
SOFTWARE PRODUCT concurrently does not exceed the number of
licenses.
2. DESCRIPTION OF OTHER RIGHTS AND LIMITATIONS.
·  Limitations on Reverse Engineering, Decompilation, and
Disassembly. You may not reverse engineer, decompile, or disassemble
the SOFTWARE PRODUCT, except and only to the extent that such
activity is expressly permitted by applicable law notwithstanding this
limitation.
·  Separation of Components. The SOFTWARE PRODUCT is licensed as
a single product. Its component parts may not be separated for use on
more than one computer.
·  Rental. You may not rent, lease or lend the SOFTWARE PRODUCT.
· Trademarks. This EULA does not grant you any rights in connection
with any trademarks or service marks of Microsoft.
·  Software Transfer. The initial user of the SOFTWARE PRODUCT may
make a one-time permanent transfer of this EULA and SOFTWARE
PRODUCT only directly to an end user. This transfer must include all of
the SOFTWARE PRODUCT (including all component parts, the media
and printed materials, any upgrades, this EULA, and, if applicable, the
Certificate of Authenticity). Such transfer may not be by way of
consignment or any other indirect transfer. The transferee of such one-
time transfer must agree to comply with the terms of this EULA,
including the obligation not to further transfer this EULA and
SOFTWARE PRODUCT.
·  No Support. Microsoft shall have no obligation to provide any
product support for the SOFTWARE PRODUCT.
·  Termination. Without prejudice to any other rights, Microsoft may
terminate this EULA if you fail to comply with the terms and conditions
847
img
of this EULA. In such event, you must destroy all copies of the
SOFTWARE PRODUCT and all of its component parts.
3. COPYRIGHT. All title and intellectual property rights in and to the
SOFTWARE PRODUCT (including but not limited to any images,
photographs, animations, video, audio, music, text, and "applets"
incorporated into the SOFTWARE PRODUCT), the accompanying
printed materials, and any copies of the SOFTWARE PRODUCT are
owned by Microsoft or its suppliers. All title and intellectual property
rights in and to the content which may be accessed through use of the
SOFTWARE PRODUCT is the property of the respective content owner
and may be protected by applicable copyright or other intellectual
property laws and treaties. This EULA grants you no rights to use such
content. All rights not expressly granted are reserved by Microsoft.
4. BACKUP COPY. After installation of one copy of the SOFTWARE
PRODUCT pursuant to this EULA, you may keep the original media on
which the SOFTWARE PRODUCT was provided by Microsoft solely for
backup or archival purposes. If the original media is required to use
the SOFTWARE PRODUCT on the COMPUTER, you may make one copy
of the SOFTWARE PRODUCT solely for backup or archival purposes.
Except as expressly provided in this EULA, you may not otherwise
make copies of the SOFTWARE PRODUCT or the printed materials
accompanying the SOFTWARE PRODUCT.
5. U.S. GOVERNMENT RESTRICTED RIGHTS. The SOFTWARE
PRODUCT and documentation are provided with RESTRICTED RIGHTS.
Use, duplication, or disclosure by the Government is subject to
restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
Technical Data and Computer Software clause at DFARS 252.227-7013
or subparagraphs (c)(1) and (2) of the Commercial Computer
Software-Restricted Rights at 48 CFR 52.227-19, as applicable.
Manufacturer is Microsoft Corporation/One Microsoft Way/Redmond,
WA 98052-6399.
6. EXPORT RESTRICTIONS. You agree that you will not export or re-
export the SOFTWARE PRODUCT, any part thereof, or any process or
service that is the direct product of the SOFTWARE PRODUCT (the
foregoing collectively referred to as the "Restricted Components"), to
any country, person, entity or end user subject to U.S. export
restrictions. You specifically agree not to export or re-export any of the
Restricted Components (i) to any country to which the U.S. has
embargoed or restricted the export of goods or services, which
currently include, but are not necessarily limited to Cuba, Iran, Iraq,
Libya, North Korea, Sudan and Syria, or to any national of any such
country, wherever located, who intends to transmit or transport the
Restricted Components back to such country; (ii) to any end-user who
you know or have reason to know will utilize the Restricted
848
img
Components in the design, development or production of nuclear,
chemical or biological weapons; or (iii) to any end-user who has been
prohibited from participating in U.S. export transactions by any federal
agency of the U.S. government. You warrant and represent that
neither the BXA nor any other U.S. federal agency has suspended,
revoked, or denied your export privileges.
7. NOTE ON JAVA SUPPORT. THE SOFTWARE PRODUCT MAY CONTAIN
SUPPORT FOR PROGRAMS WRITTEN IN JAVA. JAVA TECHNOLOGY IS
NOT FAULT TOLERANT AND IS NOT DESIGNED, MANUFACTURED, OR
INTENDED FOR USE OR RESALE AS ON-LINE CONTROL EQUIPMENT IN
HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE PERFORMANCE,
SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL,
DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
THE FAILURE OF JAVA TECHNOLOGY COULD LEAD DIRECTLY TO
DEATH, PERSONAL INJURY, OR SEVERE PHYSICAL OR
ENVIRONMENTAL DAMAGE.
MISCELLANEOUS
If you acquired this product in the United States, this EULA is governed
by the laws of the State of Washington.
If you acquired this product in Canada, this EULA is governed by the
laws of the Province of Ontario, Canada. Each of the parties hereto
irrevocably attorns to the jurisdiction of the courts of the Province of
Ontario and further agrees to commence any litigation which may arise
hereunder in the courts located in the Judicial District of York, Province
of Ontario.
If this product was acquired outside the United States, then local law
may apply.
Should you have any questions concerning this EULA, or if you desire
to contact Microsoft for any reason, please contact
Microsoft, or write: Microsoft Sales Information Center/One Microsoft
Way/Redmond, WA 98052-6399.
LIMITED WARRANTY
LIMITED WARRANTY. Microsoft warrants that (a) the SOFTWARE
PRODUCT will perform substantially in accordance with the
accompanying written materials for a period of ninety (90) days from
the date of receipt, and (b) any Support Services provided by Microsoft
shall be substantially as described in applicable written materials
provided to you by Microsoft, and Microsoft support engineers will
make commercially reasonable efforts to solve any problem. To the
849
img
extent allowed by applicable law, implied warranties on the SOFTWARE
PRODUCT, if any, are limited to ninety (90) days. Some
states/jurisdictions do not allow limitations on duration of an implied
warranty, so the above limitation may not apply to you.
CUSTOMER REMEDIES. Microsoft's and its suppliers' entire liability and
your exclusive remedy shall be, at Microsoft's option, either (a) return
of the price paid, if any, or (b) repair or replacement of the SOFTWARE
PRODUCT that does not meet Microsoft's Limited Warranty and that is
returned to Microsoft with a copy of your receipt. This Limited
Warranty is void if failure of the SOFTWARE PRODUCT has resulted
from accident, abuse, or misapplication. Any replacement SOFTWARE
PRODUCT will be warranted for the remainder of the original warranty
period or thirty (30) days, whichever is longer. Outside the United
States, neither these remedies nor any product support services
offered by Microsoft are available without proof of purchase from an
authorized international source.
NO OTHER WARRANTIES. TO THE MAXIMUM EXTENT PERMITTED BY
APPLICABLE LAW, MICROSOFT AND ITS SUPPLIERS DISCLAIM ALL
OTHER WARRANTIES AND CONDITIONS, EITHER EXPRESS OR
IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES
OR CONDITIONS OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE, TITLE AND NON-INFRINGEMENT, WITH REGARD TO THE
SOFTWARE PRODUCT, AND THE PROVISION OF OR FAILURE TO
PROVIDE SUPPORT SERVICES. THIS LIMITED WARRANTY GIVES YOU
SPECIFIC LEGAL RIGHTS. YOU MAY HAVE OTHERS, WHICH VARY FROM
STATE/JURISDICTION TO STATE/JURISDICTION.
LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY
APPLICABLE LAW, IN NO EVENT SHALL MICROSOFT OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR
CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT
LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER
PECUNIARY LOSS) ARISING OUT OF THE USE OF OR INABILITY TO
USE THE SOFTWARE PRODUCT OR THE FAILURE TO PROVIDE
SUPPORT SERVICES, EVEN IF MICROSOFT HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES. IN ANY CASE, MICROSOFT'S
ENTIRE LIABILITY UNDER ANY PROVISION OF THIS EULA SHALL BE
LIMITED TO THE GREATER OF THE AMOUNT ACTUALLY PAID BY YOU
FOR THE SOFTWARE PRODUCT OR U.S.$5.00; PROVIDED, HOWEVER,
IF YOU HAVE ENTERED INTO A MICROSOFT SUPPORT SERVICES
AGREEMENT, MICROSOFT'S ENTIRE LIABILITY REGARDING SUPPORT
SERVICES SHALL BE GOVERNED BY THE TERMS OF THAT AGREEMENT.
BECAUSE SOME STATES/JURISDICTIONS DO NOT ALLOW THE
850
img
EXCLUSION OR LIMITATION OF LIABILITY, THE ABOVE LIMITATION
MAY NOT APPLY TO YOU.
0495 Part No. 64358
851
img
LICENSE AGREEMENT FOR MindView, Inc.'s
Thinking in C: Foundations for C++ & Java CD-ROM
by Chuck Allison
This CD is provided together with the book "Thinking in C++ 2nd
edition, Volume 1."
READ THIS AGREEMENT BEFORE USING THIS "Thinking in C:
Foundations for C++ & Java" (Hereafter called "CD"). BY USING THE
CD YOU AGREE TO BE BOUND BY THE TERMS AND CONDITIONS OF
THIS AGREEMENT. IF YOU DO NOT AGREE TO THE TERMS AND
CONDITIONS OF THIS AGREEMENT, IMMEDIATELY RETURN THE
UNUSED CD FOR A FULL REFUND OF MONIES PAID, IF ANY.
©2000 MindView Inc. All rights reserved. Printed in the U.S.
SOFTWARE REQUIREMENTS
The purpose of this CD is to provide the Content, not the associated
software necessary to view the Content. The Content of this CD is in
HTML for viewing with Microsoft Internet Explorer 4 or newer, and uses
Microsoft Sound Codecs available in Microsoft's Windows Media Player
for Windows or the Macintosh. It is your responsibility to correctly
install the appropriate Microsoft software for your system.
The text, images, and other media included on this CD ("Content") and
their compilation are licensed to you subject to the terms and
conditions of this Agreement by MindView Inc., having a place of
business at 5343 Valle Vista, La Mesa, CA 91941. Your rights to use
other programs and materials included on the CD are also governed by
separate agreements distributed with those programs and materials on
the CD (the "Other Agreements"). In the event of any inconsistency
between this Agreement and the Other Agreements, this Agreement
shall govern. By using this CD, you agree to be bound by the terms
and conditions of this Agreement. MindView Inc. owns title to the
Content and to all intellectual property rights therein, except insofar as
it contains materials that are proprietary to third-party suppliers. All
rights in the Content except those expressly granted to you in this
Agreement are reserved to MindView Inc. and such suppliers as their
respective interests may appear.
1. LIMITED LICENSE
MindView Inc. grants you a limited, nonexclusive, nontransferable
license to use the Content on a single dedicated computer (excluding
network servers). This Agreement and your rights hereunder shall
automatically terminate if you fail to comply with any provisions of this
852
img
Agreement or any of the Other Agreements. Upon such termination,
you agree to destroy the CD and all copies of the CD, whether lawful
or not, that are in your possession or under your control.
2. ADDITIONAL RESTRICTIONS
a. You shall not (and shall not permit other persons or entities to)
directly or indirectly, by electronic or other means, reproduce (except
for archival purposes as permitted by law), publish, distribute, rent,
lease, sell, sublicense, assign, or otherwise transfer the Content or any
part thereof.
b. You shall not (and shall not permit other persons or entities to) use
the Content or any part thereof for any commercial purpose or merge,
modify, create derivative works of, or translate the Content.
c. You shall not (and shall not permit other persons or entities to)
obscure MindView's or its suppliers copyright, trademark, or other
proprietary notices or legends from any portion of the Content or any
related materials.
3. PERMISSIONS
a. Except as noted in the Contents of the CD, you must treat this
software just like a book. However, you may copy it onto a computer
to be used and you may make archival copies of the software for the
sole purpose of backing up the software and protecting your
investment from loss. By saying, "just like a book," MindView, Inc.
means, for example, that this software may be used by any number of
people and may be freely moved from one computer location to
another, so long as there is no possibility of its being used at one
location or on one computer while it is being used at another. Just as a
book cannot be read by two different people in two different places at
the same time, neither can the software be used by two different
people in two different places at the same time.
b. You may show or demonstrate the un-modified Content in a live
presentation, live seminar, or live performance as long as you attribute
all material of the Content to MindView, Inc.
c. Other permissions and grants of rights for use of the CD must be
obtained directly from MindView, Inc. at http://www.MindView.net.
(Bulk copies of the CD may also be purchased at this site.)
853
img
DISCLAIMER OF WARRANTY
The Content and CD are provided "AS IS" without warranty of any
kind, either express or implied, including, without limitation, any
warranty of merchantability and fitness for a particular purpose. The
entire risk as to the results and performance of the CD and Content is
assumed by you. MindView Inc. and its suppliers assume no
responsibility for defects in the CD, the accuracy of the Content, or
omissions in the CD or the Content. MindView Inc. and its suppliers do
not warrant, guarantee, or make any representations regarding the
use, or the results of the use, of the product in terms of correctness,
accuracy, reliability, currentness, or otherwise, or that the Content will
meet your needs, or that operation of the CD will be uninterrupted or
error-free, or that any defects in the CD or Content will be corrected.
MindView Inc. and its suppliers shall not be liable for any loss,
damages, or costs arising from the use of the CD or the interpretation
of the Content. Some states do not allow exclusion or limitation of
implied warranties or limitation of liability for incidental or
consequential damages, so all of the above limitations or exclusions
may not apply to you.
In no event shall MindView Inc. or its suppliers' total liability to you for
all damages, losses, and causes of action (whether in contract, tort, or
otherwise) exceed the amount paid by you for the CD.
MindView, Inc., and Prentice-Hall, Inc. specifically disclaim the implied
warrantees of merchantability and fitness for a particular purpose. No
oral or written information or advice given by MindView, Inc., Prentice-
Hall, Inc., their dealers, distributors, agents or employees shall create
a warrantee. You may have other rights, which vary from state to
state.
Neither MindView, Inc., Bruce Eckel, Chuck Allison, Prentice Hall, nor
anyone else who has been involved in the creation, production or
delivery of the product shall be liable for any direct, indirect,
consequential, or incidental damages (including damages for loss of
business profits, business interruption, loss of business information,
and the like) arising out of the use of or inability to use the product
even if MindView, Inc., has been advised of the possibility of such
damages. Because some states do not allow the exclusion or limitation
of liability for consequential or incidental damages, the above
limitation may not apply to you.
854
img
This CD is provided as a supplement to the book "Thinking in C++ 2nd
edition." The sole responsibility of Prentice-Hall will be to provide a
replacement CD in the event that the one that came with the book is
defective. This replacement warrantee shall be in effect for a period of
sixty days from the purchase date. MindView, Inc. does not bear any
additional responsibility for the CD.
NO TECHNICAL SUPPORT IS PROVIDED WITH THIS CD ROM
The following are trademarks of their respective companies in the U.S.
and may be protected as trademarks in other countries: Sun and the
Sun Logo, Sun Microsystems, Java, all Java-based names and logos
and the Java Coffee Cup are trademarks of Sun Microsystems; Internet
Explorer, the Windows Media Player, DOS, Windows 95, and Windows
NT are trademarks of Microsoft.
855
img
Thinking in C: Foundations for Java & C++
Multimedia Seminar-on-CD ROM
©2000 MindView, Inc. All rights reserved.
WARNING: BEFORE OPENING THE DISC PACKAGE, CAREFULLY
READ THE TERMS AND CONDITIONS OF THE LICENSE
AGREEMENT & WARANTEE LIMITATION ON THE PREVIOUS
PAGES.
The CD ROM packaged with this book is a multimedia seminar
consisting of synchronized slides and audio lectures. The goal of
this seminar is to introduce you to the aspects of C that are
necessary for you to move on to C++ or Java, leaving out the
unpleasant parts that C programmers must deal with on a day-to-
day basis but that the C++ and Java languages steer you away
from. The CD also contains this book in HTML form along with the
source code for the book.
This CD ROM will work with Windows (with a sound system) and
the Macintosh. However, you must:
1. Install the most recent version of Microsoft's Internet Explorer.
Because of the features provided on the CD, it will NOT work
with Netscape Navigator. The Internet Explorer software for
both the Macintosh and Windows 9X/NT is included on the
CD.
2. Install Microsoft's Windows Media Player. Unfortunately this is
only allowed to be distributed directly from Microsoft's Web
site, so it is NOT included on the CD. You will need to go to
http://www.microsoft.com/windows/mediaplayer follow
and
the instructions or links there to download and install the Media
Player for your particular platform (you may need to find and
follow an extra link for the Macintosh version). Please note that
Microsoft sometimes changes the location of Web pages on their
site and in that case you'll need to use their searching capability
to find the media player.
856
img
At this point you should be able to play the lectures on the CD.
Using the Internet Explorer Web browser, open the file Install.html
that you'll find on the CD. This will introduce you to the CD and
provide further instructions about the use of the CD.
857