Index
= 0 279
?= 326
100% C compatibility 101
2.0, Release 187
7-bit character 158
8-bit character set 161
:, comp.lang.c++ 168
,, operator 247
%: digraph 160
%:%: digraph 160
%> digraph 160
*, ** and 248
**
and * 248
exponentiation operator 247
*^, exponentiation operator 249
++
increment operator 245
prefix and postfix 245
--
decrement operator 245
prefix and postfix 245
->
delegation and 242
operator 241
->*, operator 247
.
:: vs. 95
operator 242
.*, operator 247
..., ellipsis 333
//
and C compatibility 93
::
explicit qualification 412
vs.. 95
:> digraph 160
<% digraph 160
<: digraph 160
<<
operator 186
output operator 186
=
Release 2.0 82
operator 239
>> problem with template syntax 356
0
NULL 230
false 254
null pointer 229
= 0 syntax 281
1, true 254
A
abolish Cpp 426
abomination f(void) 41
absence of template 378
abstract
class and library 183
class, template and 379
type 279
abstraction, C++ and data 197
academic pursuit of learning 70
acceptance
criteria, feature 61
process, feature 61
accepted
extensions 151
features 151
proposals 151
accepting a proposal 147
access
control and static member 288
control for constructor 94
control of names 54
to base class 301
using-declaration adjusting 419
vs. visibility 54
access-declaration 54
and using-declaration 419
deprecated 419
accessible, C++ 197
accident, protection against 116
Ada 6, 44, 67, 105, 107-108, 175, 339
C++ and 192
I/O 185
complexity 199
extensions 147
new 365
Adcock, Jim 243
address, special 214
adjusting access, using-declaration 419
advantages and disadvantages, C 44
advertising, AT&T C++ 177
affordability of C with Classes 33
affordable features 115
Agrawal, Sudhir 61
aims
AT&T 178
C with Classes 28
for exception handling 384
for standardization 130
of early libraries 184
of namespace design 402
of standardization 135
Algol60 265
Algol68 6, 22, 40, 84-85, 100, 105, 108
a rose 37
declaration 99
operators 250
references 86
references overloading 44
algortihms, standard 194
alias 403
problem with 275
allocation 357
and constructor, new 56
and real-time, dynamic 211
arena 214
array 213
new and 212
prohibit auto 237
prohibit free store 238
prohibit global 237
prohibit static 237
alternative
RTTI design 323
points of destruction of temporary 145
template syntax 355
to #ifdef, if 425
to #include, include 425
to Cpp 425
to cast 309
ambiguity 227
control 226
in template 371
multiple inheritance and 258
American national standard 136
analysis, one-pass 140
and keyword 160
and_eq keyword 160
Annemarie 404
ANSI
C C85 64
C grammar 69
C local static arrays 128
C volatile 128
C++ standard 128
X3J16 136
and ISO 136
standard library 194
ANSI3.4-1968, ISO-646-1983 ASCII 158
ANSI/ISO name lookup 141
Apple
Mac MPW 167
Macintosh 165
application
environment, standard 135
programming, general 204
archetypical problems 62
architecture-specific extension 158
arena
allocation 214
memory 215
argument
check, run-time 296
constraint on template 343
deducing template 349
default 59
depend on template 370
explicit template 350
function template 350
keyword 153
matching rules 228
named 153
names 155
namespace as template 343
non-type template 342
over-constrained 344
rules, relaxation of 295
template as template 343
workaround, keyword 156
arguments
average number of 156
for resumption 391
for termination 391
value of 301
arithmetic, mixed-mode 80, 223
Cpp in 127
features 128
learning C++ from 127
name lookup 139
purpose of 127
reference manual 126
array
allocation 213
associative 322
deallocating 217
standard associative 194
template 342
arrays, ANSI C local static 128
ASCII ANSI3.4-1968, ISO-646-1983 158
assembler
learning 169
Assert() 397
assert() 397
assignment 239
initialization and 22
overloading of 58
void* 230
associative
array 322
array, standard 194
assumptions for exception handling 384
asynchronous events 393
C++ advertising 177
C++ marketing 177
C++ use within 65
aims 178
compiler 166
library 184
Austern, Matt 248
auto allocation, prohibit 237
automatic
garbage collection 219
storage 32
template instantiation 365
autoprototyping 40
availability, commercial 70
available, C is 43
average number of arguments 156
B
bad_cast 194
Ball, Mike 166
base
and derived 74
and derived, overload 417
and derived overloading 77
cast to private 328
class 49
class, access to 301
class, ordinary 258
class, virtual 260
derived hiding 417
first construction 282
initializer 275
layout, virtual 266
member, hiding of 77
basic language support 194
basic_string 359
Bauche, Volker 400
speed 21
beauty and efficiency, C++ 379
before() 317
behavior, implementation-dependent 133-134
Bell
Labs CSRC 60
Labs C++ developers 101
Labs library 184
Bennett, Tanj 409
better
C, C++not just a 204
C subset of C++ 171
match 228
bigotry, language wars and 299
binary literal 152
binding
of reference 86
rule, name 368
bit and keyword 160
bit or keyword 160
bits<N> 194
bitstring 194
bitwise copy 239
BIX c.plus.plus 166
blackboards, design on 61
BLAS 158
Booch
components library 192
book for users 4
books, journals and 165
bool, Boolean type 254
Boolean type bool 254
bored programmer 388
Borland 164
compiler 166
bridge 200
Brown, Phil 125
Brück, Dag 145, 248, 254-255, 287, 290, 327, 391-392, 400
bugs, multiple inheritance 270
built-in
type, constructor for 380
type, derivation from 380
type, destructor for 380
types, definition of 380
types, template and 380
types, user-defined and 32, 117
C
++C 64
C++ not just a better 204
C++ separate from 65
I/O 96
I/Oprintf 185
a weed 37
advantages and disadvantages 44
and C++ compatibility 120, 129
and C++ const 90
and C++, learning 169
and C++ linkage 233
and C++ reference manual 170
and C++ textbooks 170
and Simula 1
code generated 39
compatibility 131, 225, 227, 229, 240
compatibility, / / and 93
compatibility, C with Classes 38
compatibility, conversion and 227
compatibility, namespaces and 420
compiler, PCC 69
declaration syntax 45
dialects 101
enum 253
error handling 338
exceptions and 385
extensions 147
features, dangerous 29
features, ugly 29
fixing 45
generated 67
in C++, writing 170
is available 43
is efficient 43
is flexible 43
is portable 43
learning 169
linkage 232
numerical 157
preprocessor 68
problem with 374
semantics 103
techniques, undesirable 378
variables 198
why 43
with Classes 27
with Classes C compatibility 38
with Classes a weed 37
with Classes, affordability of 33
with Classes aims 28
with Classes dilemma 63
with Classes documentation 29
with Classes efficiency 28
with Classes features 29
with Classes implementation 29
with Classes layout compatibility 28
with Classes low-level features 29
with Classes object layout 38
with Classes preprocessor, Cpre 27
with Classes run-time support 49
with Classes static type checking 40
with Classes strong type checking 40
with Classes, success of 64
with Classes support 29
with Classes, supporting 63
with Classes without virtual function 53
withdrawal symptoms 93
.c file and template 376
C84 64
C85, ANSI C 64
call
in constructor, virtual 282
notation, constructor 335
of undeclared function 40
optimization of virtual 116
callbacks 303
call-by-reference 86
call-by-value 86
calling
Fortran 86
conventions 236
sequences, standard 135
Computing Laboratory 22
CAP computer, capability-based 19
capabilities 22
capability-based CAP computer 19
Cargill, Tom 47, 105, 125, 269
Carolan, John 164
Carroll, Martin 269
cast
RTTI and 309
alternative to 309
and const 331
and incomplete type 329
and interface 183
and pointer to function 331
eliminate 309
from void* 333
implicit 350
new-style 327
notation, new 327
notation, old-style 333
overuse of 170
problems with 327
safe 309
syntax 309
to private base 328
transition to new 335
using new 335
catastrophic failure, crashes and 93
catch 385
CBEMA 136
Cedar Mesa 392
Centerline ObjectCenter 167
cerr 186
Cfront 124
code quality 302
compile-time overhead 67
compiler front-end 66
first shipment 70
implementation of new 57
memory use 66
resource requirements 65
size of 66
structure of 66
symbol tables 66
template 339
template implementation 365
to PC, port of 66
virtual table layout 320
warning 43
C++
Journal, The 165
Release 1.0 deficiencies 107
Release 1.0 features 71
Report, The 165
Simula and 106
Smalltalk and 107
accessible 197
advertising, AT&T 177
and Ada 192
and Fortran 176
and Smalltalk, learning 170
and data abstraction 197
and generic programming 379
and object-oriented programming 197
and other languages 197
as a target language 204
as an implementation language 204
beauty and efficiency 379
better C subset of 171
committee charter 130
community, diversity of 130
compilers sold, number of 164
compositional 188
concurrent 188
const, C and 90
design of 60
design using 171
developers, Bell Labs 101
development plan 124
exception handling, ideals for 385
features 131
from ARM, learning 127
general-purpose programming language 105
goals of 196
gradual approach to 171
is coherent 197
language definition 5
learning C and 169
libraries 65
linkage, C and 233
manual, size of initial 79
marketing, AT&T 177
micro 188
model of protection 22
multiple inheritance 271
name 64
not just a better C 204
operating system influence on 22
parsing 68
people who contributed to 2
prehistory of 19
programming environment 167
programming environment, future 167
programming environment, ideals for 167
projects, major 174
reference manual 60
reference manual, C and 170
separate from C 65
serving current users 110
source 207
standard, ANSI 128
standardization, ISO 129
standardization, start of 128
static type checking 197
stream I/O 185
strength 208
syntax type-system 208
teaching 168
textbooks, C and 170
time needed to learn 172
timeline 4
tools 65
type checking 92
use within AT&T 65
users, counting 164
users, number of 163
versions of 71
writing C in 170
writing Fortran in 170
writing Smalltalk in 170
C++ Programming Language, the 105
C++’s contribution 196
change
gradual 24
impact of 281
motivation for 110
rate of 24
char
constant, type of 225
int and 224
literal, type of 225
overloading and 224
character
7-bit 158
set 158
set, Unicode 161
sets, I/O of extended 161
sets, extended 161
sets, national 158
character-oriented tools 207
characters, limit on number of 69
char_ref 88
chart, language 5
charter, C++ committee 130
check
list, extension 149
run-time 42
run-time argument 296
checked interfaces, statically 107
checking
and error 378
of exceptions, dynamic 396
of exceptions, static 395
of multiple inheritance, static 263
of template, error 369
checks, run-time 29
Cheriton, David 384
choice 113
Choices 165
choosing a programming language 175
c in, initialization of 96
CLAM 165
damage, Steve 166
clarifications 138
clarity of definition 103
class
helper 87
hierarchy, exceptions and 387
layout, derived 52
member, forward reference of 140
string 66
class
Simula style 21
access to base 301
and library, abstract 183
and macro, container 337
and template, container 337
as namespace 401
base 49
concept 30
forward declaration of nested 289
hierarchies, merging of 273
hierarchy 20
hierarchy, overloading and 226
is user-defined type 30
locality nested 118
member 289
member order dependencies 138
namespace and 417
ordinary base 258
prefix, Simula 49
root 261
sibling 261
struct and 76
template 341
template and 360
template and abstract 379
unit of protection 54
universal root 184
virtual base 260
cleanup
deallocation and 212
of template design 340
clone() 293
complexity 199
learning 169
Clu-style container 339
CMP 359
Cobol extensions 147
code
bloat, curbing 347
exceptions and old 394
generation 302
quality, Cfront 302
replication 346
verbose error-prone 388
coding, low-level 338
coexistence 112
coherence, maintaining 153
coherent
C++is 197
view 148
collating sequence 358
combination, method 268
Comeau, Greg 166
commercial
availability 70
competition 175
committee
charter, C++ 130
dangers of design by 148
disband 148
for a new language, design 148
members 137
standards 128
communication between siblings 261
community, diversity of C++ 130
company language 178
comparing programming languages 5
comparison, language 270
compatibility
C with Classes C 38
C with Classes layout 28
concern for 153
hack, structure tag 48
link 120
vs. safety 334
wars 102
competition, commercial 175
compilation
model, template 376
one-pass 139
compiler
AT&T 166
Borland 166
DEC 166
GNU 166
IBM 166
Microsoft 166
Oregon Software 166
PCCC 69
TauMetric 166
Zortech 166
complexity 111
front-end, Cfront 66
has partial information 37
inlining linker 33
compilers 166
sold, number of C++ 164
compile-time 281
and template 366
overhead 233
overhead, Cfront 67
protection 54
type checking 31
type inquiry 353
comp1 keyword 160
comp.lang.c++ 231
: 168
usenet 166
library 66
template 362
complexity
Ada 199
CLOS 199
Eiffel 199
RTTI implementation 306
Smalltalk 199
compiler 111
environment 199
language 199
library 199
multiple inheritance 270
of use 111
simplicity and 112
components industry, software 191
composite operator 251
composition 116
interface 409
techniques, template 356
compositional C++ 188
computer, high-performance 176
Computing Laboratory, Cambridge 22
computing
engineering 176
numeric 203
numerical 158
concepts
and language constructs 19
focus on 168
concern for compatibility 153
and exceptions 385
support 188
support extensions 188
support libraries 188
concurrent C++ 188
condition, declaration in 99
conditionals in template 353
conferences 164
conservative garbage collection 217
consistency 37
const 22
C and C++ 90
Cpp and 425
as symbolic constant 90
cast and 331
constants 89
enforcement of 284
for specifying interface 90
ideal 286
initialization of 286
member function 284
member initializer 151
overloading and 225
references 86
static_cast and 329
~const 287
constant
const as symbolic 90
type of char 225
constants const 89
const_cast 332
constraint
and error detection 344
and readability 344
on template argument 343
through derivation 344
through inheritance 344
through use 345
constraints 346
construction, base first 282
constructor 94
access control for 94
and library 183
call notation 335
copy 240
exception and 388
for built-in type 380
new allocation and 56
new and 213
new() 56
notation 94
template and 379
virtual call in 282
contain using macro 50
container
Clu-style 339
Smalltalk-style 339
class and macro 337
class and template 337
without template 50
Container template 315
containers, standard 194
context
of template definition 369
of template instantiation 369
contract
between implementer and programmer 133
standard as a 133
contributed to C++, people who 2
contribution, C++’s 196
control
manual 121
of copy 237
of memory exhaustion 218
of memory management, fine-grain 211
Controlled_container 357
controversy, multiple inheritance 269
convenience vs. safety 411
conventions, calling 236
conversion
and C compatibility 227
and template 362
floating to integral 42
function 83
graph 228
implicit narrowing 334
lattice 228
natural 227
overloading and 223
safe 227
standard 228
static_cast and implicit 329
to void* 226
convert() 350
copy
bitwise 239
constructor 240
control of 237
deep 240
memberwise 239
of object 293
of pointer 240
prohibit 237
shallow 240
virtual 241
copy() 77
Coral 22
CORBA 206
Corfield, Sean 255
cost of exceptions 385
counting C++ users 164
coupling 281
cout 186
initialization of 96
CPL 64
c.plus.plus, BIX 166
Cpp
abolish 426
alternative to 425
and const 425
and error 424
and inline 425
and namespace 425
and programming environment 424
and scope 424
and templates 425
and tools 424
in ARM 127
Cpre
C with Classes preprocessor 27
first shipment 70
crashes and catastrophic failure 93
Cray 157
Cristian, Flaviu 392
criteria
extension 149
feature acceptance 61
for templates, design 338
tools 21
Crockett, Beth 274
crossing protection barrier 32
CSRC, Bell Labs 60
cult
language 229
of orthogonality 104
curbing code bloat 347
current users, C++ serving 110
D
DAG, dominance 263
Dahl, Ole-Johan 258
dangerous
C features 29
feature 315
dangers of design by committee 148
data
abstraction, C++ and 197
member, pointer to 304
virtual 266
databases, object-oriented 192
deallocating array 217
deallocation
and cleanup 212
delete and 212
problems 216
debugger, standard 135
debugging support 42
DEC 128
VMS 392
compiler 166
declaration
Algol68 99
implementation 35
in condition 99
in for-statement 99
of nested class, forward 289
overload 231
specialization 375
syntax, C 45
declarators, linear notation for 46
decrement operator -- 245
deducing template argument 349
deep copy 240
default
argument 59
arguments, overloading and 59
local 101
nested 101
operator 237
private 101
type checked 101
deficiencies, C++ Release 1.0 107
#define 424
definition
C++ language 5
clarity of 103
context of template 369
error, double 377
finding template 376
formal 103
function 31
of built-in types 380
of simple 403
delay causes dialects 129
delegation 242
and -> 242
experiment 272
multiple inheritance 270
delete
and deallocation 212
and destructor 213
freed() 57
delete(), destructor 56
delete[] 217
operator 214
depend on template argument 370
dependencies
implementation 138
on library 134
deprecate implicit int 45
deprecated
access-declaration 419
global static 419
derivation
constraint through 344
from built-in type 380
from int 380
prohibit 238
derived
base and 74
class layout 52
hiding base 417
overload base and 417
overloading, base and 77
design
aims of namespace 402
alternative RTTI 323
and problems 105
and teaching 119
and type checking 107
by committee, dangers of 148
cleanup of template 340
committee for a new language 148
criteria for templates 338
from first principles 44
hybrid 201
ideals for namespace 402
language 114
library 182
non-aims of namespace 403
of C++ 60
of fault-tolerant system 385
on blackboards 61
onion 323
paper 60
principles, language 109
rules, language 109
static type checking and 107
styles of 24
support rules 114
teaching and 168
template and library 378
too cautious, template 340
tools for language 103
tradeoffs, library 182
using C++ 171
warped 338
designer and implementer 60
destruction of temporary, alternative points of 145
destructor 94
and garbage collection 222
delete and 213
delete() 56
exception and 388
explicit call of 217
for built-in type 380
destructors, virtual 216
details, language-technical 3
detectable, extensions are 134
Deutsch, Peter 387
development
environment, ideal program 207
management 124
plan, C++ 124
Dewhurst, Steve 71, 125, 166, 304
dialects
C 101
delay causes 129
dialog_box 307
digraph
%: 160
%:%: 160
%> 160
:> 160
<% 160
<: 160
dilemma, C with Classes 63
direct expression 115
directive, template instantiation 367
disadvantages, C advantages and 44
disband committee 148
dispatch
double 300
template, double 364
disruption of standards process 137
distributed
system simulator 19
diversity of C++ community 130
documentation, C with Classes 29
dominance 263
DAG 263
double
definition error 377
dispatch 300
dispatch template 364
double, float and 224
Dovich, Steve 400
dynamic
allocation and real-time 211
checking of exceptions 396
linking 206
storage 32
store 56
type checking, static and 107
dynamic_cast 308
static_cast and 330
syntax of 309
dynarray 194
E
early
libraries, aims of 184
users 174
EBCDIC, IBM 160
education and technique 205
efficiency
C with Classes 28
C++ beauty and 379
Fortran 157
and overloading 84
exceptions and 397
flexibility and 379
organization, flexibility 1
overloading and 78
efficient
Cis 43
I/O 185
Matrix 252
String, simple and 185
Eick, Stephen 193
Eiffel 6, 67, 176-177, 202, 326, 397
complexity 199
learning 169
elegance, simplicity and 229
elegant language 179
eliminate cast 309
elimination of temporaries 252
ellipsis ... 333
email internet, newsgroups 164
embedded system 203 employee 292
encapsulation and friend 53
encoding, type 234
Energize, Lucid 167
enforcement 24
of const 284
engineering
computing 176
language design and 104
English as a common language 161
enum
C 253
overload based on 254
type 253
enumeration 253
overload based on 254
environment
C++ programming 167
Cpp and programming 424
complexity 199
execution 221
future C++ programming 167
ideal program development 207
ideals for C++ programming 167
separation between language and 197
standard application 135
environments, many 167
EOS 145
equivalence
name 35
operator 242
structural 35
Eratosthenes’ sieve 188
error
Cpp and 424
checking and 378
checking of template 369
detection, constraint and 344
double definition 377
handling 218
handling, C 338
handling, multi-level 385
potential 113
error-prone code, verbose 388
Estes Park workshop 165
ET++ 167
evaluating a programming language 175
events
Release 2.0 124
asynchronous 393
sequence of 123
evidence and skeptics 24
evolution, interface 206
example
of RTTI 320
of object I/O 320
task 188
examples, pathological 141
exception
and constructor 388
and destructor 388
and library 183
handling, aims for 384
handling and reliability 384
handling, assumptions for 384
handling, ideals for C++ 385
handling, multiple inheritance and 387
handling syntax 385
specification 396
exceptions 22
and C 385
and class hierarchy 387
and efficiency 397
and layout 397
and levels of abstraction 392
and old code 394
and other languages 394
and recompilation 396
and resource management 388
concurrency and 385
cost of 385
dynamic checking of 396
experience with 392
guaranteed catching of 385
large system and 392
memory exhaustion and 390
multi-level propagation of 394
overflow and 394
static checking of 395
template and 379
type safety and 385
execution environment 221
experience 126
idealists and 23
rules and 109
template implementation 339, 368
template use 339
value of 301
with exceptions 392
with type-safe linkage 234
experiment 104
delegation 272
explicit
call of destructor 217
qualification 406
qualification :: 412
template argument 350
template instantiation 366
type field 50
explicit 80
exponentiation
operator ** 247
operator *^ 249
expression, direct 115
extended
character sets 161
character sets, I/O of 161
type information 318
extending vs. mutating 85
extensible I/O 185
extension
architecture-specific 158
check list 149
criteria 149
major and minor 305
stability and 125
extensions 269
Ada 147
C 147
Cobol 147
Fortran 147
Modula-2 147
Pascal 147
accepted 151
and standard 134
are detectable 134
concurrency support 188
need for 129
problems with good 152
proposals, management of 147
suggested 150
extern C 234
extreme portability 65
F
f(), f(void) and 41
facts 1
respect for 179
reviewed 2
vs. philosophy 3
false 0 254
fancy String 185
fatalism status quo 24
fault-tolerant system, design of 385
fear of overloading 231
feature
acceptance criteria 61
acceptance process 61
dangerous 315
library vs. language 181
major and minor 305
features
ARM 128
C with Classes 29
C++ 131
C++ Release 1.0 71
Release 2.0 126
accepted 151
affordable 115
and techniques, language 170
language design and 104
necessary 149
new 269
removing 269
featurism 60
feedback, perfection and 111
Fig 295
file
and template, .c 376
and template, .h 376
and template, source 376
source 207
FilePtr 389
files, header 235
finalization 388
finding template definition 376
fine-grain
control of memory management 211
overload resolution 224
firewalls 394
first
principles, design from 44
shipment, Cfront 70
shipment, Cpre 70
first-time switch 97
fixing C 45
flame war 231
flexibility
and efficiency 379
efficiency organization 1
vs. simplicity 224
flexible, C is 43
float
and double 224
overloading and 224
floating
point, single precision 224
to integral conversion 42
focus on concepts 168
fooling static_cast 330
fopen() 388
force 113
for instability, standardization as 148
foreign language interface 236
foreman 292
formal
definition 103
methods 103
for-statement, declaration in 99
C++ and 176
a weed 37
calling 86
efficiency 157
extensions 147
in C++, writing 170
linkage 236
forward
declaration of nested class 289
reference of class member 140
forwarding function 244
foundation
libraries 191
library, horizontal 191
library, vertical 191
fragmentation 211
fraud, protection against 116
free
implementations 70
storage 32
store 56
store allocation, prohibit 238
free(), delete 57
friend
and member 81
encapsulation and 53
misuse of 301
front-end, Cfront compiler 66
function
C with Classes without virtual 53
and multiple inheritance, virtual 265
call of undeclared 40
cast and pointer to 331
const member 284
conversion 83
definition 31
forwarding 244
implementation of member 39
implementation, virtual 75
inline 32
inline member 139
layout and virtual 74
member 30
nested 152
new() 31
only, instantiate used 347
operator 83
optimization, virtual 239
pointer to 74
pointer, virtual 74
polymorphism without virtual 49
pure virtual 279
recompilation, virtual 75
static member 288
table, virtual 74
template 348
template and virtual 342
template argument 350
template overloading 351
future C++ programming environment 167
f(void)
abomination 41
and f() 41
G
garbage
collection, automatic 219
collection, conservative 217
collection, destructor and 222
collection, multiple inheritance 271
collection, plug-in 217
collection, reasons against 220
collection, reasons for 220
collection, standard 221
GDB_root 184
general
application programming 204
rules 110
general-purpose 125
programming language C++ 105
generated
C 67
C code 39
generic
programming, C++ and 379
types, macros for 51
Gibbons, Bill 139, 155, 294, 373, 400
global
allocation, prohibit 237
name 288
optimization 116
scope 412
scope name clashes 400
static deprecated 419
variable 32
Glockenspiel 164
library 191
GNU
compiler 166
library 191
goals of C++ 196
good
extensions, problems with 152
languages vs good software 149
Gorlen, Keith 125, 165, 191, 276, 345
grab_X() 393
gradual
adoption 168
approach to C++ 171
change 24
grammar, ANSI C 69
graph, conversion 228
Green Hills 164
grouping of exceptions 385-386, 396
guaranteed catching of exceptions 385
guarantees, run-time 56
gummy bear 261
H
. h file and template 376
hack
macro 401
structure tag compatibility 48
hand optimization 211
handle 243
handler, new 219
Hanson, David 253
hard
to implement, multiple inheritance 270
to use, multiple inheritance 270
hardware, special 134
Hchar 161
header
files 235
pecompiled 425
heap storage 32
helper class 87
Softbench 167
hiding
base, derived 417
of base member 77
of name 77
of representation 279
of template implementation 366
overriding and 76
hierarchy
class 20
exceptions and class 387
higher-level programming 202
high-performance computer 176
hijack names 406
hijacking of names in template 373
hindsight, retrospective 196
histogram 62
history
and philosophy 23
revisionist 1
Holly, Mike 157
honesty, intellectual 179
Hopkins, Bill 272
HOPL-2 paper 2
horizontal foundation library 191
Howard, Jim 241
Hstring 161
hybrid
design 201
styles 112
hype, marketing 63
I
EBCDIC 160
compiler 166
ideal
const 286
program development environment 207
idealism 24
idealists and experience 23
ideals
for C++ exception handling 385
for C++ programming environment 167
for namespace design 402
identity, type 316
f alternative to #ifdef 425
#ifdef 424
if alternative to 425
ignoring
standards 135
warning 42
impact of change 281
implementation
C with Classes 29
Cfront template 365
and interface 281
and interface, template 379
complexity, RTTI 306
declaration 35
dependencies 138
hiding of template 366
inheritance private 53
language, C++ as an 204
multiple inheritance 270
of Simula 20
of member function 39
of namespace 403
of new, Cfront 57
portable 21
problems, template 338
simple-minded 36
simplicity 111
supplier lock-in 138
system and language 206
virtual function 75
implementation-dependent behavior 133-134
implementations
free 70
language and 127
implementer
and programmer, contract between 133
designer and 60
implicit
cast 350
conversion, static_cast and 329
instantiation 365
int, deprecate 45
narrowing conversion 334
use in template 370
importance
multiple inheritance 271
of placement 215
of syntax 48
of time order 123
impression of instability 153
include alternative to 425
include alternative to #include 425
incomplete type, cast and 329
increment operator+ + 245
incremental linking 206
independent multiple inheritance 260
indirection 242
individual, respect for 23
individuals, learning and 169
industry
software components 191
standards 206
influence
on C++, operating system 22
operating system 55
informal standardization 126
information, compiler has partial 37
inheritance
and template 361
constraint through 344
of operator delete() 213
of operator new() 213
overloading and 225
private, implementation 53
public, interface 53
timing of multiple 257
inherited 290
initial C++ manual, size of 79
initialization 37
Simula 56
and assignment 22
and paging 98
and virtual memory 98
library 96
of cin 96
of const 286
of cout 96
of stdin 96
of stdout 96
order of 96
order of member 275
problems with run-time 96
resource acquisition 389
run-time checked 326
initializer 96
base 275
const member 151
member 275
syntax 380
inline
Cpp and 425
function 32
keyword 33
member function 139
template and 342
inlining linker compiler 33
inquiry, compile-time type 353
Insinga, Aron 392
instability
impression of 153
standardization as force for 148
instantiate used function only 347
instantiate keyword 367
instantiation
#pragma, template 366
automatic template 365
context of template 369
directive, template 367
explicit template 366
implicit 365
manual optimization of 368
multiple 367
point of 368
instruction set, standard 135
int
and char 224
deprecate implicit 45
derivation from 380
integral
conversion, floating to 42
promotions 228
integrated system 112
intellectual honesty 179
interface 31
cast and 183
composition 409
const for specifying 90
evolution 206
foreign language 236
implementation and 281
inheritance public 53
separate 35
template implementation and 379
interfaces 118
statically checked 107
inter-language linkage 236
international standard 136
internet, newsgroups email 164
interrupts 393
intersect rule 229
intersect Shape 297
Interviews 301
inventing terminology 31
I/O
Ada 185
C 96
C++ stream 185
efficient 185
example of object 320
extensible 185
library, stream 185
object 276
of extended character sets 161
printf, C 185
terse 185
type-safe 185
io 322
iocircle 322
io_counter 97
io_obj 321
iostream 260
isKindOf, Smalltalk 325
ISO
ANSI and 136
C++standardization 129
WG-21 136
standard library 194
ISO-646-1983 ASCII ANSI3.4-1968 158
issues, system-related 206
iterators, standard 194
J
Jchar 161
Johnson, Steve 22, 35, 62, 68, 70, 101, 105, 124
jokes, puns and 24
JOOP 166
Jordan, David 361
Journal, The, C++ 165
journals and books 165
Jstring 161
K
Kallman, Dave 70
Keffer, Thomas 191
Kelley, Bob 125
Kernighan, Brian 4, 22, 70, 91, 105, 125, 127, 245, 253
keyword
and 160
and_eq 160
argument 153
argument workaround 156
bitand 160
bitor 160
compl 160
inline 33
instantiate 367
not 160
not_eq 160
or 160
or_eq 160
postfix 246
prefix 246
specialise 375
specialize 375
template 341
xor 160
xor_eq 160
keywords, new 152
kinds of rules 110
Knuttilla, Kim 392
Koenig, Andrew 4, 46, 71, 81, 101, 125, 127, 131, 134, 139, 145, 165-166, 187, 227, 229, 239-240, 251, 253, 255, 263, 303, 322, 327, 339, 344, 348, 352, 368, 383, 387, 391, 400
Krogdahl, Stein 258
Krohn, Eric 400
L
lack of template 184
LALR(l) parser, YACC 68
language
C++ as a target 204
C++ as an implementation 204
C++, general-purpose programming 105
English as a common 161
and environment, separation between 197
and implementations 127
and system 37
chart 5
choosing a programming 175
company 178
comparison 270
complexity 199
constructs, concepts and 19
cult 229
definition, C++ 5
design 114
design and engineering 104
design and features 104
design and mathematics 104
design and philosophy 104
design and sociology 104
design committee for a new 148
design, motivation for 105
design principles 109
design rules 109
design, tools for 103
elegant 179
evaluating a programming 175
feature, library vs. 181
features and techniques 170
implementation, system and 206
interface, foreign 236
lawyers 5
purposes of programming 44
support, basic 194
support for library 183
wars 179
wars and bigotry 299
what is a programming 7
languages
C++ and other 197
comparing programming 5
exceptions and other 394
vs good software, good 149
language-technical
details 3
rules 117
large
program, naming in a 406
system 116
system and exceptions 392
later users 174
lattice, conversion 228
lawyers
language 5
users vs. 137
layout
C with Classes object 38
Cfront virtual table 320
RTTI 320
and virtual function 74
compatibility, C with Classes 28
derived class 52
exceptions and 397
multiple inheritance 264
object 304
standard virtual table 135
template and 342
virtual base 266
learn C++, time needed to 172
learning
C 169
C and C++ 169
CLOS 169
C++ and Smalltalk 170
C++from ARM 127
Eiffel 169
ML 169
OODBMS 169
OOP 170
Smalltalk 169
academic pursuit of 70
and individuals 169
assembler 169
object-oriented programming 170
on the job 168
verification 169
legal
program 133
source text 133
Lenkov, Dmitry 129, 306, 384, 391
levels of abstraction, exceptions and 392
libraries
C++ 65
aims of early 184
and static type checking 183
and type system 183
concurrency support 188
foundation 191
many 167
numeric 192
persistence 192
specialized 193
support for 108
use of multiple 183
library
ANSI standard 194
AT&T 184
Bell Labs 184
Booch components 192
GNU 191
Glockenspiel 191
ISO standard 194
RHALE++ 192
RTTI and 183
Rogue Wave 191
Smalltalk-inspired 184
Standard Components 184
abstract class and 183
complex 66
complexity 199
constructor and 183
dependencies on 134
design 182
design, template and 378
design tradeoffs 182
exception and 183
horizontal foundation 191
initialization 96
language support for 183
missing, standard 124
multiple inheritance and 184, 258
namespace and 183
namespaces in standard 400
naming in standard 316
providers and namespaces 403
run-time type information and 183
standard 407
standard numeric 194
stream I/O 185
support 306
vertical foundation 191
vs. language feature 181
lifetime of temporaries 143
limit on number of characters 69
limits
to perfection 108
translation 136
Lindsey, Charles 100
linear notation for declarators 46
link compatibility 120
linkage
C 232
C and C++ 233
Fortran 236
PL/I 236
Pascal 236
TSL see type-safe
and overloading 233
experience with type-safe 234
inter-language 236
model 34
name 233
overloading and 232
pointer to function 236
problem, type-safe 236
problems 69
syntax, type-safe 399
to other languages 34
linkage-specifier 234
compiler, inlining 33
names 403
problem 98
problems with 303
linking
dynamic 206
incremental 206
link-time
and template 366
overhead 233
lip service to minimalism 147
Lippman, Stan 71, 125, 303, 339
model 197
list 62
lists, standard 194
literal
binary 152
type of char 225
literature 23
on programming languages 105
L.M.Ericsson 392
lobbying for long names 70
local
default 101
static arrays, ANSI C 128
variable 32
variables, true 198
locality 117
nested class 118
Locanthi, Bart 105
lock-in, implementation supplier 138
locking 190
in users 167
logic, theory and 23
Logothetis, George 71
long
names, lobbying for 70
namespace name 408
lookup
ANSI/ISO name 141
ARM name 139
name 138
template name 371
LotterySimulation 273
low-level
coding 338
features, C with Classes 29
programming 202
programming rules 120
Lucid Energize 167
lvalue vs. rvalue 87
M
Macintosh, Apple 165
macro
contain using 50
container class and 337
hack 401
template style 339
macros for generic types 51
maintainable program 406
maintaining coherence 153
major
C++ projects 174
and minor extension 305
and minor feature 305
management 277
development 124
of extensions proposals 147
manual
ARM reference 126
C and C++ reference 170
C++ reference 60
control 121
optimization of instantiation 368
size of initial C++ 79
many
environments 167
libraries 167
map, standard 194
Map 322
Marian 405
marketing
AT&T C++ 177
hype 63
marketing, lack of 164
Mary 22
Mascitti, Rick 64
match, better 228
matching
overload 228
rules, argument 228
mathematics
as tool for problem solving 23
language design and 104
Matherr 387
Matrix, efficient 252
maturity
personal 137
technical 137
Mayka, Larry 125
McCluskey, Glen 339
McIlroy, Doug 4, 41, 46, 62, 78, 85, 91, 102, 105, 125, 127, 141, 186, 227, 229, 253, 274, 304, 384, 400
member
access control and static 288
class 289
forward reference of class 140
friend and 81
function 30
function, const 284
function, implementation of 39
function, inline 139
function, method see
function, static 288
hiding of base 77
initialization, order of 275
initializer 275
initializer, const 151
order dependencies, class 138
pointer to 303
pointer to data 304
protected 301
template 364
template, virtual 364
members, committee 137
memberwise copy 239
memory
arena 215
exhaustion and exceptions 390
exhaustion, control of 218
initialization and virtual 98
management, Release 2.0 and 212
management, fine-grain control of 211
management, tuning of 211
raw 213
read-only 286
special 211
use, Cfront 66
Memphis 115
merging of class hierarchies 273
Mesa 44
Cedar 392
meta-object 324
method
combination 268
see member function
unconstrained 325
methods, formal 103
micro C++ 188
Microsoft 129
compiler 166
migration path 201
Miller, William (Mike) 165, 384, 391
minimal run-time support 21
minimalism, lip service to 147
minimize surprises 227
Minner, Richard 400
missing, standard library 124
mistake, worst 200
misuse
of RTTI 313
of friend 301
of typeid 308
use and 115
Mitchell, Jim 392
mixed system 204
mixin 261
learning 169
model
Lisp 197
Simula 197
Smalltalk 197
linkage 34
of protection, C++ 22
protection 53
template compilation 376
Modula-2 35, 44, 103, 175, 204
extensions 147
Modula-2+ 397
variables 198
modularity 102
module structure 27
monitor 56
motivation
for change 110
for language design 105
MPW, Apple Mac 167
multi-argument overloading 228
multi-level
error handling 385
propagation of exceptions 394
multi-method 325
workaround for 299
multi-methods 297
multi-paradigm 106
multiple
inheritance C++ 271
inheritance and Simula 258
inheritance and Smalltalk 270
inheritance and ambiguity 258
inheritance and exception handling 387
inheritance and library 184, 258
inheritance bugs 270
inheritance complexity 270
inheritance controversy 269
inheritance delegation 270
inheritance garbage collection 271
inheritance hard to implement 270
inheritance hard to use 270
inheritance implementation 270
inheritance importance 271
inheritance, independent 260
inheritance layout 264
inheritance, name clash and 273
inheritance overhead 270
inheritance, single and 258
inheritance, static checking of 263
inheritance, timing of 257
inheritance tools 271
inheritance, virtual function and 265
instantiation 367
libraries, use of 183
multi-processor system 188
multi-threading 188
Murray Hill 27
mutable 287
mutating, extending vs. 85
Myers, Nathan 80
N
name
C++ 64
binding rule 368
clash and multiple inheritance 273
clashes, global scope 400
encoding, namespaces and 420
encoding, standard 135
equivalence 35
global 288
hiding of 77
linkage 233
long namespace 408
lookup 138
lookup, ANSI/ISO 141
lookup, ARM 139
lookup, template 371
mangling 234
mangling, namespaces and 420
prefixes 401
short namespace 408
space pollution 288
name() 317
named argument 153
names
access control of 54
argument 155
hijack 406
in template, hijacking of 373
linker 403
lobbying for long 70
source code 403
namespace
as template argument 343
problem 400
Cpp and 425
and class 417
and library 183
class as 401
design, aims of 402
design, ideals for 402
design, non-aims of 403
implementation of 403
name, long 408
name, short 408
syntax 405
template 360
unnamed 419
using 407
namespaces
and C compatibility 420
and name encoding 420
and name mangling 420
and releases 409
and versioning 409
in standard library 400
library providers and 403
nested 415
open 416
overloading and 414
transition to 407
naming
in a large program 406
in standard library 316
narrow() 335
conversion, implicit 334
national character sets 158
natural conversion 227
nature of programming 111
NCEG 157
NDEBUG 397
Neath, Martin 339
necessary features 149
need for extensions 129
needed for standard, time 129
Needham, Roger 22
nested
class, forward declaration of 289
class, locality 118
default 101
function 152
namespaces 415
template 364
network_f ile_err 387
networking 188
new
cast notation 327
cast, transition to 335
cast, using 335
features 269
keywords 152
language, design committee for a 148
new
Ada 365
Cfront implementation of 57
allocation and constructor 56
and allocation 212
and constructor 213
handler 219
performance 91
new()
constructor 56
function 31
new [ ], operator 214
Newcastle 22
new_handler 91
newsgroups email internet 164
new-style cast 327
Ngo, Thomas 287
Nicholas 404
noalias 157
No_free_store 238
non-aims of namespace design 403
non-pointers, pointers and 31
non-type template argument 342
not keyword 160
notation
constructor 94
constructor call 335
for declarators, linear 46
new cast 327
old-style cast 333
notational
convenience 241
convenience, operators and 223
not_eq keyword 160
null pointer 0 229
NULL 0 230
Num 243
number
of C++ compilers sold 164
of C++users 163
of arguments, average 156
of characters, limit on 69
numeric
computing 203
libraries 192
library, standard 194
numerical
C 157
computing 158
O
Oasys 164
Object Pascal 291
object
I/O 276
I/O, example of 320
copy of 293
layout 304
layout, C with Classes 38
partially constructed 389
stack 92
static 92
Object 314
ObjectCenter, Centerline 167
object-oriented
databases 192
programming, C++and 197
programming, learning 170
ObjectWorks, ParcPlace 167
old code, exceptions and 394
old-style cast notation 333
OLE2 206
ON-conditions, PL/I 392
one-definition
rule 36
rule and template 369
one-pass
analysis 140
compilation 139
Onfreestore 237
onion design 323
OODBMS 361
learning 169
learning 170
OOPSLA 299
open namespaces 416
operating
system influence 55
system influence on C++ 22
system, standard 135
operations, unsafe 222
operator
, 247
* *, exponentiation 247
*^, exponentiation 249
++, increment 245
--, decrement 245
-> 241
->* 247
. 242
. * 247
<< 186
<< output 186
= 239
composite 251
default 237
delete [] 214
equivalence 242
function 83
new [ ] 214
overloading 78
precedence of user-defined 251
private 237
prohibit 237
type inquiry 324
type relation 325
user-defined 250
operator
delete() 194
delete(), inheritance of 213
new() 194
new(), inheritance of 213
new() return value 218
operators
Algol68 250
Simula 86
and notational convenience 223
optimization
global 116
hand 211
of instantiation, manual 368
of virtual call 116
return value 302
return value 84
virtual function 239
virtual table 302
optional garbage collection 198, 220
or keyword 160
order
dependence 118
dependencies, class member 138
dependencies, workarounds for 97
dependency 232
dependency and overloading 226
of initialization 96
of member initialization 275
ordinary base class 258
Oregon
Software 164
Software compiler 166
or_eq keyword 160
organization
flexibility efficiency 1
original standards schedule 129
O’Riordan, Martin 254, 274, 288, 294, 330, 368, 391-392, 400
orthogonality 113
cult of 104
other
languages, exceptions and 394
languages, linkage to 34
output operator, << 186
over-constrained argument 344
overflow and exceptions 394
overhead
Cfront compile-time 67
compile-time 233
link-time 233
multiple inheritance 270
rule, zero 121
run-time 233
overload
base and derived 417
based on enum 254
based on enumeration 254
matching 228
resolution 224
resolution, fine-grain 224
overload declaration 231
Algol68 references 44
Release 2.0 and 224
and char 224
and class hierarchy 226
and const 225
and conversion 223
and default arguments 59
and efficiency 78
and float 224
and inheritance 225
and linkage 232
and namespaces 414
and transition 414
base and derived 77
efficiency and 84
fear of 231
function template 351
linkage and 233
multi-argument 228
of assignment 58
operator 78
order dependency and 226
reasons against 78
reasons for 78
overriding
and hiding 76
relaxation of 293
overstated weaknesses 153
overuse
of cast 170
P
paging, initialization and 98
paper
HOPL-2 2
design 60
parameterized
type template 338
ParcPlace ObjectWorks 167
parser
YACCLALR(l) 68
recursive descent 68
parsing C++ 68
partial information, compiler has 37
partially constructed object 389
and Simula 20
extensions 147
linkage 236
toy 44
variables 198
pass-by-reference 86
pass-by-value 85
paternalism 106
path, migration 201
pathological examples 141
PC, port of Cfront to 66
PCC C compiler 69
PCs personal computers 65
pecompiled header 425
people
who contributed to C++ 2
perfection
and feedback 111
limits to 108
performance 211
new 91
startup 98
persistence libraries 192
persistent symbol table 376
personal
computers, PCs 65
maturity 137
personal, preferences 106
Philip, Pat 125
philosophy
facts vs. 3
history and 23
language design and 104
PL360 22
importance of 215
plan, C++ development 124
PL/I 227
ON-conditions 392
linkage 236
plug-in garbage collection 217
point of instantiation 368
pointer
0, null 229
copy of 240
replace ordinary 245
semantics 198
syntax 304
this 39
to data member 304
to function 74
to function, cast and 331
to function linkage 236
to member 303
pointers
and non-pointers 31
and references 86
restricted 157
points of destruction of temporary, alternative 145
pollution, name space 288
polymorphic type 312
polymorphism without virtual function 49
population, user 61
port of Cfront to PC 66
portability 125
extreme 65
portable
Cis 43
implementation 21
porting problems 235
positive rules 122
postfix
+ +, prefix and 245
prefix and 245
postfix keyword 246
potential error 113
Powell, Mike 395
#pragma 424
template instantiation 366
pragmatic approach 60
precedence of user-defined operator 251
prefix
Simula class 49
and postfix ++ 245
and postfix -- 245
prefix keyword 246
prefixes, name 401
prehistory of C++ 19
preprocessor
C 68
Cpre C with Classes 27
Presotto, Dave 185
principles
design from first 44
language design 109
printf, C I/O 185
private, default 101
private 301
base, cast to 328
implementation inheritance 53
operator 237
public 53
privileges 407
problem
RTTI 307
linker 98
namespace 400
solving, mathematics as tool for 23
type-safe linkage 236
with C 374
with alias 275
with synonym 275
with template syntax, >> 356
problems
archetypical 62
deallocation 216
design and 105
linkage 69
porting 235
real 110
with cast 327
with good extensions 152
with linker 303
with run-time initialization 96
process, feature acceptance 61
productive, staying 172
program
development environment, ideal 207
legal 133
maintainable 406
naming in a large 406
reliable 406
startup 98
programmer
bored 388
contract between implementer and 133
programmers 113
training of 111
programming
C++ and generic 379
C++ and object-oriented 197
environment, C++ 167
environment, Cpp and 424
environment, future C++ 167
environment, ideals for C++ 167
general application 204
higher-level 202
language, choosing a 175
language, evaluating a 175
language, purposes of 44
language, what is a 7
languages, comparing 5
languages, literature on 105
languages, systems 22
learning object-oriented 170
low-level 202
nature of 111
rules, low-level 120
prohibit
auto allocation 237
copy 237
derivation 238
free store allocation 238
global allocation 237
operator 237
static allocation 237
prohibition 122
projects, major C++ 174
promises 62
promotions, integral 228
propagation of exceptions, multi-level 394
proposal
accepting a 147
rejecting a 147
proposals
accepted 151
rejected 151
protected 301
member 301
protection
C++ model of 22
Smalltalk 301
against accident 116
against fraud 116
barrier, crossing 32
class unit of 54
compile-time 54
model 53
prototype 40
providers and namespaces, library 403
Ptr 361
public 301
interface inheritance 53
private 53
public: 31
puns and jokes 24
pure virtual function 279
purpose
of ARM 127
purposes of programming language 44
pursuit of learning, academic 70
pvector 347
Q
qualification 95
::, explicit 412
explicit 406
queue 62
Quinn, Peggy 125
R
raise 386
Randell, Brian 22
rate of change 24
raw memory 213
readability, constraint and 344
read-only memory 286
readonly 89
real problems 110
reality, votes and 90
real-time, dynamic allocation and 211
reasons
against garbage collection 220
against overloading 78
for garbage collection 220
for overloading 78
exceptions and 396
virtual function 75
reconsideration rule 142
recursive descent parser 68
redefinition rule 139
redundancy in syntax 386
reference 85
binding of 86
manual, ARM 126
manual, C and C++ 170
manual, C++ 60
return type 87
semantics 198
this 39
references
Algol68 86
const 86
overloading, Algol68 44
pointers and 86
smart 242
RefNum 243
reinterpret_cast 331
and static_cast 331
rejected proposals 151
rejecting a proposal 147
relation operator, type 325
relationships between templates 360
relaxation
of argument rules 295
of overriding 293
Release
1.0 71
1.0 deficiencies, C++ 107
1.0 features, C++ 71
1.1 71
1.3 124
2.0 187
2.0 = 82
2.0 and memory management 212
2.0 and overloading 224
2.0 events 124
2.0 features 126
2.0 timing 124
E 70
releasel 409
release2 410
releases
namespaces and 409
to universities 70
reliability, exception handling and 384
reliable program 406
religious conversions 24
removal of restrictions 125
removing features 269
reordering rule 142
replace ordinary pointer 245
replicated virtual function table 302
replication, code 346
repository, template 376
representation
hiding of 279
resolution, overload 224
resource
acquisition initialization 389
management 215
management, exceptions and 388
requirements, Cfront 65
respect
for facts 179
for individual 23
restrict 157
restricted pointers 157
restriction, specialization 375
restrictions, removal of 125
resumption
arguments for 391
semantics 390
termination vs. 390
workaround for 393
retrospective hindsight 196
return value optimization 84
return
type 293
type, reference 87
value, operator new() 218
value optimization 302
reviewed facts 2
revisionist history 1
revolutions 24
rewrite rule 139
RHALE++library 192
Richards, Martin 64
Ritchie, Dennis 4, 22, 35, 41, 62, 64, 89-90, 105, 157, 163, 253
Rogue Wave library 191
ROM 286
root
class 261
class, universal 184
Rose, Leonie 66
rose
Algol68 a 37
Simula a 37
Rosier, Larry 64, 90, 103, 105, 128
Rowe, Keith 400
and cast 309
and library 183
and standardization 315
design, alternative 323
example of 320
implementation complexity 306
layout 320
misuse of 313
problem 307
rule
intersect 229
name binding 368
one-definition 36
reconsideration 142
redefinition 139
reordering 142
rewrite 139
specialization 375
two week 274
zero overhead 121
rules
and experience 109
argument matching 228
design support 114
general 110
kinds of 110
language design 109
language-technical 117
low-level programming 120
positive 122
sociological 110
voting 136
run-time
argument check 296
check 42
checked initialization 326
checks 29
guarantees 56
initialization, problems with 96
overhead 233
support, C with Classes 49
support, minimal 21
type information and library 183
type inquiry 74
rvalue, lvalue vs. 87
S
safe
cast 309
conversion 227
safety 126
and exceptions, type 385
and type safety 93
compatibility vs. 334
convenience vs. 411
Sakkinen, Markku 269
Santa Fe USENIX workshop 165
schedule, original standards 129
Schwarz, Jerry 97, 105, 125, 187, 286-287, 327, 400
scientific computing 158, 176, 203
scope
Cpp and 424
global 412
name clashes, global 400
scopes, semi-transparent 54
Scott, Roger 125
Season 254
self, Smalltalk 39
self-assignment 59
self-sufficiency, user 37
semantics
C 103
pointer 198
reference 198
resumption 390
termination 390
value 198
semantics-oriented tools 207
semi-transparent scopes 54
separate
from C, C++ 65
interface 35
separation between language and environment 197
sequence of events 123
serving current users, C++ 110
Set of Shape* 360
set 279
set_new_handler 219
set_new_handler() 194
shallow copy 240
Shape, intersect 297
Shape*, Set of 360
Shopiro, Jonathan 4, 46, 61, 66, 78, 83, 87, 105, 125, 129, 134, 184, 206, 227, 229, 251, 288, 304, 339, 362, 368
short namespace name 408
sibling class 261
siblings, communication between 261
signal 386
signals 393
SIMLIB 193
simple
and efficient String 185
definition of 403
simple-minded implementation 36
simplicity
and complexity 112
and elegance 229
flexibility vs. 224
implementation 111
C and 1
Pascal and 20
THIS 39
Users’ group, ASU 106
a rose 37
and C++ 106
class prefix 49
implementation of 20
initialization 56
model 197
multiple inheritance and 258
operators 86
run-time performance of 20, 32
style class 21
variables 198
virtual 73
simulator, distributed system 19
Singh, Livleen 165
single
and multiple inheritance 258
precision floating point 224
single-rooted hierarchy 170, 184
size
of Cfront 66
of initial C++ manual 79
sizet 213
Skaller, John 400
skeptics, evidence and 24
slicing 240
slist_set 280
Smalltalk 37, 44, 67, 175, 325
and C++ 107
complexity 199
in C++, writing 170
isKindOf 325
learning 169
learning C++ and 170
model 197
multiple inheritance and 270
protection 301
self 39
subclass 49
super 291
techniques, undesirable 378
variables 198
Smalltalk-inspired library 184
Smalltalk-style container 339
smart
references 242
sociological rules 110
sociology, language design and 104
Softbench, Hewlett-Packard 167
software
components industry 191
good languages vs good 149
SOM 206
sort() 348
sorting 358
source
C++ 207
code names 403
control and template 366
file 207
file and template 376
text, legal 133
special
address 214
hardware 134
memory 211
specialise keyword 375
specialization
declaration 375
of template 373
restriction 375
rule 375
specialize keyword 375
specialized
libraries 193
tools 204
specification, exception 396
Spicer, John 350
stability
and extension 125
and standards 205
stack
object 92
storage 32
stack 30
Standard Components library 184
standard
ANSI C++ 128
American national 136
algortihms 194
application environment 135
as a contract 133
associative array 194
calling sequences 135
containers 194
conversion 228
debugger 135
extensions and 134
garbage collection 221
instruction set 135
international 136
iterators 194
library 407
library, ANSI 194
library, ISO 194
library missing 124
library, namespaces in 400
library, naming in 316
lists 194
map 194
name encoding 135
numeric library 194
operating system 135
time needed for 129
timeliness of 135
vector 194
virtual table layout 135
what is a 133
standardization 124
ISO C++ 129
RTTI and 315
aims for 130
aims of 135
as force for instability 148
informal 126
start of C++ 128
status of 150
standards
committee 128
ignoring 135
industry 206
process, disruption of 137
schedule, original 129
stability and 205
Stark, Kathy 125
start of C++ standardization 128
startup
performance 98
program 98
static
and dynamic type checking 107
checking of exceptions 395
checking of multiple inheritance 263
object 92
storage 32
store 56
type checking, C with Classes 40
type checking, C++ 197
type checking and design 107
type checking, libraries and 183
type system 117
static
allocation, prohibit 237
deprecated, global 419
member, access control and 288
member function 288
Statically checked interfaces 107
static_cast 329
and const 329
and dynamic_cast 330
and implicit conversion 329
fooling 330
reinterpret_cast and 331
status
of standardization 150
quo, fatalism 24
staying productive 172
stdin, initialization of 96
stdio.h 407
stdout, initialization of 96
Stepanov, Alex 194, 339, 348, 354, 379
STL 194
storage
automatic 32
class 32
dynamic 32
free 32
heap 32
stack 32
static 32
store
dynamic 56
free 56
static 56
Strachey, Christopher 64
stream
I/O, C++ 185
I/O library 185
strength, C++ 208
fancy 185
simple and efficient 185
string 194
class 66
strong type checking, C with Classes 40
strtok() 225
struct and class 76
structural equivalence 35
structure
of Cfront 66
tag 47
tag compatibility hack 48
styles
hybrid 112
of design 24
subclass
Smalltalk 49
superclass and 74
subset of C++, better C 171
success of C with Classes 64
suggested extensions 150
sum() 368
super, Smalltalk 291
superclass and subclass 74
support
C with Classes 29
concurrency 188
debugging 42
for libraries 108
for library, language 183
library 306
rules, design 114
supporting C with Classes 63
surprises, minimize 227
switch
on type 313
on type field 72
symbol
table, persistent 376
tables, Cfront 66
synonym 403
problem with 275
syntax 119
= 0 281
>> problem with template 356
C declaration 45
alternative template 355
cast 309
exception handling 385
importance of 48
initializer 380
namespace 405
of dynamic_cast 309
pointer 304
redundancy in 386
template 350
type-safe linkage 399
type-system, C++ 208
syntax-oriented tools 207
system
and exceptions, large 392
and language implementation 206
design of fault-tolerant 385
embedded 203
integrated 112
language and 37
large 116
libraries and type 183
mixed 204
multi-processor 188
system-related issues 206
systems programming languages 22
T
tag, structure 47
target language, C++ as a 204
task
example 188
TauMetric compiler 166
teaching
C++ 168
and design 168
design and 119
technical maturity 137
technique, education and 205
techniques
language features and 170
template composition 356
undesirable C 378
undesirable Smalltalk 378
template
Container 315
conditionals in 353
use of 322
template
. c file and 376
. h file and 376
Cfront 339
absence of 378
ambiguity in 371
and abstract class 379
and built-in types 380
and class 360
and constructor 379
and exceptions 379
and inline 342
and layout 342
and library design 378
and virtual function 342
argument, constraint on 343
argument, deducing 349
argument, depend on 370
argument, explicit 350
argument, function 350
argument, namespace as 343
argument, non-type 342
argument, template as 343
array 342
as template argument 343
class 341
compilation model 376
compile-time and 366
complex 362
composition techniques 356
container class and 337
container without 50
definition, finding 376
design, cleanup of 340
design too cautious 340
double dispatch 364
error checking of 369
function 348
hijacking of names in 373
implementation, Cfront 365
implementation and interface 379
implementation experience 339, 368
implementation, hiding of 366
implementation problems 338
implicit use in 370
inheritance and 361
instantiation #pragma 366
instantiation, automatic 365
instantiation, context of 369
instantiation directive 367
instantiation, explicit 366
keyword 341
lack of 184
link-time and 366
member 364
name lookup 371
namespace 360
nested 364
one-definition rule and 369
overloading, function 351
parameterized type 338
repository 376
source control and 366
source file and 376
specialization of 373
style macro 339
syntax 350
syntax, >> problem with 356
syntax, alternative 355
typedef 357
use experience 339
vector 342
virtual member 364
templates
design criteria for 338
relationships between 360
timing of 257
templates, Cpp and 425
temporaries
elimination of 252
lifetime of 143
temporary, alternative points of destruction of 145
terminate() 194
termination
arguments for 391
semantics 390
vs. resumption 390
terminology 133
inventing 31
Terribile, Mark 400
terse I/O 185
textbooks, C and C++ 170
and logic 23
THIS, Simula 39
this
and thunk 265
pointer 39
reference 39
throw 385
thunk, this and 265
TI Explorer 392
Tiemann, Mike 58, 166, 225, 292, 384, 395
time, lack of 168
time
needed for standard 129
needed to learn C++ 172
order, importance of 123
timeline, C++ 4
timeliness of standard 135
timing
Release 2.0 124
of multiple inheritance 257
of templates 257
tolerance 23
tool
for problem solving, mathematics as 23
tools
C++ 65
Cpp and 424
character-oriented 207
criteria 21
for language design 103
multiple inheritance 271
semantics-oriented 207
specialized 204
syntax-oriented 207
toy, Pascal 44
tradeoffs
for user 183
library design 182
training of programmers 111
and using-directive 407
overloading and 414
path 153
to namespaces 407
to new cast 335
translation
limits 136
unit of 57
translations 165
trigraphs 159
true local variables 198
try 385
TSL see type-safe linkage
tuning of memory management 211
two week rule 274
type
abstract 279
bool, Boolean 254
cast and incomplete 329
checked, default 101
checking, C with Classes static 40
checking, C with Classes strong 40
checking, C++ 92
checking, C++ static 197
checking and design, static 107
checking, compile-time 31
checking, design and 107
checking, libraries and static 183
checking, static and dynamic 107
class is user-defined 30
constructor for built-in 380
derivation from built-in 380
destructor for built-in 380
encoding 234
enum 253
field, explicit 50
field, switch on 72
identity 316
information and library, run-time 183
information, extended 318
information, run-time 266, 306
inquiry, compile-time 353
inquiry operator 324
inquiry, run-time 74
of char constant 225
of char literal 225
polymorphic 312
reference return 87
relation operator 325
return 293
safety and exceptions 385
safety, safety and 93
switch on 313
system 20
system, libraries and 183
system, static 117
template, parameterized 338
violation 117
typedef 47
template 357
typeid 316
misuse of 308
use of 322
types
definition of built-in 380
macros for generic 51
template and built-in 380
user-defined and built-in 32, 117
type-safe
I/O 185
linkage, TSL see
linkage, experience with 234
linkage problem 236
linkage syntax 399
type-system, C++ syntax 208
U
ugly C features 29
unconstrained method 325
undeclared function, call of 40
undesirable
C techniques 378
Smalltalk techniques 378
unicode character set 161
uninitialized variables 99
union 333
uniqueness 37
unit
of protection, class 54
of translation 57
universal root class 184
universities, releases to 70
unnamed namespace 419
unsafe operations 222
Usable 239
Usable_lock 239
use
and misuse 115
complexity of 111
constraint through 345
experience, template 339
of multiple inheritance 271, 322
of multiple libraries 183
of template 322
of typeid 322
within AT&T, C++ 65
used function only, instantiate 347
usenet comp.lang.c++ 166
USENIX 164
workshop, Santa Fe 165
user
population 61
self-sufficiency 37
tradeoffs for 183
user-defined
operator 250
operator, precedence of 251
type, class is 30
users
C++ serving current 110
book for 4
counting C++ 164
early 174
later 174
locking in 167
number of C++ 163
vs. lawyers 137
Users’ group, ASU, Simula 106
using new cast 335
using 404
namespace 407
namespace 404
namespace, using vs. 411
vs. using namespace 411
using-declaration 404
access-declaration and 419
adjusting access 419
vs. using-directive 411
using-directive 404
transition and 407
using-declaration vs. 411
USL 127
V
value
of arguments 301
of experience 301
semantics 198
variable
global 32
local 32
variables
C 198
Modula-3 198
Pascal 198
Simula 198
Smalltalk 198
true local 198
uninitialized 99
Vasa 147
vector
standard 194
template 342
verbose error-prone code 388
verification, learning 169
versioning, namespaces and 409
versions of C++ 71
vertical foundation library 191
Vilot, Mike 192, 271, 391, 400
violation, type 117
virtual
function and multiple inheritance 265
function table, replicated 302
memory, initialization and 98
table layout, Cfront 320
table optimization 302
virtual
Simula 73
base class 260
base layout 266
call in constructor 282
call, optimization of 116
copy 241
data 266
destructors 216
function, C with Classes without 53
function implementation 75
function, layout and 74
function optimization 239
function pointer 74
function, polymorphism without 49
function, pure 279
function recompilation 75
function table 74
function, template and 342
member template 364
table layout, standard 135
visibility, access vs. 54
VMS, DEC 392
void* 213
assignment 230
cast from 333
conversion to 226
volatile, ANSI C 128
votes and reality 90
voting rules 136
vptr 74
vtbl 74
W
Ward, Judy 71
warning 240
Cfront 43
ignoring 42
warped design 338
wars
compatibility 102
language 179
wchar_t 161
weaknesses, overstated 153
weed
Ca 37
C with Classes a 37
Fortran a 37
Weinreb, Daniel 387
WG-21, ISO 136
what
is a programming language 7
is a standard 133
whatis paper 106
Wheeler, David 22
why C 43
Wilkes, Maurice 22
Wilkinson, Nancy 71
Williams, Tony 384
withdrawal symptoms, C 93
wordlink 50
workaround
for multi-method 299
for resumption 393
keyword argument 156
workarounds for order dependencies 97
working groups 137
workshop, Estes Park 165
world view 23
worst mistake 200
wrappers 58
writeonly 89
writing
C in C++ 170
Fortran in C++ 170
Smalltalk in C++ 170
wstring 194
X
X() 94
~X() 94
X3J16, ANSI 136
Xerox PARC 309
xor keyword 160
xor_eq keyword 160
Y
Y ACC 103
LALR(l) parser 68
Yaker, Laura 214
Yost, David 164
Z
zero overhead rule 121
compiler 166