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