home account info subscribe login search My ITKnowledge FAQ/help site map contact us


 
Brief Full
 Advanced
      Search
 Search Tips
To access the contents, click the chapter and section titles.

C++ in Plain English
(Publisher: IDG Books Worldwide, Inc.)
Author(s): Brian Overland
ISBN: 1558284729
Publication Date: 04/01/96

Bookmark It

Search this book:
 
Previous Table of Contents Next


Index

# (pound sign) in directives, 22
^ (caret) as bitwise exclusive OR (XOR) operator, 430
% (percent sign) as remainder operator, 430, 475-476
& (ampersand). See ampersand
+ (plus sign). See plus sign
: (colon). See colon
; (semicolon). See semicolon
<< and >> (double angle brackets). See angle brackets
= (equal sign). See equal sign
(->) as pointer operator, 115
?: (question mark colon) as conditional operator, 430
\ (backslash), as escape sequence character, 27
~ (tilde). See tilde
@ (at sign) with operator functions, 153
[] (brackets) in array indexing, 429, 441
, (commas), in variable declarations, 20, 367
... (ellipses) as iteration indicator, 234, 239
! (exclamation point). See exclamation point
- (minus sign). See minus sign
() (parentheses). See parentheses
. (period or dot) in function calls, 108, 429
{} (braces). See braces
“” (quotation marks for indicating string literals), 497-498
/ (slash). See slash
| (vertical bar or pipe). See vertical bar
A
abstract base classes, 220, 229-230
abstract data types, 231
active types, 101
addition-assignment operator (+=), 48, 178-179, 430
addition operator (+), 13, 430 with operator function, 154
addresses as pointers, 54, 55, 57-58
address operator (&), 28, 57, 58, 232-233, 429
aggregates, 234-236
aliases, 469
ampersand (&)
as address operator, 28, 57, 58, 232-233, 429
as bitwise AND operator, 49, 430
doubled (&&) as logical AND operator, 49, 430
with equal sign (&=) as bitwise AND assignment operator, 430
as reference operator, 134, 140, 141-142, 166, 468-472
angle brackets
double (<< and >>) as left- and right-shift operators, 49, 430
double (<< and >>) as stream operators, 83-87, 401, 433-434
double with equal sign (=<< and =>>) as left- and right-shift assignment operators, 430
with equal sign (<= or =>) as comparison operators, 46
with hyphen (->) as pointer operator, 115, 429
single (< or >) as comparison operators, 46
anonymous unions, 237-238
arguments
default values, 317-319
references as, 470-471
variability of lists, 530-532
arithmetical operations
with addition/subtraction/multiplication/division operators (+), 13, 430
with pointer arithmetic, 443-445
arrays
multi-dimensional, 242-244
one-dimensional, 240-242
and pointers, 60-67
syntax, 239
ASCII coding convention, 68
assignment expressions, 31, 245
assignment operators, 48, 148, 161-166, 178
overloading, 438-439
with reference operator, 166
assignment statements
declaring variables and assigning values, 25-26
as operator function, 161-166
syntax, 25, 245
associativity
for class operators, 179
of left- and right-shift operators, 87
list for C++ operators, 428
list for C operators, 428
asterisk (*)
with equal sign (*=) as multiplication-assignment operator, 48, 179, 430
as multiplication operator, 25, 430
as pointer-indirection operator, 57, 105, 392-393, 429
with slash (/*....*/) as begin- and end-comment symbols, 28
A-to-Z reference guide, 14, 229
at sign (@) with operator functions, 153
auto keyword, 246
auto variable, 496
B
backslash (\)
double (\\) in path names in C quoted strings, 96
as escape sequence character, 27
base classes
abstract, 220, 229-230
access specifiers, 250
constructors, 200-202, 252-255
described, 182, 188, 247
examples, 248, 249
pointers, 203-206, 250-251
syntax, 247, 248
virtual, 211, 533-535
binary operators
considerations for operator functions, 154
as friends, 160
operator functions, 176
overloading, 438
bit fields, 256-261
bitwise operators, 48-49, 262
black box concept, 7-8
Boolean values, 263-264
braces ({}), 18
for compound statements, 45, 283
no semicolon after, 29, 30, 35, 106
brackets ([]) in array indexing, 429, 441
break statements, 265-266, 411
bugs. See debugging
C
C++ programming language
advantages, 2, 15-16
future of, 15
origins and development, 2
See also debugging; sample code; syntax; transitioning from C to C++
callback functions, 11, 538
capitalization, 18
caret (^)
as bitwise exclusive OR (XOR) operator, 430
with equal sign (^=) as bitwise XOR assignment operator, 430
case keyword, 271-272
case sensitivity of identifiers, 377-378
casts
explicit type conversions, 273, 355-359
implicit type conversions, 388-389
type, 273
catch blocks, 348-350, 351, 354
cat function, 120, 122
CAuto class, 197-198, 253
“C/C++” icon, 13, 15
CFontIoStr
deriving from CIoStr, 189-190
private member access, 194
char* function, passing CStr with con-version function, 167-169
char arrays, 68, 69
char data type, 274-275, 309
chips
as objects, 6, 7
virtues of independence and ignorance, 7-8
cin objects
advantages of gets, 90-91
described, 85-87, 276-277
formatting decimal, hex or octal numbers, 86
versus scanf function, 97-98, 276
C in Plain English, 14
CIoStr class
creating as shell around CStr object, 190-194
deriving from CStr, 184-185
function definitions, 185-186
function inheritances, 186 function overrides, 186-188
with object containment, 193-194
object declarations, 185
public/protected member-access, 194-195
classes
advantages of private functions, 103
chips’ make and model as, 6
clients of, 192
as code and data, 7
compared to structures, 128
for control to data/function sharing, 8
declarations requiring semicolon after brace, 106
deriving (inheritance), 182-183, 328
described, 3, 101, 102, 129-130, 278
encapsulation, 9, 119, 129, 278, 337-339
linking of declarations and function definitions by class name, 105
names, 107
reusing and publishing, 130-131
run-time type information (RTTI), 478-480
storage, 496
string, 102-103
syntax, 279-280
as type, 9, 101
typedef operators with, 520-521
See also base classes; inheritance; overloading
class keyword, 102
class templates, 507, 508-510
clients of classes, 192
CMenu class
declaring/defining base class, 212-213
declaring/defining menu objects, 213-215
described, 212
implementing Do_Command, 219-220, 229-230
objects, 215-217
virtual functions, 217-219
code
exception handling, 346-354
as instructions to computers, 5
segregation from data, 5, 6, 110-111
source code of published functions or classes, 182, 190
See also compiling; sample code; syntax
collection classes with templates, 507, 510
colons
in class argument lists, 202
double (::) as context or scope opera-tor, 103-104, 299-300, 429
commas (,), in variable declarations, 20, 367, 430
comments
/*....*/ (begin- and end-comment symbols), 20, 281
// (begin comment line symbol), 20, 281, 282
described, 281
examples, 282
with #if directive, 379, 382
ignored in compiling, 20
and labels, 410-411
nesting, 282
syntax, 281
communtativity for class operators, 179
comparisons
Boolean values, 263-264
caution on use of assignments in, 32-33
operators, 46
compiling
comments ignored, 20
C programs as C++ programs, 4, 13
described, 19
implementation files for publishable language extensions, 131
compound control structures, 45
See also loop processing
compound statements, 29, 45, 283-284, 489
conditional compilation
#ifdef directive, 386
#if directive, 379-381
#ifndef directive, 387
conditional tests
caution on use of assignments in, 32
#elif directive, 334
else keyword, 44, 335
#endif directive, 340
operator (?:), 285-286
with switch statements, 489, 501-506
See also loop processing; testing
constants
aggregates, 234-236
declaring, 25, 26
with #define directive, 320-323
described, 292
storing, 293
syntax, 292
const char* function, passing CStr with conversion function, 169
const keyword, 287-291
constructors
absence of returns, 125
base-class, 200-202, 252-255
blank argument lists, 125
calls to, 147-149
copy, 133, 138-145, 150, 156, 297-298
default, 296
default or hidden, 136-138, 150
described, 115, 124, 294
examples, 145-147
naming, 124, 134
overloading, 134-135, 149
syntax, 294-295
containment of objects, 192, 193
context operator (::), 299-300
continue statement, 301-303
control structures
compound, 45
described, 43
See also loop processing
conversion functions, 167-169, 304-305
conversion of types
and constructors, 148-149, 151
conversion functions, 167-169, 304-305
unsigned data, 527-529
copy constructors, 133, 138-145, 150, 156, 297-298
cout objects
described, 85-87, 277, 306
examples, 307
syntax, 306
versus printf, 97-98
.CPP files, suggestions for publishable language extensions, 131
C programming language
compilation considerations, 4, 13
See also transitioning from C to C++
cpy function, 120, 121
CRateCar class, 199-200
CShape class, 222-224
CSportsCar class
base-class constructors, 200-202, 253-255
defining, 198-199
CStr class
addition (+) operator function for concatenating strings, 154-158
addition/subtraction assignment operator, 178-179
advantages, 169
assignment operator function, 161-166
calls from shell, 190-194
constructor calls, 147-149
constructors, 135-136
conversion function, 167-169
copy constructors, 133, 138-145, 156
CSTR.CPP file, 170-173
CSTR.H file, 170
declarations, 104-105
default constructors, 136-138
deriving classes from (inheritance), 182-185
deriving class function overrides, 186-188
deriving class functions, 185-186
dynamic-memory management, 117-119, 120-123
friend keyword, 154, 158-161
function/operator summary, 183
inheritance hierarchies, 188-190
inline functions in place of encapsulation, 126-128
member function calls, 108-112, 113-114
memory leaks, null pointers and constructors/destructors, 123-126
passing to char* function with conversion function, 167-169
pointer use, 116-120
public/protected member-access, 194-197
as publishable language extension, 130-131, 181-182
requirements, 169-170
string creation, 106-107
type conversion, 148-149, 151
See also CFontIoStr; sample code
CSTR.H file, 185, 198
CSTR.OBJ file, 198 CTemp_point example
class declarations, 114
described, 112
operator functions, 173-175
CTimePiece class, 208-210
CTYPE.H header file, 23
current object, 164
CWagon class, 199
.CXX files, suggestions for publishable language extensions, 131
D
data
flows as streams, 81-82
organization and structuring, 5
pointing for access to, 54
as raw information, 5
segregation from code, 5, 6, 110-111
data abstraction, 308
data declarations, 24
data members, 110
static, 493-494
See also member functions
data types
abstract, 231, 308
char, 274-275
characteristics, 21
double, 21, 309, 332-333
list of, 309
primitive, 458
See also types
debugging
advantages of default constructors, 137
advantages of encapsulation for avoiding, 119-120
caution on mixing I/O techniques, 84, 89, 97-98
caution on setting initial and terminating conditions of loops, 62
caution on string handling code rewrites, 116
caution on use of assignment (=) in place of test-for-equality (==), 33
exception handling, 346-354
loops, 415
scanf function, 484
declarations
compared to definitions, 324-325
described, 310
examples, 311-312
prototypes and pointers, 312-315
requiring semicolon after brace, 106
storage class modifiers, 315-316
syntax, 310-311
See also classes
decrement operators, 47
overloading, 439-441
default argument values, 317-319
default constructors, 136-138, 150
#define directive, 320-323, 325, 376
typedef operator with, 521
definitions, compared to declarations, 324-325
delete operator
call to constructors and destructors, 326
described, 77-78, 326-327, 429
overloading, 441-442
return of pointer, 73, 115
deriving classes, 328
See also inheritance
destractors, 115, 122, 125-126, 329-330
directives
with pound sign, 22
without semicolon, 29
display screen standard output (cout), 85-87
division-assignment operator (/=), 48
division operator (/) with operator function, 154
Do_Command function, 219-220, 229-230
do statement, 331
double arguments (%1f) for scanf function, 28
double data type, 21, 309, 332-333
dynamic_cast operator, 429, 478-479
dynamic memory, 73
E
#elif directive, 334
ellipses (...) as iteration indicator, 234, 239
else keyword, 44, 335
empty statements (;), 336
encapsulation, 9, 119, 129, 278, 337-339
#endif directive, 340
enum declarations, 341-345, 376
EOF checks, 94
equal sign (=)
as assignment operator, 31, 148, 161, 430
doubled (==) as equality/comparison operator, 32-33, 46, 430
with exclamation point (=!) as not equal comparison operator, 430
for variable initialization, 20, 25, 148
errors. See debugging
escape sequences, 27
event-driven programs, 3
exception handling, 346-354
exclamation point (!)
with equal sign (!=) as comparison operator, 46
as logical NOT operator, 49, 429
executable statements, 24
explicit type conversions, 355-359
expressions, 31-33, 47, 360, 488 postfix and prefix, 47
extensions (filename)
.H, 23
.OBJ, 23
external variables, 41-43
extern “C” declarations, 361
extern declarations, 42, 315, 316, 362-363
in header files, 42, 316, 376
F
fclose function, 92
fgetc function, 93, 94, 95
fgets function, 92
filename extensions. See extensions (filename)
files
implementation, 131
as streams, 82-83
See also header files
float data type, 21, 364-365
double, 333, 364, 365
floating-point values, 21, 293
fopen function, 92, 93
form function in decimal, hex or octal formats, 89
for statement, 366-367
fprintf function, 92
fputs function, 92
fread function, 95
free function, 74, 77, 120
friend functions, 154, 158-161, 368-370
fscanf function, 92
fseek function, 95
FSTREAM.H header file, 96, 97, 276
function definitions
entering prototypes and headings for, 35
with local variables declaration, 38-89
function prototypes, 35, 372
void keyword, 539
functions
argument list variations, 530-532
callback, 11
choosing header file to use with, 23
for derived classes, 185-186
described, 33, 371
friend, 154, 158-161, 368-370
as hierarchical organizations of code, 5
inline, 126-128, 210, 396-398
main, 39
member. See member functions
overloading, 12, 134, 435
overrides, 186-188
pointers to, 453-456
requirement to declare, 22
returning values, 36
static, 492-493
syntax, 34-38, 371-873
void, 37-38
See also virtual functions
function templates, 511-514
fwrite function, 95
G
get function, 104, 400
getline function, 96, 400
gets function, 90, 91-92, 93-95
global objects, 124
global variables, 39-40, 124
caution on use of, 54
glossary. See A-to-Z reference guide; individual terms
goto statements, 374
with labels, 410-411
graphical user interface (GUI) systems, 11
H
header files
described, 22, 375-376
example of use of two, 36
extern declarations in, 42
list of commonly used, 23
suggestions for publishable language extensions, 131
hexadecimal representation, 50-51, 88-89
.H filename extensions, 23
hierarchies (inheritance), 11, 188-190
I
icons
“C/C++,” 13, 15
“NOTE,” 14
“TIP,” 15
identifiers, 377-378
#ifdef directive, 386
#if directive, 379-382
if-else statements, 43-45, 383-385
conditional operator (?:), 285-286
See also loop processing
#ifndef directive, 387
ifstream objects, 399
ifstream stream objects, 95, 96
implementation files, suggestions for publishable language extensions, 131
implicit type casts, 388-389
#include directives
described, 390
header file references, 22-23
placement, 24
reasons for, 22
syntax, 22, 24, 390-391
increment operators, 47
overloading, 439-441
indexes for arrays, 239, 241
indirection, 55, 208, 221-222, 392-393
indirection operator (*), 57, 105, 392-393
inheritance
advantages, 181, 394
base-class constructors, 200-202
base-class pointers, 203-206
deriving classes, 182-185
deriving class function overrides, 186-188, 211
deriving class functions, 185-186
deriving types into family trees of classes, 197-200
example, 394-395
versus containment, 193
inheritance hierarchies, 11, 188-190
initializing pointers, 448-450, 451-452
initializing variables
member, 123-124
when declaring, 20, 25-26
inline functions, 126-128, 210, 396-398
in place of encapsulation, 126-128
virtuality disallowed, 210
input. See I/O operations
instantiation of objects, 130, 220
int data type, 21, 309, 403-404
integers
as ASCII character code, 68
in decimal, hex or octal formats, 88-89
described, 21
as variables with use of bitwise operators, 49
interchangeability
virtues for chips, 7-8
virtues for software modules, 8
interfaces
as connecting links between software modules, 8
as public functions, 196
versus internals as encapsulation, 9, 119
I/O operations
advantages of streams, 81-83, 97-99
caution on mixing techniques, 84, 89, 97-98
file operations, with STDIO.H, 92-95
line-based, with STDIO.H, 89-92
printing value of variables, 26
printing with formatting, 21
printing with stream operators, 27
sequential versus random access, 92-95
simple printing, 17-19
IOSTREAM.H header file
described, 23
and FSTREAM.H, 96
use of, 85, 86, 276
istream class, 399-402
J
jump statements, 489
K
keyboard standard input (cin), 85-87
keywords, 405
L
labels, 410-411
late binding, 206, 208, 536
left- and right-shift operators, 49
versus commutativity for class operators, 180
library functions, header files to include, 23
line breaks
in code, 18
in print operations (newline character), 26-27
linkage
by collection classes with templates, 507, 510
type-safe, 12, 269
lists
with enum declarations, 341-344
with templates, 507
literals (string), 497-498
local objects, 124
local variables, 38-39, 124
logical operators, 49
long arguments (%1d) for
scanf function, 28
long data type, 21, 309, 412-413
loop processing
arrays, 239
continue statement, 301-303
described, 414-415
exiting with break statement, 265-266
for statement, 366-367
if-else statements, 43-45, 285-286, 383-385
pointers, 64-67
stream objects, 96
while statements, 45-46, 366, 544-545
See also conditional tests; testing
1-values, 406-409
M
macros with #define directive, 322-323
main functions
with and without arguments, 417-418
described, 39, 416
with return value, 93
syntax, 416
malloc function, 73, 74-77
in CStr class, 119, 120
new and delete preferred to, 115
MALLOC.H header file, 23, 74
MATH.H header file
described, 23, 375
example of use, 36
member functions, 96, 103-114, 194-197
const objects as, 291
static, 494-495
See also data members
memory
dynamic, 73
importance of freeing, 77
menus, polymorphic, 20
minus sign (-)
with angle bracket (->) as pointer operator, 115, 429
double (—) as postfix decrement operator, 429
with equal sign (-=) as assignment operator, 178-179, 430, 443
as subtraction/negative operator, 13, 429, 430
modules
described, 41, 362
interfaces as connecting links between, 8
use of external variables for use by, 41-43, 362-363
virtues of interchangeability for, 8
modulus operator (%), 419
multiplication-assignment operator (*=), 48, 179
multiplication operator (*), 25 with operator function, 154
N
namespaces, 420-422
naming
with identifiers, 377-378
operator functions, 176
variables, 19
nesting
comments, 282
control (if/else) statements, 44-45, 335
loops, 303
newline character (\n), 26-27
new operator
advantages of default constructors, 137, 150
call to constructors and destructors, 326
described, 77-78, 423-425, 429
overloading, 441-442
return of pointer, 53, 73, 114, 115
“NOTE” icon, 14
null bytes as terminators of strings, 68
null pointers, 449, 450
null statements, 489
O
object-oriented programming, 1-2
classes of objects, 4-7
independence of objects (polymorphism), 9-11
objects
behavior created by class declaration, 108, 109
containment, 192, 193
conversion functions, 167-169, 304-305
creating, 107-108
current, 164
deleting, 73, 77-78, 115, 326-327, 429
described, 426-427
global, 124
as instances of class type, 9, 108, 130
instantiation, 130
local, 124
pointers to, 114-115
stream, 81
.OBJ filename extensions, 182
ofstream stream objects, 95, 96
operator functions
assignment, 178-179
associativity, precedence and commutativity, 179-180
binary operators, 176
calling, 156-157
CStr class examples for concatenating strings, 154-158, 161-166
CTemp example, 173-175
described, 153
naming, 176
syntax, 153-155
this keyword, 160, 164-165, 175-176
unary operators, 177
operator overloading
assignment operator functions, 438-439
binary operator functions, 438
described, 12-13, 153, 436
flexibility, 153
function call operator, 442
increment and decrement, 439-441
left- and right- shift as examples of, 86
new and delete, 441-442
subscript, 441
syntax, 436-437
unary operator functions, 437-438
operators
assignment, 48, 148, 161-166, 178
bitwise, 48-49
conditional (?:), 285-286
context (::), 299-300
description and lists, 428-430
increment and decrement, 47
left- and right-shift, 49
logical, 49
modulus, 419
reference (&), 134, 140, 141-142, 166
See also delete operator; new operator
ostream class, 399, 431-434
output. See I/O operations
overloading
compared to virtual functions, 207
constructors, 134-135, 149
described, 12, 134-135, 153
functions, 12, 134, 435
operators. See operator overloading
stream operators, 98, 401-402, 433-434
overriding functions, 186-188
pointer use, 204-206
virtual functions as, 211
P
parentheses (())
for clarification of loop statements, 65
in function calls, 429
overloading, 442
passing by reference, 56-60
peek function, 400
percent sign (%)
with equal sign (%=) as remainder assignment operator, 430
as remainder operator, 430, 475-476
performance considerations
inline functions, 398
of virtual functions, 211, 221-224
period or dot (.) in function calls, 108, 429
plus sign (+)
as addition/positive operator, 13, 86, 429, 430
double (++) as prefix increment operator, 429
with equal sign (+=) as addition-assignment operator, 48, 178-179, 430, 443
pointer arithmetic, 443-445
pointers
address expressions, 446-448
advantages, 53, 446
and arrays, 60-67
asterisk (*) as pointer-indirection operator, 57, 105, 392-393, 429
base-class, 203-206
to const variables, 288-289
described, 53, 54
for dynamic memory handling, 73-79
to functions, 453-456
initialization, 448-450
initialization and aggregates, 451-452
for loop processing, 64-67
to objects, 114-115
passing by reference, 56-60
for string handling, 72-73
syntax, 446
void keyword, 539
polymorphism, 9-11, 457
postfix and prefix expressions, 47
precedence of, 65, 66
pound sign (#) in directives, 22
precedence
for class operators, 179
of left- and right-shift operators, 87
of postfix expressions, 65, 66
primitive data types, 458
printf function
advantages of format specifiers, 89-90
caution on mixing I/0 techniques, 84, 97-98
comparison to stream operators, 84-85
described, 21, 26, 459
format modifiers, 460-461
formats, 459-460
format symbols by data type, 21
syntax, 459
private base classes, 184, 247, 249, 250, 462, 463
private data types, 128
private members, 8, 194-197, 462
programming languages
C++, 2, 3, 4
development, 1
object-oriented, 1-2
Simula, 3
Visual Basic, 2
protected base classes, 247, 249, 250, 465
protected member access, 194-197, 464
public base classes, 184, 247, 467
public data types, 128
public members, 9, 194-197, 466
punctuation, 18
putchar function, 400
puts function, 90, 93-95
Q
question mark with colon (?:) as conditional operator, 430
quotation marks (“”) for indicating string literals), 497-498
R
random access file handling, 95
reading
with read function, 400
See also scanf function
reference operator (&), 134, 140, 141-142, 166, 468-472
register keyword, 473-474
remainder operators (% and %=), 430, 475-476
reserved words (keywords), 405
return statements, 36, 477
return values, references as, 471-472
right- and left-shift operators, 49
RTTI (run-time type information), 478-480
run-time type information (RTTI), 478-480
S
sample code (in order of presentation)
printing simple string, 17-19
printing formatted out-put, 21
assigning values, 25-26
printing value of variables, 26
printing with stream operators, 27
prompting for input, 28
use of semicolons, 30
multiple assignments, 31-32
Pythagoras function call, 34
Pythagorus function call illustrating syntax and return statement, 35-37
calling void function, 37-38
Pythagoras function call with main local variables declaration, 39
Pythagoras function call with global variables declaration, 40
static variable as private to single function, 41
external variable declarations in header files, 42
nested control (if/else) statements, 44-45
compound control (if/else) statements, 45
while statements, 46
while statements with decrement operator, 47
assignment operators with calculations, 48
bitwise and left-shift operators to print binary representations, 50-51
passing by reference, 57, 58, 59, 60
declaring arrays or variable indexes, 63-64
loop processing of arrays, 64
loop processing with pointers, 64-67
copying strings, 71-72
malloc function, 73, 74-77
memory allocation with new operator, 77-78
memory freeing with delete operator, 78-79
getting and printing sum of floating-point numbers, 84-85
more compact version of previous code, 86-87
inputting line with gets and assigning fields to strings, 91-92
printing text file and converting all lower to uppercase, 93-94
printing file contents, 97
defining member functions, 103-106
inheritance trees, 197-200
base-class constructors, 200-202
base classes and pointers, 203-206
virtual functions, 209-210
virtual function indirect calls, 221-224
virtual functions for menu commands, 212-220
See also CFontIoStr; CIoStr class; CMenu class; CStr class
scanf function
advantages of format specifiers, 89-90
advantages of gets, 90-91
caution on mixing I/0 techniques, 84, 97-98
comparison to stream operators, 84-85, 399
debugging, 484
described, 27-28, 481
format modifiers, 483
format specifiers, 482
format symbols by data type, 21
other characters with, 483
syntax, 481
scope of variables, 38, 485
scope operator (::), 103-104
screen display standard output (cout), 85-87
semicolon (;)
after brace in class, struct and union declarations, 106
in empty (null) statements, 336
non-use with directives (such as #include), 22, 29
not used after braces ({}), 29, 30, 35, 106
terminating function prototype statements with, 35
terminating statements with, 18, 29
in variable declarations, 19, 25
sequential file I/O, 92-95
short data type, 21, 309, 486-487
signed char data type, 309
Simula programming language, 3
single data type, 309
sizeof operator, 429
slash (/)
with asterisk (/*....*/) as begin- and end-comment symbols, 20
as division operator, 430
as division operator with operator function, 154
doubled (//) for comment lines, 20, 281, 282
with equal sign (/=) as division assignment operator, 430
source code
of published functions or classes, 182, 190
See also compiling, CStr class; sample code
spacing, 18
stacks, 55
and auto keyword, 246
collection class template, 510-511
standard input/output, 82
See also cin objects; cout objects
standard library, 23
statements
compound, 29, 45, 283-284, 489
described, 24
expression, 31-33, 47, 360, 488
jump, 489
labels for, 410-411
null, 489
switch, 271-272, 410, 411, 489, 501-506
syntax, 488-490
versus expressions, 360
See also assignment statements
static data members, 493-494
static functions, 492-493
static keyword, 491-499
static member/unctions, 494-495
static variables, 40-41, 492, 496
STDIO.H header file
described, 22, 23, 375
file operations, 92-95
line-based input, 89-92
stream operator alternatives, 83
storage classes, 496
strcat function, 71
strcpy function, 68, 70
stream objects, 81
creating, 96
files as, 82-83
ifstream, 95
ofstream, 95
stream operators
advantages for I/O operations, 14, 81-83, 97-99
angle brackets (<< and >>} as, 83-87
caution on mixing I/O techniques, 84, 97-98
comparison to scanf function, 84-85, 399
direction of data flows, 85-86
example, 27
file handling, 95-97
overloading, 98
See also cin objects; cout objects
string classes, 102-103
string handling
in Basic versus C, 102
caution on code rewrites, 116
creating for CStr class, 106-108
STRING.H header file, 23, 71
string literals, 497-498
strings
aggregates, 234-236
char data type, 274-275
concatenating with addition operator, 13
concatenating with operator functions (overloading), 153-156
copying, 70-71
creating, 70
described, 68
determining length of, 68-69
passing to char function with conversion function, 167-169
terminated with null bytes, 68
string types, 101-102
str1en function, 71
strncpy function, 71
Stroustup, Bjarne, 3
struct declarations
declaring variables, 107
described, 499-500
in header files, 376
public versus private, 128
requiring semicolon after brace, 106
structures, compared to classes, 128
subtraction-assignment operator (-=), 48, 178-179
subtraction operator (-), 13, 430
with operator function, 154
switch statements, 489, 501-506
case keyword, 271-272
labels for, 410, 411
symbolic constants, with #define directive, 320-322
syntax
for arrays, 61
for assignment statements, 25, 245
for base classes, 247, 248
capitalization, 18
for classes, 279-280
for comment lines, 20, 281, 282
for constants, 292
for constructors, 294-295
for directives, 22, 29
for functions, 34-38, 371-373
idiosyncrasies of C++, 14, 17, 29-33
for operator functions, 153-155
for operator overloading, 436-437
period or dot (.) in function calls, 108, 429
for pointers, 446
punctuation, 18
spacing and line breaks, 18
for statements, 488-490
for variables, 19-20
See also ampersand; angle brackets; asterisk; braces; equal sign; individual topics; minus sign; parentheses; precedence; sample code; semicolon
T
templates, 507-514
testing
bits with bitwise operators, 49
for EOF, 94, 95
memory allocations or freeings, 76, 79
See also loop processing
this keyword
described, 515-516
examples, 516-517
as pointer to current object, 160, 164-165, 175-176
throw statements, 352
tilde (~)
as bitwise NOT operator, 49
as destructor name prefix, 124, 329
“TIP” icon, 15
transitioning from C to C++
anonymous unions, 237-238
begin- and end-comment symbols (/* and */), 20
“C/C++” icon, 13, 15
code porting guidelines, 267-270
ease of, 4
extern “C” declarations, 361
idiosyncrasies of C++ syntax, 14, 17
I/O with STDIO.H, 89-95
mixing declarations and statements, 24
placement of data/variable declarations, 24
pointers and data types, 76
recommended reading, 14
simplified variable declarations, 107
stream objects, 81
void main keyword requirement, 19, 267, 268
TRUE/FALSE comparisons (Boolean values), 263-264
try blocks, 348-350, 351
type casts, 273
explicit, 355-359
implicit, 388-389
void keyword, 539
typedef declarations, 107, 376
typedef operators, 518-521
typeid operator, 429, 479-480
type names in variable declarations, 19
types
abstract, 231, 308
active, 101
C++ strengthened handling of, 11-12
of classes, 9
conversion and constructors, 148-149, 151
deriving through inheritance, 197-200
explicit conversions, 355-359
providing information with function prototypes, 35
string, 101-102
use with function overloading, 12
use with operator overloading, 12-13
See also casts
type-safe linkage, 12, 269
U
unary operators
operator functions, 177
overloading, 437-438
union declarations
anonymous (unnamed), 237-238
declaring variables, 107
described, 522
examples, 523-525
in header flies, 376
public versus private, 128
requiring semicolon after brace, 106
syntax, 522
unsigned data types, 309, 526-529
V
values
assigning, 25-26
1- (left), 406-409
returned by functions, 33 same, assigning to multiple variables, 31
variables
allocating to registers, 473-474
const keyword, 287-288
declaring 19-22, 24
declaring multiple, 20
declaring with const keyword, 287-291
with enum declarations, 344-345
external, 41-43
global, 39-40, 124
incrementing and decrementing, 47
initializing when declaring, 20
local, 38-39, 124
manipulating with statements, 24-25
scope of, 38, 485
static, 40-41, 492, 496
uses for storing/manipulating data, 19
visibility, 485
vertical bar (|) (pipe character)
as bitwise OR operator, 49, 430
doubled (||) as logical OR operator, 49, 430
with equal sign (|=) as bitwise OR assignment operator, 430
virtual base classes, 211, 533-535
virtual functions
advantages, 11, 203, 207-208
compared to callbacks, 538
compared to overloading, 207
described, 536-538
implementation and performance considerations, 221-224
late binding, 206, 536
menu command example, 212-219
overrides, 188, 536
pure (no implementation), 219-220
syntax, 208
when to use, 210-211
virtual function tables, 222
visibility of variables, 485
Visual Basic, 2
void functions, 37-38
void keyword, 539-540
void main statement, 19
volatile keyword, 541-543
W
while statements, 45-46, 366, 544-545


Previous Table of Contents Next
[an error occurred while processing this directive]

Products |  Contact Us |  About Us |  Privacy  |  Ad Info  |  Home

Use of this site is subject to certain Terms & Conditions, Copyright © 1996-2000 EarthWeb Inc.
All rights reserved. Reproduction whole or in part in any form or medium without express written permission of EarthWeb is prohibited. Read EarthWeb's privacy statement.