Programming Wordlist A,B.

A

abstract classes,  

stat,  

accuracy of floating-point

arithmetic,  

float versus double datatypes,  

add function (for complex numbers),  

adding

complex numbers,  

element to linked list,  

floating-point numbers,  

addition (+) operator,  

address of (&) operator,  

(see also pointers)

addresses, variable,  

alignment problems and portability,  

ampersand (&)

for reference variables,  

(see also AND operator)

AND (&&) operator, logical,  

AND (&) operator, binary,  

AND into (&=) operator,  

apostrophe (see quotation mark)

argc and argv arguments,

arguments, command-line,  

arrays,  

of bits (see bitmapped graphics)

index operator [],  

infinite, module for (example),  

initializing,  

multidimensional,  

as parameters,  

and pointers,  

optimizing,  

of structures,  

(see also structures)

ASCII characters,  

ASCII files (see files, ASCII)

assembly language,  

assignment (=) operator,  

for classes,  

versus == (equal to) operator,  

assignment statements,  

placement of,  

author, comments about,  

auto qualifier,  

auto variable class,  

automatic

generation of member functions,  

variables,  

B

backslash (\)

as escape character,  

in preprocessor directives,  

backspace character (\b),  

bad member function,  

 base classes,  

initializing,  

search order,  

binary files,  

with multiple structures,  

binary I/O,  

binary operations (see bits)

binary operators,  

- (subtraction),  

% (modulus),  

& (AND),  

versus logical AND (&&),  

* (multiplication),  

+ (addition),  

/ (division),  

<< (left shift),  

>> (right shift),  

^ (exclusive OR),  

| (OR),  

to merge flags,  

~ (NOT),  

binary search, debugging,  

binary trees,  

nodes,  

recursion with,  

bit fields,  

bit flip operator - (see NOT operator, binary)

bitmapped graphics,  

bits,  

operations on,  

muliplication versus shifting,  

setting, clearing, and testing,  

bitwise operators (see binary operators)

<blank> modifier,  

blocks,  

stack of,  

 boldface in comments,  

Boolean operators  

Borland C++ compiler,  

Makefile for,  

bottom-up programming,  

brackets {} (see curly braces)

branching statements,  

if statements,  

switch statements,  

break command (debugger),  

(see also gdb debugger)

break statements,  

in switch statements,  

browsers, class,  

byte order and portability,  

bytes,  

pad.  

Programming Wordlist C

%c conversion,  

C language,  

binary I O,  

and C++ language,  

compiler, 

conversion routines, 

I/O (input/output),  

handling exceptions in,  

programming tools for,  

C++ compiler

Borland,  

g++,  

Microsoft Visual, 

Turbo,  

UNIX CC.  

C++ file I/O,  

C++ language, 

compared with C language.  

programming tools for,  

standard functions in,  

C++ preprocessor, 

#define directive,  

#include directive.  

call by address,  

call by value, 

and copy constructors,  

callback functions. 

<carriage return> character,  

case labels 

case sensitivity,  

cast operators,  

catch keyword,  

cerr (console error) class variable,  

CFront templates.  

char variable type,  

character(s)

ASCII,  

constants.  

data (see files, ASCII)

character(s) (continued)

special,  

treated as bits,  

variables, 

character-to-number (>>) operator,  

character-type modules,  

cin (console input) class variable.  

class keyword,  

class member (->) operator,  

class, variable (see variables, classes of)

classes, 

( ) operator for,  

abstract,  

accessing members of,  

assignment (=) operator for,  

base,  

browsers for,  

complex,  

constant members of,  

constructors and destructors,  

default constructors,  

derived,  

friends of (see friend classes)

hierarchy of,  

I/O stream, 

member functions,  

member variables,  

members of static,  

and pointers,  

problems reading, 

programming style for,  

pure virtual functions,  

search order of,  

standard,  

stat,  

and structures,  

templates of,  

virtual,  

clearing bits,  

clog (console log) class variable,  

close member function, 

COBOL,  

code (see programs; source files)

comma (,) operator,  

command-line

arguments, 

debugging switch,  

comment boxes,  

comments,  

in headers,  

marking variable units,  

styles for,  

comparing strings (see strcmp function)

compiler

Borland C++,  

construction of,  

g++,  

Microsoft Visual C++, 

Turbo-C++,  

UNIX CC,  

compiling, conditional,  

complex class,  

complex numbers,  

adding,  

concatenating expressions (,) operator, 

concatenating strings (see strcat function)

conditional

breakpoints,  

clauses (see branching statements)

compilation,  

statements (see: construct; ? construct; switch statements)

confessional method of debugging, 

const keyword,  

versus #define directive,  

const parameters, 

reference,  

const variable type,  

constant call by value,  

constants

character, 

class members as,  

declaring,  

#define versus const,  

hexadecimal,  

naming,  

octal, 

pointers as,  

constructors, class, 

copy,  

default,  

in derived classes, 

overloading,  

parameterized, 

cont command (debugger),  

(see also gdb debugger)

continue statements,  

control statements,  

control variables, 

(see also for statements)

conversion

flags, 

integer-to-floating-point,  

routines for,  

C-style I/O,  

copy constructors,  

copying strings  

core files, 

cout (console out) class, 

for debugging,  

diagnostic use of,  

temporary, 

in Turbo-C++,  

cross-references,  

ctype.h include file,  

curly braces {},  

and structures.  

Programming Wordlist D

%d conversion, 

data

inputting, 

protecting,  

stacks of  ,

datatypes,  

changing  

classes,  

defining special,  

enum (enumerated),  

pointers,  

stacks,  

structures,  

unions,  

debugger as browser,  

debugging,  

binary search,  

confessional method of,  

divide-and-conquer method,  

interactively (see interactive debugging)

playback file, 

saving keystrokes,  

with text editor,  

using a program switch,  

within program code,  

dec I/O manipulator, 

decimal numbers, 

decimal places for numbers, 

declaring

constants,  

#define versus const,  

file variables,  

functions,  

pointers, 

structures,  

style of,  

templates,  

variables,  

decrease (-=) operator, 

decrement (--) operator, 

default

constructors,  

parameters,  

statements, in switch statements (see switch statements)

#define directive,  

versus const keyword.  versus enum statement,  

versus typedef statement,  

defining variable types, 

delete function, 

delete operator,  

using brackets [] with,  

deleting derived classes,  

dereference (*) operator,  

derived classes,  

constructors and destructors,  

deleting,  

hiding members functions in,  

search order,  

designing

file formats,  

modules,  

programs,  

destructors,  

calling virtual functions from,  

in derived classes,  

names for,  

virtual,  

diagnostic cout,  

disk files, I O with,  

divide by 0 error, 

divide into (/=) operator,  

divide-and-conquer debugging method,  

dividing floating-point numbers,  

division ( ) operator,  

do while loops  

documentation, Oualline's law of,  

dot ( ) operator,  

double keyword,  

double qualifier,  

versus float datatype,  

double quote  

double-linked lists,  

Programming Wordlist E,F,G,H.

E

%e conversion,  

elements, array,  

else statements,   

#endif directive,  

endl I/O manipulator,  

end-of-line puzzle, end-of-string character,  end-of-string marker,  

ends I/O manipulator,  

enum (enumerated) datatype,  

equal to (==) operator.  

versus = (assignment) operator,  

errors

eliminating from code (see debugging)

handling within programs,  

infinite recursion, 

roundoff (floating-point),  

runtime (see runtime errors)

stack overflow, 

escape character (\),  

evaluation order,  

exceptions,  

in C, 

runtime library,  

exclusive OR (^) operator,  

exclusive OR into (^=) operator,  

executable programs, 

exponential notation,  

expressions, simple,  

extended precision (see long double qualifier)

extern modifier,  

extern variable class,  

F

%f conversion,  

"// fall through" comment, 

fast prototyping,  

fclose (file close) function,  

fgetc (get character) function, 

fgets (get string) function, 

file formats, comments on,  

filenames, portability of, 

files

ASCII,  

binary,  with multiple structures,  

changing modification date of,  

core,  

designing formats for, 

directing debugging information

into,  

disk,  

header,  

I/O with (see I/O)

identification numbers for, 

include (see include files)

multiple (see modules)

object (see object files)

playback, for debugging,  

source (see source files)

standard unbuffered,  

types of, and portability, 

variables for,  

find function (linked lists),  

flags

conversion,  

open,  

float datatype, 

versus double datatype,  

float keyword,  

float h include file,  

floating-point numbers,  

arithmetic,  

accuracy of,  

guard digit, 

overflow and underflow, 

floating-point numbers (continued)

arithmetic (continued)

roundoff error, 

speed of,  converting to integers,  

dividing,  

versus integers,  

flush command.  

flush I/O manipulator,  

fopen (file open) function,  

for statements,  

formatting

files,  

floating-point numbers,  

programs,  

form-feed character (\f), 

FORTRAN, 

fputc (put character) function,  

fputs (put string) function,  

fractional numbers

fread routine, 

free function (C language), 

friend classes,  

friend directive.  

fscanf function,  

fstream class.  

fstream.h file, 

functions,  callback,  

as class members,  

inline,  

versus parameterized macros, 

K&R style,  

length of, 

 as operators,  

 overloading,  parameters of,  arrays as,  

const, 

reference,  

recursive,  

static, templates of,  

virtual,  

pure,  

functions, standard (see standard functions)

fwrite routine,  

G

-g (compiler option),  

g++ compiler,  

Makefile for,  

templates in,  

gdb debugger,  

example of using,  

generating templates,  

getline member function,  

global variables, 

goto statements,  

programming without.  

graphics, bitmapped,  

greater than (>) operator,  

greater than or equal to (>=) operator, 

guard digits,  

(see also floating-point numbers)

H

header files,  

headers,  

comments in.  

help, online UNIX, 

hex I/O manipulator, 

hexadecimal numbers,  hiding member functions, 

hierarchy, class,  high-level languages.  

hyphen (-) for command-line options,  

Programming Wordlist I,J,K,L.

I

I/O (input output), 

binary,  

C-style,  

C++ file package,  

conversion routines,  

C-style, 

with disk files. 

manipulators,  

operators

<< (output), >> (input),  

unbuffered,  

I/O stream classes,  

IDE (integrated development environment),  

if statements, 

with else statement,  

(see also ? construct;: construct; switch statements)

#ifdef directive, 

#ifndef directive, 

ifstream

::bad,  ::close,  :.open, 

implementing templates,  

#include directive, 

include files, 

ctype.h,  

float.h,  fstream.h, iomanip.h,  

iostream.h,  

nested,  

stdio.h,  

inclusive OR operator (see OR operator)

increase (+=) operator,  

increment (++) operator,  

indentation, styles of,  

tools for,  

index [] operator,  

index, array,  

infinite arrays, module for (example),  

infinite recursion error, 

info command (debugger),  

(see also gdb debugger)

init function,  

initializing 

arrays  

base classes,  

stacks,  

automatically,  strings,  

structures,  

temporary variables, 

variables, 

inline directive, and classes,  

inline functions, 

versus parameterized macros,  

input (>>) operator, 

inputting data,  

int (integer) keyword,  

int number type,  

long versus short,  

(see also size qualifiers, variables)

integers,  

converting to floating-point

numbers, 

dividing,  

signed versus unsigned, 

integrated development environment (IDE),  

interactive debugging,  

conditional breakpoint trick,  

invert (-) operator (see NOT operator, binary)

iomanip.h file,  ios

::app flag,  

::ate flag,  

::binary flag,  

::dec flag, 

::fixed flag,  

::hex flag,  

::in flag,  

:internal flag,  

::left flag, 

::nocreate flag,  

::noreplace flag,  

::oct flag,  ::out flag, 

::right flag, 

::scientific flag,  

:.showbase flag,  

::showpoint flag,  

:showpos flag,  

::skipws flag,  

::stdio flag,  

::trunc flag,  

::unitbuf flag,  

::uppercase flag, iostream

class, 

::fill,  

::precision,  :-setf,  

::unsetf, iostream.h include file, 

ipfx member function,  

isalpha macro,  

istream

class,  :·getline,  

··ipfx,  

italics in comments, 

J

justification,  

K

K&R-style functions,  

L

L character, for long integers, 

labels for goto statements,  

languages

assembly (machine),  

C (see C language)

C++ (see C++ language)

other high-level,  

%1d conversion,  

left shift (<<) operator, length function,  

less than (<) operator,  

less than or equal to (<=) operator,  

letters (see character constants)

libraries, standard,  LIFO (last-in-first-out) order 

linear programs, 

<line-feed> character, 

linked lists, 

double-linked,  ordered,  

linkers,  list command (debugger),  

(see also gdb debugger)

lists, linked (see linked lists)

local include files,  

local variables, 

static,  

logical operators, 

! (NOT),  

&& (AND), 

versus bitwise AND,  

| | (OR), 

and relational operators,  

long double qualifier, long int keyword,  

long int type, 

long qualifier,  

longjmp function (C language), 

looping statements,  

and break statements,  

control variables in (see control variables)

for statements, 

optimizing order of, while loops, 

%lu conversion,