The ONLY C++ Glossary - 
(On the internet anyway)

& - A number of meanings.  When it precedes the name of a variable without
following a type name, it means "the address of the following variable."
For example, &Str means "the address of the variable Str."  When & follows
a type name and precedes a variables name, it means that the variable
which is being declared is a reference; that is, another name for a
prexexisting variable.  In this book, references are used only in argument
lists, where they indicate that the variable being defined is a new name
for the caller's variable rather than a new local variable.

< - This is the "less than" operator, which returns the value true if the
expression on its left has a lower value than the expression on its right;
otherwise, it returns the value false.  Also see operator < later on.

= - This is the assignment operator.  It assigns the value on its right to
the variable on its left.  Also, see operator = later on.

> - The "greater than" operator.  It returns the value true if the
expression on its left has a greater value than the expression on its
right; otherwise, it returns the value false.  Also see operator > later
on.

[ - Left square bracket.  See square brackets for more info.

] - Right square bracket.  See square brackets for more info.

{ - Left curly brace.  See curly braces for more info.

} - Right curly brace.  See curly braces for more info.

!= - The "not equals" operator, which returns the value true if the
expression on its left has a value different from the expression on its
rightl otherwise, it returns the value false.  See Operator != later on.

&& - is the "logical AND" operator.  It produces the result true if both
of the expressions on its right and left are true; if either of those
expressions is false, it produces the result false.  However, this isn't
the whole story.  There is a special rule in c++ governing the execution
of the && operator: If the expression on the left is false, then the
answer must be false and the expression on the right is not executed at
all.  The reason for this short-circuit evaluation rule is that in some
cases you may want to write a right hand expression that will only be
legal if the left hand expression is false.

++ - incerment operator, which adds 1 to the variable to which it is
affixed.

+= - add to variable operator, which adds the value on its right to the
variable on its left.

// - comment operator.  See comment for usage.

<< - stream output operator, used to write data to an ostream.  See
operator << later on.

<= - less than or equal to operator, which returns the value true if the
expression on its left has the same value or a lower value than the
expression on its right; otherwise, it returns the value false.  See
operator <= later on.

== - equals operator, which returns the value true if the expression on
its left has the same value as the expression on its right; otherwise it
returns the value false.  See operator == later on.

>= - greater than or equal to operator, which returns the value true if
the expression on its left has teh same value or a greater value than the
expression on its right; otherwise it returns the value false.  See
operator >= later on.

>> - stream input operator, used to read data from an istream.  See
operator >> later on.

[] - used after the delete operator to tell the compiler that the pointer
for which delete was called refers to a group of elements rather than just
one data item.  This is one of the few times when we have to make that
distinction explicitly, rather than leave it to context.

ll - the "logical OR" operator.  It produces the result true if at least
one of the two expressions on its right and left are true; if both of
those expressions are falst, it produces the result false.  However, this
isn't the whole story.  There is a special rule in c++ governing the
exexcution of the ll operator:  If the expression on the left is true,
then the answer must be true and the expression on the right is not
executed at all.  The reason for this short circuit evaluation rule is
that in some cases you may want to write a right hand exoression that will
only be legal if the left hand expression is true.

#include - An #include statement has the same effect as copying all of the
code from a specified file into anothr file at the point where the
#include statement is written.  For example, if we wanted to use
definitions contained in a file called iostream.h in the implementation
file test.cc, we could instert the include statement #include <iostream.h>
in test.cc rather than physically copying the lines from the file
iostream.h into test.cc.


A

Access Specifier - controls the access of nonmember functions to the
member of functions and the variables of a class.  Two classes are used
ever.  One is public, which allows general access to member functions and
variables, and private, which forbids access by nonmembers functions.
Also, see friend.

Access time - a measure of how long it takes to retrieve data from a
storage device, such as RAM.

Address - see memory address.

Algorithm - a set of precisely defined steps guaranteed to arrive at an
answer to a problem or set of problems.  As this implies, a set of steps
that might never end is a not an algorithm.

Application program - a program that actually accomplishes some useful or
interesting task.  Examples include inventory control, payroll, and game
programs.

Application programmer - a programmer who uses native and class variables
to write an application program.  See library designer.

Argument - a value that is suppled by one function (the calling function)
that wishes to make use of the services of another function (the called
function).  There are two main types of arguments: value arguments, which
are copies of the values from the calling function, and reference
arguments, which are not copies but actually refer to varialbes in the
calling function.

Argument List - a set of argument definitiions specified in a function
declaration.  The argument list descrbies the types and names of all the
variables that the function receives when it is called by a calling
function.

Array - a group of elements of the same type; for example, we can create
an array of chars.  The array name corresponds to the address of the first
of these elements; the other elements follow the first one immediately in
memory.  As with a vector, we can refer to the individual elements by
their indexes.  Thus, if we have an array of chars called m_Data,
m_Data[i] referes to the ith char in the arry.  Also see pointer.

ASCII Code - a standardized representation of characters by binary or
hexadecimal values.  For example, the letter A is represented as a char
with the hexadecimal value 41, and the digit 0 is represented as a char
with the hexadecimal value 30.  All other printable charactes also have
representations in the ASCII code.

Assembler - a program that translates assembly language instructions into
machine instructions.

Assembly language - human readable representation of a machine
instruction.

Assignment - the operation of setting a variable to a value.  The operator
that indicates assignment is the equal sign, =.

Assignment operator - function that sets a preexisting variable to a value
of the same type.  There are three varieties of assignment operators: 
1 - For a variable of a native type, the compiler supplies a native
assignment operator.

2 - For a variable of a class type, the compiler will generate its own
version of an assignment operator (a compiler generated assignment
operator), if the class writer does not at the same time.

3 - The class writer can write a member function to do te assignement, see
operator = later on.

Assignment statement - such asx = 5; is not an algebraic equality, no
matter how much it may resemble one.  It is a command telling the compiler
to assign a value to a variable.  In the example, the variable is x and
the value is 5.

Auto Storage Class - default storage class for variables declared within
c++ functions.  When we define a variable of the auto storage cass, its
memory address is assigned automatically upon entry to the function where
it is define; the memory address is valid for the duration of that
function.


B

Batch File - A text file that directs the execution of a number of
programs, one after the other, without manual intervention.  A similar
facility is available in most operating systems.

Binary - Number system that uses only two digits, 0 and 1.

Bit - Fundamental unit of storage in a modern computer; the word "bit" is
derived from the phrase BInary digiT.  Each bit, as this suggests, can
have on of two states: 0 or 1.

Block - A group of statements that are considered one logical statement.
A block is delimited by the "curley braces" ( { and } ).  The first of
these symbols starts a block, and the second one ends the block.  A block
can be used anywhere that a statement can be used and is treated in eactly
the same way as if it were one statement.  For example, if a block is the
controlled block of an if statement, then all of the statements in the
block are executed if the condition in the if is true and none is executed
if the condition in the if is false.

Bool - Short for boolean.  A type of variable whose range of values is
limited to true or false.  This is the most appropriate return type for a
function that uses its return value to report whether some condition
exists, such as operator <.  In that particular case, the return value
true indicates that the first argument is less than the second, while
false indicates that the first argument is not less than the second.

Break statement - A loop control device that interrupts processing of a
loop whenever it is executed within the controlled block of a loop control
statement.  When a break statement is executed, the flow of control passes
to the next statement after the end of the controlled block.

Byte - The unit in which data capacities are stated, whether in RAM or on
a disk.  In modern computers, a byte is made up of 8 bits.


C

C string - A literal value representing a variable number of characters.
An example is "This is a test."  C strings are surrounded by double quotes
(" ").  Note that this is NOT the same as a C++ String.

Cache - A small amount of fast memory where frequently used data is stored
temporarily.

Call instruction - An assembly language instruction that is used to
implement a function call.  It saves the program counter on the stack, and
then transfers execution from the calling function to the called function.

Called function - A function that starts execution as the result of a
function call.  Normally, it will return to the calling function via a
return statement when finished.

Calling function - A function that suspends execution as a result of a
function call; the called function begins execution at the point of the
function call.

Char - An integer variable type that can represent either one character of
text or a small whole number.  Both signed and unsigned chars are
available for use as "really short" integer variables; a signed char can
represent a number from -128 to +127, whereas an unsigned char can
represent 0 - 255.

Char* - A pointer to a char or the first of a group of chars.

Cin - Predefined istream; it gets its characters from the keyboard.

Class - A user defined type; for example, string is a class.

Class Implementation - Tells the compiler how to implement the facilities
defined in the class interface.  A class implementation is usually found
in a implementation file.

Class Interface - Tells the user of the class what facilities the class
provides by specifying the public member functions of the class.  It also
tells the compiler what data elements are included in objects of the
class, but this is not logically part of the interface.  A class interface
is usually found in a header file, that has the extension ".h."

Class Membership - Operator, ::, indicates which class a function belongs
to.  For example, the full name of the default constructor for the string
class is "string::string()."

Class Scope - Describes the visibility of member variables; that is, those
that are defined within a class.  These variables can be accessed by any
member function of that class; their accessibility to other functions is
controlled by the access specifier in effect when they were defined in the
class interface.

Comment - Note to the programmer; it is ignored by the compiler your
using.  The symbol // marks the beginning of a comment; the comment
continues until the end of the line contraining the //.  For people
familiar with the BASIC language, its just like REM; anything after it on
a line is ignored by the compiler.

Compilation - Process of translating source coe into an object program,
which is composed of machine instructions along with the data needed by
those instructions.  Virtually all of the software on your computer was
created by this process.

Compiler - A program that performs the process of compilation.

Compiler-generated - Function is supplied by the compiled because of the
existence of that function is fundamental to the notion of a concrete data
type.  The compiler will automatically generate its own version of any of
the following functions if they are not provided by the creator of the
class: the assignment operator, the copy constructor, the default
constructor, and the destructor.

Compile time - Is simple.  Means "While the compiler is compiling the
source code of a program."

Concrete Data Type - A type of class whose objects behave like variables
of native data types.  That is, the class gives the compiler enough
information that objects of that class can be created, copied, assigned,
and automatically destroyed just as native variables are.

Const - Two different meanings.  The first is a modifier to an argument of
a function.  In this context, it means that we are promising not to modify
the value of that argument in the function.  An example of this use might
be the function declaration "string& operator = (const string& Str);.
The second use of const is to define a data item similar to a variable,
except that its value cannot be changed once it has been initialized.  For
this reason, it is mandatory to supply an initial value when creating a
const.  An example of this use is const short x = 5.

Constructor - A member function that creates new objects of a particular
class type.  All constructors have the same name as the class for which
they are constructors; for example, the constructors for the string class
have the same name string.

Continuation Expression - Part of a for statement computed before every
execution of the controlled block.  The block controlled by the for will
be executed if the result of the computation is true, but not if it is
false.

Controlled Block - A block under the control of a loop control statement
or an if or else statement.  The controlled block of a loop control
statement can be executed a variable number of times, whereas the
controlled block of an if or else statement is executed either once or not
at all.

Copy Constructor - Makes a new object with the same contents as an
existing object of the same type.

Cout - Pronounced "see out."  A predefined ostream; characters sent to it
are displayed on the screen.

CPU - Abbreviation for Central Processing Unit.  This is the "active" part
of your computer, which executes all the machine instructions that make
the computer do useful work.

Curly Braces - Used to surround a block.  The compiler treats the
statements in the block as one statement.  { and }.


D

Data - Pieces of information that are operated on by programs.
Originally, "data" was the plural of "datum"; however, the form "data" is
now commonly used as both singular and plural.

Debugger - A program that controls the execution of another program, so
that you can see what the latter program is doing.

Dedicated Register - A register such as the stack pointer whose usage is
predefined, rather than being determined by the programmer.  Compare with
general registers such as eax.

Default Constructor - A member function that is used to create an object
when no initial value is specified for that object.  For example,
"string::string()" is the default constructor for the string class.

Delete - Operator used to free memory that was previously used for
variables of the dynamic storage class.  This allows the memory no longer
needed for those variables to be reused for other variables.

Destructor - Member function that cleans up when an object expires; for an
object of the auto storage class, the destructor is called automatically
at the end of the function where that onject is defined.

Digit - One of the characters used in any position numbering system to
represent all numbers starting at 0 and ending at one less than the base
of the numbering system.  In the decimal system, there are ten digits, 0 -
9 and in the hexadecimal system there are sixteen digits, 0 - 9 and a - f.

Double - A type of floating point variable that can represent a range of
positive and negative numbers including fractional values.  With most
current c++ compilers, these numbers can vary from approximately 4.940656e
- 324 to approximately 1.79769e + 308 (and 0), with approximately 16
digits of precision.

Dynamic Storage Class - Used for variables size is not known until run
time.  Variables of this storage class are assigned memory addresses at
the programmer's explicit request.

Dynamic type check - refers to the practice of checking the correct
usage of variables of different types during execution of a program rather
than during compilation; see type system for further diiscussion.


E

Element - One of the variables that make up a vector or an array.

Else - Causes its controlled block to be executed if the condition in its
matching if statement turns out to be false at run time.

Empty stack - A stack that currently contains no values.

Encapsulation - Concept of hiding the details of a class inside the
implementation of that class rather than exposing them in the interface.
This is one of the primary organizing principles that characterize object
oriented programming.

End user - The person who actually uses an application program to perform
some useful or interesting task.  Also see application programmer, or
library designer.

Executable program - A program in a form suitable for running on a
computer; it is composed of machine instructions along with data needed by
those instructions.


F

False - Predefined value, representing the result of a condition
expression whose condition is not satisfied.  For example, in the
condition expression x < y, if x is not less than y, the result of the
expression will be falst.  Also see bool.

Fencepost error - A logical error that causes a loop to be executed one
more or one less time than the correct count.  A common cause of this
error is confusing the number of elements in a vector or array with the
index of the last element.  The derivation of this term is by analogy with
the problem of calculating the number of fence sections and fenceposts
that you need for a given fence.  For example, if you have to put up a
fence 100 feet long and each section of the fence is 10 feet long, how
many sections of fence do you need?  Obviously, the answer is 10.  Now,
how many fenceposts do you need?  11.  The confusion is caused by counting
fenceposts when yu should be counting segments of the fence (and vice
versa) is the cause of a fencepost error.  Returning to a programming
example, if you have a vector with 11 elements, the index of the last
element is 10, not 11.  Thus confusing the number of elements with the
highest index has much the same effect as the fencepost problem.  This
sort of problem is also known as, less colorfully, as an off-by-one error.

Float - Type of floating point variable that can represent a range of
positive and negative numbers including fractional values.  With most
current c++ compilers, these numbers can vary from 1.401298e-45 to
3.40282e+38 (and 0), with 6 digits of precision.

Floating Point Variable - FPV for short.  An approximation of a
mathematical "real number."  Unlike the mathematical real numbers, c++
floating point variables have a limited range and precision, depending on
their types.  See "float" and "double" for details on this.

For statement - Loop control statement that causes its controlled block to
be executed while a specified logical expression (the continuation
expression) is true.  It also provides fr a starting expression to be
executed before the first execution of the controlled block, and a
modification expression to be executed after every execution of the
controlled block.  For example, in the for statement "for (i = 0l i < 10;
i ++)" the initilization expression is i = 0.  The continuation expression
is i <10, and the modification process is i ++.

Friend - Allows access by a specified class or function to private members
of a particular class.

Function - A section of code having a name, optional arguments, and a
return type.  The name makes it possible for one function to start
execution of another one via a function call; the arguments are used to
provide input for the function, and the return type allows the function to
provide output to its calling function when the return statement causes
the calling function to resume execution.

Function call - Causes execution to be transferred temporarily from the
current function to the one named in the function call.  Normally, when a
called function is finished with its task, it will return to the calling
function, which will pick up execution at the statement after the function
call.

Function declaration - Tells the compiler some vital statistics of the
function: its name, its arguments, and its return type.  Before we can use
a function, the compiler must have already seen its function declaration.
The most common way to arrange for this is to use a #include statement to
insert the function declaration from the header file where it exists into
our implementation file.

Function overloading - The c++ facility that allows us to create more than
one function with the same name.  So long as all such functions have
different signatures, we can write as many of them as we wish and the
compiler will be able to figure out which one we mean.


G

General register - A register whose usage is determined by the programmer,
rather than being predefined as with dedicated registers such as the stack
pointer.  On an intel CPU such as the 486 or Pentium, the 16 bit general
registers are ax, bx, cx, dx, si, di, and bp; the 32-bit general registers
are eax, ebx, ecx, edx, esi, edi, and ebp.

Global scope - Describes the visibility of variables that are defined
outside any function; such variables can be accessed by code in any
function.  It also describes the visibility of functions that are defined
outside any class.


H

Hardware - Refers to the phsyical components of a copmuter, the ones you
can touch.  Examples are the keyboard, monitor, and the boards inside your
computer.

Header file - A file that contains class interface definitions and/or
global function declarations.  By convention, header files have the
extension .h.

Heap - Area of memory where variables of the dynamic storage class store
their data.

Hex - Abbreviation for hexadecimal.

Hexadecimal - Number system that has 16 digits, 0 - 9, and a - f.


I

Identifier - User defined name; both function names and variable names are
identifiers.  Identiffiers must not conflict with keywords such as if and
for; for example, you cannot create a function or a variable with the name
for.

If statement - A statement that causes its controlled block to be executed
if the logical expression specified in the if statement is true.

Ifstream - Pronounced "i f stream."  A stream used for input from a file.

Implementation file - Contains source code statements that are turned into
executable code by a compiler.

Increment a variable - Means to add 1 to its value.  In c++, this is done
by using the increment operator, ++.

Index - An expression used to elect one of a number of elements of a
vector or an array.  It is enclosed in square brackets ( [ ] ).  For
example, in the expression a[i+1], the index expression is i+1.

Index variable - Used to hold an index into a vector or an array.

Initiolization - The process of setting the initial value of a variable or
const.  It is very similar to assignment but is not identical.
Initialization is done only when a variable or const is created, whereas a
variable can be assigned to as many times as desired.  A const, however,
cannot be assigned to at all, so it must be initialized when it is
created.

Input - The process of reading data into the computer from the outside
world.  A very commonly used source of input for simple programs is the
keyboard.

Int - Short for integer.  A type of integer variable.  While the c++
language definition requires only that an int be at least as long as a
short and no longer than a long, with most current c++ compilers thistype
is equivalent to either a short or a long, depending on the compiler you
are using.

Integer variable - A c++ representation of a whole number.  Unlike
mathematical integers, c++ integers have a limited range, which varies
depending on their types.  See the individual types char, short, int, and
long for details.  The type bool is sometimes also considered an integer
variable type.

I/O - Abbreviation for Input/Output.  This refers to the process of
getting information into and out of the computer.  See input and output
for more details.

Iostream.h - Name of the header file that tells the compiler how to
compile code that uses predefined stream variables like cout and operators
like <<.

Istream - A stream used for input.  For example, cin is a predefined
istream that reads characters from the keyboard.  Istream means Input
Stream.


K

Keyword - A word defined in the c++ language, such as if and for.  It is
illegal to define an identifier such as a variable or function name that
conflicts with a keyword; for example, you cannot create a function or a
variable with the name for.


L

Library - Contains the object code generated from several implementation
files, in a form that the linker can search when it needs to find
general-purpose functions.

Library designer - A programmer who creates casses for application
programmers to use in writing application programs.

Linker - Program that combines information from all of the object files
for our program, along with ome previously prepared files called
libraries, to produce an executable program.

Linking - The process of creating an executable program from object files
and libraries.

Literal - Value doesnt have a name, but represents itself in a literal
manner.  Some examples are 'x' (a char literal having the ASCII value that
represents the letter x) and 5 (a numberic literal with the value of 5).

Local scope - Describes the visibility of variables that are defined
within a function; such variables can be accessed only by code in that
function.

Logical expression - An expression that takes on the value true or false,
rather than a numerical value.  Some examples of such expressions are x >
y (which will be true if x has a greater value than y and false otherwise)
and a==b (which will be true if a has the same value as b, and false
otherwise).  Also see bool.

Long - A type of integer variable that can represent a whole number.  With
most c++ compilers, a long occupies 4 bytes of storage and therefore can
reresent a number in either the ranger -2147483648 to 2147483647 (if
signed) or the range 0 to 4294967295 (if unsigned).

Loop - Means of executiong a controlled block a variable number of times,
depending on some condition.  The statement that controls the controlled
block is called a loop control statement.  See "while" and "for" for more
details.

Loop control statement - A statement that controls the controlled block in
a loop.


M

Machine Code - Combination of machine instructions with the data used by
those instructions.  A synonym is object code.

Machine instruction - One of the fundamental operations that a CPU can
perform.  Some examples of these operations are addition, subtraction, or
other arithmetic operations; other possibilities include operations that
control what instruction will be executed next.  All c++ programs must be
converted into machine instructions before they can be executed by the
CPU.

Machine language - Program composed of machine instructions.

Member function - A function defined in a class interface.  It is viewed
as belonging to the class, which is the reason for the adjective member.

Member initialization expression - Preferred method of specifies how a
member variable is to be initialized in a constructor.

Member initialization list - Specifies how member variables are to be
initialized in a constructor.

Member variable - A variable defined in a class interface.  It is viewed
as belonging to the class, which is the reason for the adjecteve member.

Memberwise copy - Means to copy every member variable from teh source
object to the destination object.  If we don't define our own copy
constructior or assignment operator for a particular class, the
compiler-generated versions will use memberwise copy.

Memory Address - A unique number identifying a particular byte of RAM.

Memory Hierarchy - The particular arrangement of the different kinds of
storage devices in a given computer.  The purpose of using various kinds
of storage devices having different performance characteristics is to
provide the best overall performance at the lowest cost.

Memory leak - A programming error in which the programmer forgot to delete
something that had been dynamically allocated.  Such an error is very
insidious, because the program appears to work correctly when tested
casually.  The usual way to find these errors is to notice that the
program runs apparently correctly for a (possibly long) time and then
fails due to running out of available memory.

Modification expression - The part of a for statement executed after every
execution of the controlled block.  It is often used to increment an index
variable to refer to the next element of an array or a vector; see for
statement for an example.


N

Nanosecond - One billionth of a second.

Native - A data type that is defined c++ language, as opposed to a
user-defined data type (class).

New - Operator is used to allocate memory for variables of the dynamic
storage class; these are usually variables whose storage requirements may
not be known until the program is executing.

Nonmember function - One that is not a member of a particular class being
discussed, although it may be a member function of another class.

Nonnumeric variable - A variable that is not used in calculations like
adding, multiplying, or subtraction.  Such variables might represent
names, addresses, telephone numbbers, Social Security numbers, bank
account numbers, or drivers license numbers.  Note that just because
something is called a number or even is composed entirely of the digits
0 - 9, does not make it a numeric variable by our standards; the questions
is how the item is used.  Noone adds, multiplies, or subtracts drivers
license numbers, for example; they serve solely as identifiers and could
just as easily have letters in them, as indeed some of them do.

Nonprinting character - Used to control the format of our displayed or
printed information, rather than to represent a particular letter, digit,
or other special character.  The space ( ) is one of the more important
nonprinting characters.

Null Byte - An object of some class whose purpose is to indicate that a
"real" object of that class does not exist, analogously to a null pointer.
One common use for a null object is as a return value from a member
function that is supposed to return an object with some specified
properties but cannot find such an object.  For example, a null
"StockItem" object might be used to indicate that an item with a specified
UPC cannot be found in the inventory of a store.

Numeric Variable - A variable representing a quantity that can be
expressed as a number, whether a whole number (an integer variable) or a
number with a factional part (a floating point variable), and that can be
used in calculations such as addition, subtraction, multiplication, or
division.  The integer variable types in c++ are char, short, int, and
long.  Each of these integer types can be further subdivided into signed
and unsigned versions.  The former of these can represent both negative
and positive values (and 0), whereas the latter can represent both
negative and positive values (and 0) but provides a greater range of
positive values than the corresponding signed version does.  The floating
point variable types are float and double, which differ in their range and
precision.  Unlike the integer variable types, the floating point types
are not devided into signed and unsigned versions; all floating point
variables can represent either positive or negative numbers as wekk as 9.
See float and double for details on range and precision.


O

Object - Variable of a class type, as distinct from a variable of a native
type.  The behavior of an object is defined by the code that implements
the class to which the object belongs.  For example, a variable of type
string is an object whose behavior is controlled by the definition of the
string class.

Object code module - Result of compiling a implementation file into object
code.  A number of object code modules are combined to form an executable
program.  This is unrelation to c++ objects.

Object oriented programming - An approach to solving programming problems
by creating objects to represent the entites being handled by the program,
rather than relying solely on native data types.  This approach has the
advantage that you can match the language to the needs of the prolem
you're trying to solve.  For example, if you were writing a nurse's
station program in c++, you would want to have objects that represented
nurses, doctors, ppatients, various sorts of equipment, and so on.  Each
of these objects would display the behavior appropriate to the thing or
person it was representing.

Ofstream - A stream used for output to a file.

Op code - The part of a machine instruction that tells the CPU what kind
of instruction it is and ismetimes also specifies a register to be
operated on.

Operating System - A program that deals with the actual hardware of your
computer.  It supplies the lowest level of software inrastructure needed
to run a program.  By far the most common operating system for Intel CPU,
at present, is MS-DOS (Which is the basis for windows 95), followed by
OS/2 and WindowsNT.

Operator - Used to indicate that the following symbol is the name of a c++
operator that we are redefining, either globally or for a particular
class.  For exmaple, to redefine =, we have to specify operator = as the
name of the funcion we are writing, rather than just =, so that the
compiler does not object to seeing an operator when it expects an
identifier.

Ostream - A stream used for output.  For example, cout is a predefined
ostream that displays characters on the screen.

Output - Process of sending data from the computer to the outside world.
The most commonly used source of output for most programs is the screen.


P

Point - Essentially the same as a memory address.  The main difference
between these two concepts is that a memory address is "untyped" (it can
refer to any sort of variable), but a pointer always has an associated
data type.  For example, char* means "pointer to a char."  To say "a
variable points to a memory location" is almost exactly the same as saying
"a variable's value is the address of a memory location."  In the specific
case of a variable of type char*, to say "the char* x points to a C
string" is equivalent to saying "x contains the address of the first byte
of the C string."  See array.

Pop - Means to remove the top value from a stack.

Private - Access specifier that denies nonmember functions access to
member functions and member variables of its class.

Program - A set of instructions specifiying the solution to a set of
problems, along with the data used by those instructions.

Program counter - A dedicated register that holds the address of the next
instruction to be executed.  During a function call, a call instruction
pushes the contents of the program counter on the stack.  This enables the
called funciton to return to the calling function when finished.

Programming - Art of science of solving problems by the following
procedure:

1 - Find or invent a general solution to a set of problems.

2 - Express this solution as an algorithm or set of algorithms.

3 - Translate the algorithm's into terms so simple that a stupid machine
like a computer can follow them to calculate the specific answer for any
specific problem in the set.

Public - Access specifier that allows nonmember functions access to member
functions and member variables of its class.

Push - To add another value to a stack.


R

RAM - An acronym for Random Access Memory.  This is the working storage of
a computer, where data and programs are stored while we're using them.

Reference Argument - Another name for a variable from a calling function,
rather than an independent variable in the called function.  Changing a
reference argument therefore affects the corresponding variable in the
calling function.  Compare with value argument.

Register - A storage area that is on the same chip as the CPU itself.
Programs use registers to hold data items that are actively in use; data
in registers can be accessed within the time allocated to instruction
execution, rather than the much longer times needed to access data in RAM.

Retrieval function - A function that retrieves data, which may have been
previously stored by a storage function or may be generated when needed by
some other method such as calculation according to a formula.

Return address - Memory address of the next machine instruction in a
calling function.  It is used during execution of a return statement in a
called function to transfer execution back to the correct place in the
calling function.

Return statement - Used by a called function to transfer execution back to
the calling function.  The return statement can also specify a value of
the correct return type for the called function.  This value is made
available to the calling function to be used for further calculation.  An
example of a return statement is return 0;, it can be used to determine
what action a batch file should take next.

ROM - Acronym for Read-Only Memory.  This is the permanent internal
storage of a computer, where the programs needed to start up the computer
are stored.  As this suggests, ROM does not lose its contents when the
power is turned off, as does RAM.

Run time - Time "while a program is being executed."


S

Scalar variable - A single value (at any one time); this is contrasted
with a vector or an array, which contains a number of values each of which
is referred to by its index.

Scope - A variable is the part of the program in which the variable can be
accessed.  The scopes with which we are concerned are local, global, and
class; see local scope, global scope, and class scope for more details.

Selection sort - A sorting algorithm that select the highest (or lowest)
element from a set of elements (the "input list") and moves that selected
element to another set of elements (the "output list").  The next highest
(or lowest) element is then treated in the same manner; this operation is
repreated until as many elements as desired have been moved to the output
list.

Short - A type of integer variable that can represent a whole number.
With most c++ compilers, a short occupies 2 bytes of storage and therefore
can represent a number in either the range -32768 to 32767 (if signed) or
the range 0 - 65535 (if unsigned).

Short circuit evaluation rule - Governs the execution of the || and the &&
operators.  See || and && for details.

Side effect - Any result of calling a function that persits beyond the
execution of that function, other than its returning a return value.  For
example, writing data to file is a side effect.

Signature - A function consists of its name and the types of its
arguments.  In the case of a member function. the class to which the
function belongs is also part of its signature.  Every function is
uniquely identified by its signature, which is what makes it possible to
have more than one function with the same name; this is called function
overloading.

Signed char - A type of integer variable.  See char.

Signed int - A type of integer variable.  See int.

Signed long - A type of integer variable.  See long.

Signed short - A type of integer variable.  See short.

Signed variable - Can represent either negative or positive values.  See
char, short, int, or long.

Software - Refers to the nonphysical components of a computer, the ones
you cannot touch.  If you can install it on your hard disk, it's software.
Examples include games, word processor's, anything along those lines.

Source code - A program in a form suitable for reading and writing by a
human being.

Space - The space character is one of the nonprinting characters (or
nondisplay characters) that controls the format of displayed or printed
information.

Square brackets - [ ].  Used to enclose an array or vector index, which
selects an individual element of the array or vector.

Stack - A data structure with characteristics similar to  a springloaded
plate holder such as you might see in a cafeteria.  The last plate
deposited on the stack of plates will be the first one to be removed when
a customer needs a fresh plate; similarly, the last value deposited
(pushed) onto a stack is the first value retrieved (popped).

Stack pointer - A dedicated register.  The stack pointer is used to keep
track of the address of the most recently pushed value on the stack.

Starting expression - The part of a for statement that is executed once
before the controlled block of the for statement is first executed.  It is
often used to initialize an index variable to 0, so that the index
variable can be used to refer to the first element of an array or vector.
See for.

Statement - A complete operation understood by the c++ compiler.  Each
statement is ended with a semicolon ( ; ).

Static member rfunction - A member function of a class that can be called
without reference to an object of that class.  Such a function has no this
pointer passed to it on entry, and therefore cannot refer to member
variables of the class.

Static storage class - Simplest of the three storage classes in c++;
variables of this storage class are assigned memory addresses in the
executable program when the program is linked.

Static type checking - Refers to the practice of checking the correct
usage of variables of different types during copilation of a program
rather than during execution.  C++ uses static type checking.  See type
system.

Stepwise refinement - The process of developing an algorithm by starting
out with a "coarse" solution and "refining" it until the steps are within
the capability of the c++ language.

Storage - Synonym for memory.

Storage class - The characteristic of a variable that determines how and
when a memory address is assigned to that variable.  C++ has three
different storage classes: static, auto, and dynamic.  Please not that the
term storage class has nothing to do with the term class.  See static
storage class, auto storage class, and dynamic storage class for more
details.

Storage function - A function that stores data for later retrieval by a
retrieval function.

Stream - A place to put (in the case of an ostream) or get (in the case of
an istream) characters.  Some predefined streams are cout and cin.

String class - Defines a type of object that contains a group of chars;
the chars in a string can be treated as one unit for purposes of
assignment, I/O, and comparison.


T

Temporary variable - Automatically created by the compiler for use during
a particular operation, such as a function call with an argument that has
to be converted to a different type.

This - Reoresents a hidden argument automatically supplied by the compiler
in every member function call.  Its value during the execution of any
member function is the address of the class object for which the member
function call was made.

Token - A port of a program that the compiler treats as a separate unit.
It's analogous to a word in English; a statement is more like a sentence.
For example, string is a token, as are :: and (.  On the other hand, x =
5;, is a statement.

True - A predefined value representing the result of a conditional
expression whose condition is satisfied.  For example, in the conditional
expression x < y, if x is less than y the result of the expression will be
true.

Type - An object that is the class to which it belongs.  The type of a
native variable is one of the predefined variable types in c++.  See
integer variable, floating point variable, and bool for details on native
types.

Type system - Refers to the set of ules that the compiler uses to decide
how a variable of a given type may legally be employed.  In c++, these
determinations are made by the compiler (static type checking).  This
makes it easier to prevent type errors than it is in languages where type
checking is done during execution of the program (dynamic type checking).


U

Uninitialized variable - One that has never been set to a known value.
Attempting to use such a variable is a logical error that can cause a
program to act very oddly.

Unqualified name - A reference to a member variable that doesn't specify
which object the member variable belongs to.  When we use an unqualified
name in a member function, the copmiler assumes that the object we are
reffering to is the object for which that member function has been called.

Unsigned char - Type of integer variable.  See char.

Unsigned int - Type of integer variable.  See int.

Unsigned long - Type of integer variable.  See long.

Unisnged short - Type of integer variable.  See short.

Unsigned variable - An integer variable that represents only positive
values (and 0).  See char, short, int, and long.

User - Several meanings in programming.  The primary one is an application
programmer.  However, it can also mean library designer (in the phrase
user-defined data type) or even end user.

User defined - Data type is one that is defined by the user.  In this
context, user means "someone using language facilities to extend the range
of variable types in the language", i.e. library designer.  The primary
mechanism used to define a user-defined type is the class.


V

Value argument - A variable of local scope created when a function begins
execution.  Its initial value is et to the value of the corresponding
argument in th calling function.  Changing a value argument does not
affect any variable in the calling function.  Compare with reference
argument.

Variable - A programming construct that uses a certain part of RAM to
represent a specific item of data that we wish to keep track of in a
program.  Some examples are the weight of a pumpkin or the number of
cartons of milk in the inventory of a store.

Vector - A goup of variables that can be addressed by their position in
the group; each of these variables is called an element.  A vector has a
name, just as a regular variable does, but the elements do not.  Insread,
each element has an index which represents its position in the vector.

Void - Return type specifier in a function declaration indicates that the
function in question does not return any value when it finishes executing.


W

While Statement - A loop control statement that causes its controlled
block to be executed while a specified logical expression is true.


Z

Zero based indexing - Refers to the practice of numbering the elements of
an array or vector starting at 0 rather than 1.




Written by phooey.
Found on irc on #hackerzlair (irc.dal.net).