Index
for Chapters 5-12:
Symbols
% (remainder operator) 156
%c conversion specifier 153
%d conversion specifier 153
%f conversion specifier 153
%G conversion specifier 380
%g conversion specifier 380
%hd conversion specifier 153
%ld conversion specifier 153
%Lf conversion specifier 153
%lu conversion specifier 153
%p conversion specifier 261, 371, 379
%u conversion specifier 153
%X conversion specifier 379
& (bitwise AND operator) 406
& and * pointer operators 262
&& (logical AND operator) 176
&= (bitwise AND assignment operator) 413
* assignment suppression character 384
+ flag 375
++ (increment operator) 279-280
+= 279
. (structure member operator) 398
:? 176
<< (left shift operator) 406
<<= (left shift assignment operator) 413
-= (subtraction assignment operator) 279
-> (structure pointer) 397
>> (right shift operator) 406
>>= (right shift assignment operator) 413
\" (double-quote-character escape sequence) 378
\\ (backslash-character escape sequence) 378
\' (single-quote-character escape sequence) 378
\0 (null escape sequence) 212
\a (alert escape sequence) 278
\b (escape sequence) 378
\f (form-feed escape sequence) 320, 378
\n (newline escape sequence) 320, 378
\r (carriage-return escape sequence) 320, 378
\t (horizontal tab escape sequence) 320, 378
\v (vertical tab escape sequence) 320, 378
^ (bitwise exclusive OR operator) 382, 406
^= (bitwise exclusive OR assignment operator) 413
| (bitwise inclusive OR operator) 406
|= (bitwise inclusive OR assignment operator) 413
|| (logical OR operator) 176
~ (bitwise one's complement operator) 406
Numerics
0.00 conversion specifier 380
0x (hexadecimal prefix) 376
A
a file open mode 438
a+ file open mode 438
a+ file update mode 436
ab binary file open mode 438
ab+ binary file open mode 438
absolute value 146
abstraction 147
access privileges 268
access violation 320, 370
accessibility heuristic 254
add instruction 308
address 476
address of a bit field 417
address operator (&) 156, 212, 260-261, 263, 274
Advanced string manipulation exercises 360-363
aggregate data types 271
aggregates 394
airline reservation system 251
aligning 366
argument 160
arithmetic expression 279
arithmetic operation 307
array bounds checking 209
array initializer list 205
Array name is the same as the address of the array's first element 217
array notation 284
array of pointers 295
array of pointers to functions 314-315
array subscript notation 212, 273, 285
arrow operator (->) 397
ASCII (American Standard Code for Information Exchange) 339
<assert.h> header 154
assignment expressions 279
associativity 202
atof 326
atoi 327
atol 327
Attempting to modify a constant pointer to constant data 273
Attempting to modify a constant pointer to non-constant data 272
Attempting to modify data through a non-constant pointer to constant data 270
audible (bell) 378
auto 164
automatic array 204
automatic storage duration 165, 200, 214
automatic variable 165-166
B
backslash (\) 378
bank account program 451
bar chart 210
base 10 number system 329
base 16 number system 329
base 8 number system 329
base case in recursion 170
binary 320
binary digits 430
binary search 228, 230, 257
Binary search of a sorted array 230
binary search tree 491, 495-496, 504
binary tree 467, 490
binary tree delete 505
binary tree insert 178
binary tree sort 495
bit 430
bit field 414-415
Bit fields used to store a deck of cards 415
bit manipulation 417
bitwise AND (&) operator 406, 410, 426
Bitwise, AND, bitwise inclusive OR, bitwise exclusive OR and bitwise complement operators 408
bitwise assignment operators 413
bitwise complement operator (~) 408
bitwise data manipulations 405
bitwise exclusive OR (^) operator 406, 411
bitwise inclusive OR (|) operator 406, 410-411
bitwise operators 405
bitwise shift operators 411
block 150
block of data 346
block scope 167
bounds checking 209
branch 511
branch negative 511
branch zero 511, 514-516
branching instructions 311
bubble sort 221, 226, 248, 273, 275-276, 313
bubble sort with call-by-reference 273-274
bucket sort 256, 313
Building a compiler 510
Building your own computer 306
byte 405
byte offset 444
C
C 267
C Standard Library 144, 156, 268
C++ 152
Calculating factorials with a recursive function 172
call-by-reference 155, 259, 263, 267-268, 271, 273, 399
call-by-value 155, 263, 265, 267-268, 271, 399
called function 144
caller 145
calling function 145
Card dealing program 289
card games 304
card shuffling and dealing simulation 286, 289, 400
caret (^) 382
carriage return ('\r') 320
case label 167
casino 156, 161
cast 154
ceil function 146
char * 370
char ** 328
char primitive type 153, 319
character 430
character array 212-213
character constant 269, 318, 370
character handling library 320
character handling library functions 320
character set 339, 430
character string 202
check if a string is a palindrome 178
check protection 361
chess 252
child 490
clock 160
coercion of arguments 153
coin tossing 193
column 233
comma operator (,) 176
commission 247
comparing structures 397
comparing unions 404
comparison expressions 279
compilation process 514
complement operator (~) 406
computer-assisted instruction (CAI) 194
Computing the sum of the elements of an array 207
conserve storage 414
const 219, 267-268, 272, 276, 285-286
const type qualifier 220
constant pointer 272-273, 281
constant pointer to constant data 268, 272-273
constant pointer to non-constant data 268, 272
constant string 285
conversion specification 366
conversion specifier 366
Conversion specifiers for scanf 379
convert lowercase letters to uppercase letters 154
Converting a string to uppercase using a non-constant point to non-constant data 269
copy 155
cos function 147
cosine 147
craps 156, 161
craps program 198
create sentences 358
Creating and traversing a binary tree 491
crossword puzzle generator 363
<ctype.h> header 154, 321
Cube a variable using call-by-reference 264
Cube a variable using call-by-value 263
D
data hierarchy 431-432
data structure 467
database 431
database management system (DBMS) 431
data 155
DBMS 431
deallocate memory 469
decimal 320, 329
decimal digits 430
deck of cards 286-287
declaration 183
decrement 280
default precision 368
#define preprocessor directive 206
delete a node from a list 478
delimiting character 344
Demonstrating an array of pointers to functions 296
depth of a binary tree 505
dequeue operation 484
dereferencing a pointer 261, 264
dereferencing a void * pointer 281
dereferencing operator (*) 261, 397
derived data type 394
diagnostics 154
dice game 161
dice rolling 161
dice-rolling program 211
Dice-rolling program using arrays instead of switch 211
dictionary 465
directly reference a value 259
displacement 448
display a binary tree 506
Displaying an unsigned integer in bits 408
Displaying the value of a union in both member data types 404
distance between two points 197
divide and conquer 144, 147
dot (.) operator 379
double 153, 173
double indirection (pointer to a pointer) 476
double quotes 370
double-subscripted array representation of a deck of cards 287
double-subscripted array 233-234, 287
double-subscripted array problem 251
Double-subscripted arrays example 237
dump 310
duplicate elimination 248, 255, 496, 504
duration 164-165, 167
dynamic data structure 200, 259, 467
dynamic memory allocation 468
dynamic memory management 259
E
EBCDIC (Extended Binary Coded Decimal Interchange Code) 339
editor 318
Eight Queens 178, 255, 257
Eight Queens: Brute Force Approach 255
element of an array 200
element of chance 156
end-of-file 320, 331, 432, 435
enqueue operation 484
enum 164, 417
enumeration 164, 417-418
enumeration constant 164, 417
Enumeration example 418
EOF 320
equality and relational operators 281
<errno.h> 154
error conditions 154
escape sequence 378, 391
Euler 252
Examples:
& and * pointer operations 262
Array name is the same as the address of the array's first element 217
Attempting to modify a constant pointer to constant data 273
Attempting to modify a constant pointer to non-constant data 272
Attempting to modify data through a non-constant pointer to constant data 270
Binary search of a sorted array 230
Bit fields used to store a deck of cards 415
Bitwise AND, bitwise inclusive OR, bitwise exclusive OR and bitwise complement operators 408
Bitwise shift operators 411
Bubble sort with call by reference 274
Calculating factorials with a recursive function 172
Card dealing program 289
Computing the sum of the elements of an array 207
const type qualifier 220
Conversion specifiers for scanf 379
Converting a string to uppercase using a non-constant data 269
Copying a string using array notation and pointer notation 284
Creating and traversing a binary tree 491
Cube a variable using call by reference 264
Cube a variable using call by value 263
Demonstrating an array of pointers to functions 296
Dice-rolling program using arrays instead of switch 211
Displaying an unsigned integer in bits 406
Displaying the value of union in both member data types 404
Double-subscripted arrays example 237
Enumeration example 418
Generating the values to be placed into elements of an array 205
High-performance card shuffling and dealing simulation 400
Histogram printing 210
Initializing multidimensional arrays 234
Initializing the elements of an array to zeros 203
Initializing the elements of an array with an initializer 204
Inputting characters and strings 381
Inputting data with a field width 383
Inserting and deleting nodes in a list 471
Left-justifying strings in a field 375
Linear search of an array 228
Multipurpose sorting program using function pointers 292
Operator sizeof when applied to an array name returns the number of bytes in the array 277
Passing arrays and individual array elements to functions 218
Printing a string one character at a time using a non-constant pointer to constant data 270
Printing positive and negative numbers with and without the + flag 376
Processing a queue 485
Program to simulate the game of craps 161
Programmer-defined maximum function 151
Randomizing he die-rolling program 159
Reading and discarding characters from the input stream 384
Reading input with floating-point conversion specifiers 380
Reading input with integer conversion specifiers 380
Recursively generating Fibonacci numbers 174
Right justifying integers in a field 372
Rolling a six-sided die 6000 times 157
Scoping example 168
Shifted, scaled integers produced by 1+rand()%d 156
Sorting an array with bubble sort 221
Stack program 479
Static arrays are automatically initialized to zero if not explicitly initialized by the programmer 214
Structure member operator and structure pointer operator 398
Student poll analysis program 208
Survey data analysis program 223
Treating character arrays as strings 213
Using a programmer-defined function 148
Using a scan set 382
Using an inverted scan set 382
Using atof 326
Using atoi 327
Using atol 327
Using floating-point conversion specifiers 369
Using four methods of referencing array elements 282
Using functions islower, issupper, tolower and toupper 323
Using getchar and puts 332
Using gets and putchar 331
Using integer conversion specifiers 367
Using isdigit, isalpha, isalnum and isxdigit 321
Using isspace, iscntrl, ispunct, isprint and isgraph 324
Using memchr 349
Using memcmp 348
Using memcpy 347
Using memmove 347
Using memset 349
Using precisions to display information of several types 373
Using sprintf 333
Using sscanf 334
Using strcat and strncat 337
Using strchr 340
Using strcmp and strncmp 338
Using strcpy and strncpy 336
Using strcspn 341
Using sterror 350
Using strlen 350
Using strpbrk 342
Using strrch 343
Using strspn 343
Using strstr 344
Using strtod 328
Using strtok 344
Using strtol 329
Using strtoul 330
Using the # flag 376
Using the 0 (zero) flag 377
Using the character and string conversion specifiers 370
Using the p, n and % conversion specifiers 371
Using the sizeof operator to determine standard data type sizes 278
Using the space flag 376
exp function 146
exponential complexity 177
exponential format 366
exponential function 146
exponential notation 368-369
expression 151
Extended Binary Coded Decimal Interchange Code (EBCDIC) 339
extern 164
external variable 166
F
fabs function 146
factorial 171
factorial function 171, 178
Fahrenheit 391
fatal error 311
fetch 310
fgetc 432, 465
Fibonacci function 176, 178
Fibonacci series 173, 195
field 431
field width 366, 372, 374, 383
FIFO (first-in-first-out) 484
file 430-431
file control block (FCB) 432, 434
file descriptor 432
file matching program 462
file offset 440
file open mode 434, 436
FILE pointer 438
file position pointer 440, 448
file scope 167
FILE structure 432
find the minimum value in an array 257
first-in first-out (FIFO) 484
five-card poker 304
flagged 511
flags 366, 374, 376
float keyword 153
<float.h> 154
floating point conversion specifiers 369, 373, 379
floating-point number 369
floating-point size limits 154
floor function 146
fmod function 147
form-feed character ('\f') 320
format control string 365, 373, 378
fputc 443
fputs 465
fread 443, 444
free 469
front of a queue 467
fseek 446
function 144
function body 150, 177
function call 145, 150
function call and return 155
function call stack 271
function header 267, 275
function name 149, 166, 179
function parameter 267, 272
function pointer 292
function prototype 149-150, 166, 267-268, 276
function prototype scope 166-167
function scope 167
fwrite 444, 446
G
gambling casino 156
game of craps 161, 250
game playing 156
general utilities library (stdlib) 325
generating mazes randomly 315
Generating the values to be placed into elements of an array 205
generic pointer 281
getchar 332, 432, 465
gets 331
global variable 165-167, 185, 276, 403
golden mean 173
golden ratio 173
goto statement 167
Greatest common divisor 178
guess the number exercise 194
H
Halt 308, 310
halt instruction 308, 511
hardware registers 165
head of a queue 467, 484
header 154
heuristic 254
hexadecimal (base 16) number 321, 329, 366, 370
hexadecimal integer 261
hierarchical boss function/worker function relationship 145
High-performance card shuffling and dealing simulation 400
histogram 210
Histogram printing 210
horizontal tab (\t) 320
I
#include preprocessor directive 206
including headers 155
incremented 280
indefinite postponement 287-288, 305
indirection 259, 263
indirection operator (*) 156, 261, 263
indirectly reference a value 259
infinite recursion 173
information hiding 167, 273
initializer 203
initializer list 212
initializing an array 204
Initializing multidimensional arrays 234
initializing structures 397
Initializing the elements of an array to zeros 203
Initializing the elements of an array with an initializer list 204
inner block 167
inOrder traversal 495
inorder traversal of a binary tree 178
input/output operators 307
Inputting characters and strings 381
Inserting and deleting nodes in a list 471
inserting literal characters 366
instruction 507
instruction counter 514
instruction execution cycle 310
int 154
integer array 200
integer constant 273
integer conversion specifiers 366
integral size limits 154
international Morse code 362
interpreter 519
inventory 463
inverted scan set 382
invoke a function 145
isalnum 320-321
isalpha 320-321
iscntrl 320, 324
isdigit 320-321
isgraph 321, 324
islower 268, 320, 323
isprint 321, 324
ispunct 321, 324
isspace 320, 324
isupper 320, 323
isxdigit 320-321
iteration 177
iterative function 231
K
key value 228
keyboard 331
Knight's Tour 252
Brute Force Approaches 254
Closed Tour Test 256
L
last-in-first-out (LIFO) 478
leading asterisks 361
leaf node 491
least access privilege 272
left child 490
left justification 366
left shift operator (<<) 406, 426
left subtree 490
left-justifying strings in a field 375
legacy code 267
length modifier 367
level order binary tree traversal 496, 506
LIFO (last-in-first-out) 478
limerick exercise 358
<limits.h> 154
line number 507, 510
linear data structure 470
linear search 178, 228, 257
link 468
linkage 164
linked list 259, 394, 467, 470
linked list delete 178
linked list insert 178
literal characters 366
Load 307-308, 310
load 517
load a program into memory 307
load instruction 308
load/store operations 307
local variable 147, 165-166, 213
locale 155
<locale.h> 155
log function 146
log10 function 146
logic error 152, 206, 403
logical AND (&&) operator 408
logical OR (||) operator 411
logical page 378
Logo language 251
long 171
long double 153
long int 153
lowercase letters 154
lvalue ("left value") 201
M
m-by-n array 233
machine dependent 405
machine language programming 306
Macintosh 435
macro 154
mask 407
master file 462
math library functions 155, 198
<math.h> header 146, 155
maximum 151
maze traversal 178, 314
mazes of any size 315
mean 223
median 223
member 394
memchr 346, 349
memcmp 346, 348
memcpy 346-347
memmove 347
memory access violation 268
memory addresses 259
memory allocation 155
memory functions of the string handling library 346
memory utilization 414
menu drive system 295
metric conversion program 363
minimum value in an array 178
mixed-type expressions 153
mode 223, 248
modifications to the Simple compiler 518
modifications to the simpletron simulator 315
module 144
Morse code 362
multidimensional array 234
multiple-source-file programs 165, 167
multiple-subscripted array 236
multiply two integers 178
Multipurpose sorting program using function pointers 292
N
n factorial (n!) 171
n! (n factorial) 171
name 200
name of an array 200
natural logarithm 146
newline (\n) 318-320
nodes 468
non-constant pointer to constant data 268, 270
non-constant pointer to non-constant data 268
nonfatal error 152
NULL 160, 260, 281, 285, 468, 476
null character (\0) 212, 269, 285, 318-319, 503
null-terminated character string 286
O
object-oriented programming (OOP) 147
octal 320, 329, 366
offset 282, 444, 448
open a file 435
open file table 432
operand 308
operation code 511
Operator sizeof when applied to an array name returns the number of bytes in the array 277
optimized 517
optimized code 518
optimizing the simple compiler 517
order of operands of operators 176
other arguments 366, 378
outer block 167
P
packets in a computer network 484
padding 416
page layout software 318
palindrome 257
parameter 147-148
parameter-list 149, 179
parameter names in function prototypes 152
parameter passing 267
parameter types 276
partitioning step 313
pass-by-reference 216-217
passing an array 218
passing an array element 218
Passing arrays and individual array elements to functions 218
perfect number 193
performance requirements 166
Pig Latin exercise 358
pointer 259-260, 263
pointer arithmetic 268, 279, 282, 359
pointer arrow (-->) operator 397
Pointer comparisons 281
pointer expression 282
pointer notation 267, 282, 284
pointer/offset notation 282
pointer parameter 267
pointer/subscript notation 282
pointer subscripting 282
pointer to a function 292
pointer to pointer (double indirection) 476
pointer to void (void *) 281, 469
pointer variable 273-274
pointers to functions 296
poker 340
poll 207
pop 479
position number 200
postfix evaluation 511
postfix notation 511
postorder traversal of a binary tree 178
pow ("power") function 146
power 146
precedence 202, 261
precision 366, 368
predicate function 476
preOrder traversal 495
preorder traversal of a binary tree 178
preprocessor 155
prime number 193
principle of least privilege 165, 167, 185, 220, 267, 272, 276, 300
print a linked list backwards 178
print a string backwards 178, 257
print an array 178, 257
print an array backwards 178
print characters 322
printing a string input at the keyboard backwards 178
Printing a string one character at a time using a non-constant pointer to constant data 270
printing dates in various formats 361
printing keyboard inputs in reverse 178
Printing positive and negative numbers with and without the + flag 376
probability 156
Processing a queue 485
production 517
Program to simulate the game of craps 161
programmer-defined function 145
Programmer-defined maximum function 151
promotion hierarchy 153
promotion rules 153
pseudo-random numbers 159
Q
question mark (?) character 378
queue 259, 394, 467, 484-485
quicksort 313
R
r file open mode 438
r+ file open mode 438
radians 147
raising an integer to an integer power 178
rand 156
RAND_MAX 156, 160
random-access file 443, 446
random number 155, 286, 358
Randomizing the die-rolling program 159
Randomizing the random number generator 159
rb file open mode 438
rb+ file open mode 438
readability 148
Reading and discarding characters from the input stream 384
Reading input with floating-point conversion specifiers 380
Reading input with integer conversion specifiers 380
record 271, 431, 433
record key 431
recursion 170, 176
recursion examples:
binary search 178
binary tree insert 178
check if a string is a palindrome 178
Eight Queens 178
Factorial function 178
Fibonacci function 178
Greatest Common divisor 178
inorder traversal of a binary tree 178
linear search 178
linked list delete 178
linked list insert 178
maze traversal 178
minimum value in an array 178
multiply two integers 178
postorder traversal of a binary tree 178
preorder traversal of a binary tree 178
print a linked list backwards 178
print a string backwards 178
print an array 178
print an array backwards 178
printing a string input at the keyboard backwards 178
printing keyboard inputs in reverse 178
quicksort 178
raising an integer to an integer power 178
recursive main 178
search a linked list 178
selection sort 178
sum of the elements of an array 178
sum of two integers 178
Towers of Hanoi 178
visualizing recursion 178
recursion vs. iteration 177
recursive call 170-171
recursive calls to method fibonacci 176
recursive definition 171
recursive evaluation 171
recursive function 170
recursive function gcd 196
recursive function power 195
recursive main 178
recursive step 170, 313
Recursively generating Fibonacci numbers 174
recursively print a list backwards 505
recursively search a list 505
redirected 365
register 164-165, 261
"reinventing the wheel" 145
remainder 147
remainder operator (%) 156
replacement text 206
requirements 166
return 146
return 263
return key 311
return statement 151
return type 149, 179, 276
right child 490
right justification 366, 372
right justifying integers 372
Right-justifying integers in a field 372
right shift (>>) operator 406, 426
right subtree 490
roll two dice 250
Rolling a six-sided die 6000 times 157
root node of a binary tree 490, 506
rounding 170, 366
rows 233
run time 154
run time error 212
S
scalable 206
scalar 217
scalars 274
scaling 156
scaling factor 156, 161
scan characters 379
scan set 382
scientific notation 368
scope 164, 166
Scoping example 168
search a linked list 178
search functions of the string handling library 339
search key 228
searching 229, 660
searching a binary tree 496
seed 160
seed the rand function 159
SEEK_CUR 449
SEEK_END 449
SEEK_SET 449
segmentation faults 268
selection sort 178, 257, 313
self-referential structure 468
self-documenting 396
self-referential structure 395
sequential access file 433
sequential file 431, 433
<setjmp.h> 155
Shifted, scaled integers produced by 1+rand()%6 156
shifting value 161
short keyword 153
sibling 490
side effects 155, 166
Sieve of Eratosthenes 256
<signal.h> 155
signed decimal integer 366
Simple interpreter program 519
Simpletron Machine Language (SML) 307, 315
Simpletron simulator 307, 309, 311
simulated call by reference 156
simulation 156, 286
sin function 147
sine 147
single quote (') character 370
single-subscripted array 268, 275
sinking sort 221
size_t 278, 335, 339
sizeof operator 277-278, 396, 446, 465, 469
SML 307, 309, 311, 315
software-based simulation 306, 309
software engineering 167, 267, 276
software model 309
software reusability 147
sorting 221
sorting algorithm 276
Sorting an array with bubble sort 221
space 383
space flag 376
special characters 318
Special Section: Advanced string manipulation exercises 360-363
Special Section: Building your own compiler 507-512, 514-519
Special Section: Building your own computer 306
special symbols 430
sprintf 331, 333
sqrt function 146
square brackets [] 200
square root 146
srand 159
sscanf 331, 334
stack 259, 394, 467, 478-479
Stack program 479
standard data types 278
standard error 432
standard error (cerr) 365
standard input 330
standard input file 432
standard input stream (cin) 365
standard input/output library (stdio) 330
standard input/output library character and string functions 330
standard library headers 154
standard output file 432
standard output object (cout) 365
statement 507
static 166-167, 214
static array 204
Static arrays are automatically initialized to zero if not explicitly initialized by the programmer 214
static storage duration 165
<stdarg.h> header 155
<stddef.h> header 155, 260
stderr (the standard error device) 432
stdin (the standard input device) 432
<stdio.h> header 155, 166, 330, 365, 432
stdout (the standard output device) 432
stepwise refinement 287
storage class 164
storage class specifiers 164
storage duration 165, 214
storage unit boundary 417
strcat 335-337
strchr 340
strcmp 337, 339, 451
strcpy 335-336
strcspn 339-341
stream 365
strerror 350
String 326
string array (in C) 289
string comparison functions 338, 359
string concatenation 359
string constant 318
string conversion function 325-326
string copy 359
string is a pointer 319
string literal 213, 318-319
string manipulation functions of the string handling library 335, 339-340
string processing 211
string processing function 155
<string.h> header 155, 335
strlen 350
strncat 335-337
strncmp 337, 339
strncpy 335
strpbrk 340, 342
strrchr 340, 342-343
strspn 339, 343
strstr 340, 344
strtod 326, 328
strtok 340, 344
strol 326, 328-329
strtoul 326, 329-330
struct 200
structure 271, 394
structure definition 395
structure member (.) operator 397-398, 404
Structure member operator and structure pointer operator 398
structure pointer (->) operator 397-398, 404
structure tag name 394, 396
structure type 394
structure variable 396
student poll analysis program 208
subscript 209
subscript notation 272
subtracting two pointers 281
sum of the elements of an array 178, 207
sum of two integers 178
supermarket simulation 504
survey data analysis 223, 227
symbol table 510
symbolic constant 206
syntax error 149
T
tab 378, 383
table 233
tabular format 203
tail of a queue 467, 484
tan 147
tangent 147
telephone number program 358
telephone number word problem 464
terminating null character 212, 319, 331, 369
ternary operator 176
text analysis 360
text manipulation 206
text processing 318
time 155
<time.h> 155
time/space tradeoff 271
token 340, 510
tokens in reverse 358
tolower 320, 323
top-down, stepwise refinement 287-288
top of stack 467
tortoise and the hare 305
toupper 268, 320
Towers of Hanoi 178, 195
trailing zeros 368
transaction file 462
transaction processing program 450
transaction processing systems 443
transfer of control operations 307
transfers of control 311
Treating character arrays as strings 213
tree 259, 394
trigonometric cosine 147
trigonometric sine 147
trigonometric tangent 147
turtle graphics 251
two-dimensional array 286
type checking 152
type justification 360
type mismatch 268
typedef 399-400
typesetting systems 318
U
unary operator 260
unary operator sizeof 277
unconditional branch 516
Unicode 339
union 403-404, 425
unnamed bit field 416
unnamed bit field with a zero width 417
unsigned 159
unsigned decimal integer 366
unsigned hexadecimal integer 366
unsigned int 153, 159, 335
unsigned integer 405
unsigned long integer 329
unsigned octal integer 366
uppercase letter 154
Using a programmer-defined function 148
Using a scan set 382
Using an inverted scan set 382
Using atof 326
Using atoi 327
Using atol 327
Using floating-point conversion specifiers 369
Using four methods of referencing array elements 282
Using functions islower, isupper, tolower, and toupper 323
Using getchar and puts 332
Using gets and putchar 331
Using integer conversion specifiers 367
Using isdigit, isalpha, isalnum and isxdigit 321
Using isspace, iscntrl, ispunct, isprint and isgraph 324
Using memchr 349
Using memcmp 348
Using memcpy 347
Using memmove 347
Using memset 349
Using precisions to display information of several type 373
Using sprintf 333
Using sscanf 334
Using strcat and strncat 337
Using strchr 340
Using strcmp and strncmp 338
Using strcpy and strncpy 336
Using strcspn 341
Using sterror 350
Using strlen 350
Using strpbrk 342
Using strrch 343
Using strspn 343
Using strstr 344
Using strtod 328
Using strtok 344
Using strtol 329
Using stroul 330
Using the # flag 376
Using the 0 (zero) flag 377
Using the character and string conversion specifiers 370
Using the p, n and % conversion specifiers 371
Using the sizeof operator to determine standard data type sizes 278
Using the space flag 376
utility function 155
V
variable initialization 285
vertical tab ('\v') 320
visualizing recursion 178, 196
void * (pointer to void) 281, 346, 469
W
w file open mode 438
w+ file open mode 436, 438
wb file open mode 438
whitespace 383
width of a bit field 417
Write 307-308
write 511
writing the word equivalent of the check amount 362
writing a file 435
www.unicode.org 339
Z
0 (zero) flag 377
zeroth element 200