Index

<< C: Recommended Reading:Depth & dark corners, Analysis & design

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

* � 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

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

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;

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

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

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

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

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-

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;

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

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

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

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;

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;

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

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

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

Gorlen, Keith � 694

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

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

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

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;

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; `.'

(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

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

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

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

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

MindView: public hands-on training

malloc( ) � 223, 550, 552, 554, 569; behavior,

seminars � 16; seminars-on-CD-ROM �

not deterministic in time � 555

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

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

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

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;

= � 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

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

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

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;

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;

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

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

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

reflexivity, in operator overloading � 536

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

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

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

area � 549; storage class specifier � 412;

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

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;

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;

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

virtual functions inside � 670; efficiency

� 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

(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

by the constructor � 643

VTABLE � 637, 640, 642, 648, 653, 662, 665;

zero indexing � 183

inheritance and the VTABLE � 652

842

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

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

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

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

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

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

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

EXCLUSION OR LIMITATION OF LIABILITY, THE ABOVE LIMITATION

MAY NOT APPLY TO YOU.

0495 Part No. 64358

851

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.

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

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

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

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

Thinking in C: Foundations for Java & C++

Multimedia Seminar-on-CD ROM

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

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

Table of Contents: