Glossary of terms used in Chapters 1-8 and Appendix A
% operator: Modulo
operator; returns remainder in division.
! operator: Logical
operator of negation
!= operator: Relational
operator for inequality
&& operator: AND,
or conjunction, logical operator.
* operator: Operator
of multiplication, pointer declarations, or pointer dereferencing.
+ operator: Addition
operator. Overloaded to work with <int> or <float>.
- operator: Operator
of subtraction (binary) or arithmetic negation (unary).
/ operator: Arithmetic
division operator; returns quotient. Data type of integer division is
<int>; data type of a quotient involving at least one <float> is
<float>.
< operator: Less-than
relational operator.
<< operator: Inserter,
inserts a data item into an output stream. Stream appears to operator's left.
Also used as bitwise left-shift operator.
<= operator: Relational
operator for the less than or equal to condition.
= operator: Assignment
or initialization operator.
== operator: Relational
operator for equality.
> operator: Greater-than
operator.
>= operator: Greater
than or equal to operator
>> operator: Extractor;
accepts input data from an input stream (left operand) and assigns it to a
variable (right operand).
|| operator: OR, or
disjunction, relational operator
abs: The standard
function that returns the absolute value of its integer parameter.
absolute value: The
distance between a number and zero. We
write |N| for
abstract data type: A
class of data objects, associated with a set of operations that may be
performed on them.
abstraction: Consideration
of a class of things as a whole, apart from any specific instance.
ACC: Abbreviation for
a processor's accumulator register.
accumulator: Within
the central processing unit, a register (data location) that stores data copied
from a memory cell or the result of an operation on that data.
activation record: The
form for storing, on the machine stack, a set of data items passed to a
subprogram or declared within it.
Variable names then refer to these stack addresses. When the subprogram terminates, these items
cease to be accessible and in effect disappear.
actual parameter: A
data value listed as an argument in a procedure or function call. It must be of the same data type as the
formal parameter listed in the subprogram declaration. Unlike formal parameters, actual parameters
need not be identifiers.
ADD: Assembler-language
mnemonic for addition on model processor.
address: A number
specifying a location in RAM that may hold data or instructions.
address operator: &,
prefix operator that returns address of a data item
algorithm: A precise
plan to accomplish a task in a finite number of steps.
allocate: To reserve
memory space that is named by an identifier. Allocation may be <static>,
as under the <Var> heading, or <dynamic>, as when <New> is
used in executable statements.
Allocation may be static (on the stack) or dynamic (on the heap).
ALU: Arithmetic-logic
unit, a part of a microprocessor.
AND gate: The logic
gaate that accepts two inputs and outputs 1 if both inputs are 1; otherwise it
outputs 0.
AND operator: &&,
logical operator denoting conjunction
ANSI: The American
National Standards Institute, which has published an official description of
the C language.
application class: Data
type encapsulating an application program. Application programmer inherits from
the base application class to customize its response to events.
application framework: A
library of class definitions that allow programmers to build a user interface
for a program using standard tools.
applications program: A
computer program that the end user other than a programmer uses to perform a
task. It is in contrast to a system
program, which performs services for the programmer or for applications
programs.
approximation error: The
absolute difference between the value of a real number and its floating-point
representation. It is due to any
round-off required in representing the number.
architecture: The
physical organization of a computer.
argument: A data item
passed to a subprogram by placing it between parentheses after the subprogram's
name in the statement that invokes the subprogram.
arithmetic expression: An
expression formed by applying arithmetic operators to constants and variables
arithmetic operator: A
program element used to specify operations on integer or real data expressions.
The C++ arithmetic operators are unary (-) and binary (+, -, *, /, %).
arithmetic-logic unit: The
part of the central processing unit that manipulates data. It works alongside
the control unit, which directs the fetch-execute cycle and determines the
order in which instructions are carried out. The ALU executes some of the
instructions brought int
array: A data
structure named by a single identifier and composed of a number of elements,
each of the same data type, arranged one after the other in memory. An element is referred to using a subscript
value, which provides access.
ASCII: American
Standard Code for Information Interchange. A standard table of characters and
their decimal encodings.
ASCII character set: A
table of characters (letters, numbers, punctuation, and others), each with its
corresponding seven-bit number (from zero to 127).
assembler: A program
that translates from the character-based assembly language of a given
microprocessor to that processor's binary-coded machine language.
assembly language: A
low-level language, similar to binary-coded machine language in that one line
is devoted to each elementary instruction and its operands. Assembly language differs from machine
language in that it uses easily-memorized abbreviations (mnemonics) for ope
assign: To copy a data
value to a named memory location.
assignment operator: A
binary operator used in the assignment statement. A variable name precedes the operator and an expression follows
it. The value of the expression is
placed in the memory location specified by the variable name.
assignment statement: Statement
formed by a variable name, assignment operator, and expression.
atof: String-to-float
conversion function defined in math.h
atoi: String-to-integer
conversion function defined in math.h
average: The sum of a
set of numbers, divided by the number of items in the set.
Backus-Naur form: A
method for describing a language's syntax in text and symbols. It consists of productions, which are
definitions of elements of the language.
The names of the elements are enclosed by < and >. In a definition, a bracketed item is
optional. A item in
base case: In a
recursive solution, the simplest version of the problem, in which the solution
can be determined nonrecursively.
binary number system: The
base-2 system of representing numbers, in which only the digits 0 and 1
appear. Like the decimal system, the
binary system uses place values.
bit: A binary digit,
having a value of either zero or one. The bit corresponds to a miniature
two-state electronic device or magnetic storage location. It may represent a true-or-false value or
may be part of a larger data item.
black box: A hardware
or software component whose behavior we know, without knowing its internal
structure.
block diagram: A
picture that shows a hardware component with a label, but does not attempt to
show its internal structure; a
body of a loop: The
instructions carried out on each iteration of the loop. The other part of the
loop is the exit condition test.
Boolean expression: A
logical assertion; an expression whose value is either TRUE or FALSE.
Boolean operator: A
logical operator, such as !, ||, or &&.
Boolean variable: A
variable that stores the value true or false.
bottom-tested loop: A
repetition in which the exit condition is tested after the instructions inside
the loop are carried out, rather than before.
In C++, the bottom-tested loop statement is <for>.
bottom-up design: Design
that begins with components and proceeds to assemble them later
braces: The delimiters
{ and }, that begin and end a compound statement or a class or structure
definition.
brackets: The
delimiters [ and ], which surround: (1) array subscripts; (2) anonymous
subrange type definitions in array declarations; (3) a list of values in a set
enumeration.
branch: The decision,
or selection, control structure.
break statement: Unstructured
statement that causes exit from a loop or branch statement; necessary in switch
statement to separate case labels.
bulletproof: Able to
survive incorrect data input without program termination. A program that is bug-free, user-friendly
and robust must be bulletproof.
byte: A sequence of
eight binary digits (bits) taken as a data item or part of one. A byte may represent any of 2^8, or 256,
values, and it is the standard storage unit for a character.
C: Structured language
implemented in 1971
call: The execution of
a function by using its name in a program.
In machine code, a call is a jump to a subroutine, saving the address
jumped from in order to be able to jump back to that address on termination of
the subprogram.
calling statement: Statement
that invokes a function.
case label: Constant
value and colon, used to test for match with a variable in a switch statement.
case sensitivity: Distinguishing
upper-case from lower-case letters. C++
is case sensitive.
central processing unit: (CPU) The hardware element that directs all activity in the computer,
carrying out program instructions in a fetch-execute cycle. The CPU is composed of a control unit that
determines the order of execution of instructions and an arithmetic logic unit
th
char: A data type
whose values occupy eight bits (one byte) and may be displayed on machines like
the IBM PC as the ASCII character set and 128 other characters.
character constant: A
declared symbolic constant of type <char>, or a literal constant
consisting of one character surrounded by a single quotes.
chip: A silicon wafer
that uses semiconductivity to store or process data. Two kinds are microprocessor chips and RAM chips.
cin: Standard console
input stream object.
class: An object data
type, whose instances are defined by their data attributes and their behaviors.
The word <class> is also a C++ keyword.
class declaration: Introduction
of class name to a program. Syntax: <class> or <struct>, class
identifier, member item declarations in one set of braces, semicolon.
close: The member
function of standard types <ifstream> and <ofstream> that releases
a program's access to a previously-opened file for reading or writing.
close():
cohesion: Close
relationship of all aspects of a single function. Single-purpose functions are
encouraged.
comment: Text that is
inserted into a program but set off in such a way that it has no effect on
program execution. It is used by the
programmer to make clear how the program works, for the benefit of persons who
read the program code.
compile time: The
interval when a source file is being translated into object code. Syntax errors are found at compile time, logic
errors at runtime.
compiler: A program
that translates source code, written in a high-level language, such as C++,
into machine-language object code.
compiler directive: A
special kind of C++ language element that begins with "#" and is
executed by the compiler rather than translated into machine language. Example:
#include <iostream.h>.
compiler error: A
syntax error; a violation of language rules.
Compiler errors are not mistakes made by the compiler program, but those
it detects. They are distinguished from
logic errors and runtime errors.
compound statement: A
statement that consists of a pair of braces with a series of statements in
between. Implements sequence control structure.
computer: An
electronic device that executes programs, which consist of instructions to
process data and copy it into and out of the computer. What separates a computer from other tools
is that is processes information, is general purpose, and is programmable.
computer aided software engineering: The use of special software tools to analyze problems,
design software, and generate program code. Examples are diagramming tools and
code generators.
computer science: The
study of computer programming, particularly the mathematical theory involved
and the aspects of programming that are independent of particular machines,
systems or languages.
concatenate: To join
strings of characters end to end by placing one after the other in a single
data location. Standard function is
<strcat>.
condition: The Boolean
expression that follows the keyword <if> in the <if> statement, or
<while> in the <whole> or <do> statements.
conditional jump: In
machine language, an instruction to change the contents of the instruction
register, or not, depending on what is in some register such as the
accumulator. This enables a program to
implement the branch control structure.
conjunction: Expression
that is true if, and only if, both its sub-expressions are true.
const: The reserved
word that initiates the (optional) list of constant declarations. It is followed by an identifier, then an
equal sign, then an expression whose value is given to the constant, then a
semicolon.
constant: A data
element whose value does not change during program execution. Two kinds of constants are literals, such as
the numeral 6 or the string "hello", and named constants, which must
be declared using the reserved word <const>.
constructor: Initializer
module that is a member of any class and whose name is the same as the class's
control structure: A
way of ordering the execution of instructions.
Structured programming admits three control structures: sequence,
branch, and loop.
control unit: The part
of the central processing unit that determines the order in which instructions
execute. It directs the fetch-execute
cycle. The arithmetic-logic unit works
under its direction.
control variable: Data
item used to count a loop's iterations or otherwise affect exit condition.
cos: Predefined cosine
function that accepts the size of an angle in radians as a parameter and
returns the ratio between the side of a right triangle adjacent to that angle
and the hypotenuse (longest side). Defined in <math.h>.
count-controlled loop: See
<for> statement
counted loop: Loop
that iterates a predetermined number of times.
counter: A variable,
of an ordinal data type, that is used to keep track of the number of times an
event occurs. The counter in a
<for> statement is a loop-control variable.
coupling: Interdependence
of functions. Since function independence is encouraged, coupling is discouraged.
cout: Standard console
stream output object. Defined in <iostream.h>.
CPU: The
central-processing unit, the hardware item that directs all activity of a
computer.
ctype.h: Standard
library that defines character-related functions.
data: The particular
form in which information appears. Data
may or may not have meaning. It may be
digital (discrete) or analog (continuous).
The smallest unit of digital data is the bit (binary digit).
data abstraction: An
approach that focuses on logical aspects of items of a data type, particularly
what operations may be performed on them, rather than on their specific
representation.
data hiding: The
practice of concealing data not needed by a function or class; the use of
<private> data members is a form of data hiding.
data statement: A
command in a machine-language program that allocates space for data in
random-access memory and puts a data value in that space at the time the
program is loaded.
data structure: An
arrangement of related data items.
Examples are arrays, records, linked lists, and trees.
data type: A set of
values, associated with a way to represent them in binary form, and a set of
operations on these values. A data type
is an abstraction that occupies no space in memory; an item of a data type
occupies space.
data validation: Testing
of a data item to see whether it is acceptable for an operation. For example, a number representing a
person's age might be checked to see that it is between 0 and 125.
DBMS: Database
management system
debug: To find and
correct errors in a computer program.
debugger: A program
that allows the user to execute another program, interrupting it at will to
inspect values generated, such as variable values. Turbo C++ has a built-in debugger.
debugging: Finding and
fixing logic errors in programs.
decimal number system: The
standard representation of numbers in daily life, using the digits 0 to 9, with
each digit representing the product of itself and the power of ten
corresponding to its position in relation to the rightmost digit in the number.
decision control structure: The control structure that enables program execution to
proceed in one way or another, depending on conditions that can be tested by
the program. Synonyms: selection,
branch.
decision statement: In
C and C++, and <if> or <switch> statement.
declaration: A
statement that introduces an identifier to a program.
declared constant: A
storage location with a name and a value, declared using the <const>
keyword.
decrement: To reduce
by one, as with the decrement operator (--).
decrement operator: Unary
assignment operator (--) that subtracts 1 from operand variable's value.
default: A condition
or value that is assumed unless another is specified.
default keyword: Keyword
used as a case label in a <switch> statement to cover the case that no
other case label matches the selector.
definition: See
function definition
delimiter: A token
used to separate parts of a program or members of a list.
derived class: A class
that inherits from another class
desk checking: Inspecting
program design or code to decide whether it fits program specifications and
will generate a working program. It is
often more efficient than testing a program by running it.
destructor: Class
member that automatically executes when instance goes out of scope. Name is
class name preceded by '~'.
digit: In a number
system, a single symbol that stands for a number. Our decimal system has ten digits, 0 through 9.
disjunction: Logical
OR operation that is true if, and only if, at least one of its sub-expressions
is true.
disk drive: A device
that allows the computer to read or write data from a floppy disk or hard disk.
division operator: An
arithmetic operator that produces the quotient of its two operands.
do reserved word: Used
in <do…while> loop statement.
documentation: Descriptive
material that helps to use or understand a program. Two types of documentation exist: that for the user and that for
the programmer who must debug or
maintain the code.
double: High-precision
version of <float> data type
dynamic data structure: Organization
of data in which components are created in memory (new memory reserved) at the
time of program execution. Components
of dynamic data structures are linked using pointers. Examples: linked list, binary tree.
E-notation: A way to
represent real numbers in three components: a real number between 1 and 10; the
letter 'E'; a positive or negative integer signifying an exponent. If N is the real number between 1 and 10 and
M is the exponent, then the number represented by the
echo: To print on the
screen what the user has input at the keyboard.
editor: A program that
allows the user to create, save, and modify text files. A word processor is a kind of text editor.
encapsulate: To
package or place a boundary around instances of a class. A class encapsulates
properties and methods.
end-of-file: State of
affairs when all available characters have been read
end-of-file character: A
byte that occurs at the conclusion of any MS-DOS text file.
end-of-line character: A
character that normally follows a line of text in a file, normally the carriage
return and line feed characters, ASCII codes 13 and 10, in that order.
endl: Manipulator that
signifies end of line.
enumerated type: A
list of identifiers defined in a program as the set of values constituting a
data type. The type declaration uses
the format: <enum>, type name, equal sign, left brace, comma-delimited
list of identifiers, right brace, semicolon.
eof function: Standard
input-stream member function used to tell when to exit file-reading loop.
event-controlled loop: A
loop that continues executing until an occurrence in the body of the loop is
detected, signalling exit.
excess-128 exponent: Part
of the representation of a floating-point number, containing eight bits that
constitute a number 128 greater than the base-2 exponent of the number being
represented. The excess-128 exponent in
the representation of the number 4 is 128+3=1
exit condition: A
true-or-false expression inside a loop which, if true, causes execution of the
loop to stop.
exit function: Function
defined in <stdlib.h> that terminates program.
expression: A
representation of a data value in a program.
The value may be of any of several data types and the expression may
take the form of a literal constant, symbolic constant, variable, function
call,…
extractor: The
>> operator, which extracts data from an input stream and assigns it to a
variable.
false: The Boolean
value corresponding to zero or not-true.
fetch-execute cycle: A
repetitive process in which the control unit of the central processing unit
retrieves one instruction at a time from random-access memory, causes it to be
carried out, and updates the value of the program counter register. The fetch-execute cycle is ru
field: A component of
a record, which consists of two or more fields. A field may be of any data type.
The names and types of fields are specified by the record's declaration
under the TYPE heading. Within a record
type declaration, a field declaration has th
field width: Number of
screen columns allocated to an output item.
file: The form in
which data is moved to or from a disk or other device. Storage areas on the disk are linked
together logically as a single file and given a name that is used to gain
access to the data. A file is usually
of variable length and a user may cha
FILE data type: A type
embracing objects that are I/O files, each composed of items of a particular
data type. A file consisting of
integers may be accessed after declaring a file variable FP, for example:
file pointer: Data
item that references a location in a file.
flag: A boolean
variable used as a signal to indicate that a certain event has occurred in the
execution of a program.
float: Floating-point
(real-number) data type.
floating-point notation: The way of representing real numbers, using decimal points or some
indicator of where a decimal point would appear. See also E-notation.
flow of control: The
order in which a computer executes program instructions; control is said to
flow from one statement to another when first one, then the other is executed.
flowchart: A graphic
representation of the elements of a computation, showing input, output,
processing, and flow of control. A
structured flowchart contains only the control structures sequence, branch, and
loop.
for statement: Counted
loop consisting of header, with 3 expressions, and a body.
formal parameter: A
variable declared within parentheses in a subprogram header. When the subprogram is called, the formal
parameter is assigned the value of the corresponding actual parameter that is
found in the set of parentheses following the subprogram call.
formatted output: Output
whose form is controlled by manipulators or format strings.
friend class: Class
given access to another type’s private members.
fstream.h: Standard
header for file I/O classes <ofstream>, <ifstream>
ftoa: Standard
float-to-string conversion function
function: C or C++
subprogram.
function body: Compound
statement that follows function header.
function call: The
invocation of a function by use of its name and usually a parameter list within
parentheses. A function call is an
expression with a value.
function declaration: Prototype,
introducing function name to program.
function definition: Code
that spells out header and body of function.
function header: Type,
name, and parameter list in parentheses
function identifier: Name
of function, denoting its address.
get(): Input-stream
member function for character input.
getline: Standard
keyboard input function for strings.
global variable: A
variable declared in the main program block, which is therefore accessible from
that block and from any subprogram, except from subprograms that contain
declarations of local variables of the same name as the global one.
goto: Statement that
causes unconditional jump. Uses label.
grammar: The rules of
a formal language
header file: Source
file with <.h> extension. Defines classes, constants.
hexadecimal number system: A method for representing numbers in which sixteen digits
are used (0 to 9 and A to F). Since 16=
2^4, one hexademical digit corresponds to four bits. Thus an eight-bit byte may be reprsented by two hexadecimal
digits. The hexadecimal system is
therefo
hierarchy chart: A
diagram that shows the relationship among different program modules.
high-level language:
I/O: Input/output;
data communicated to or from the central processing unit via peripheral
devices.
I/O error: An
exception to normal processing at runtime, usually due to data input in an
unexpected form, such as a floating-point number when an integer is expected.
IDE: Integrated
Development Environment.
identifier: The name
for a constant, variable, data type, function, etc. Must begin with a letter
and may contain letters, digits, or underscores.
if statement: Implementation
of the branch control structure. The
statement consists of the reserved word <if>, followed by a true/false
condition in parentheses, followed by a statement. An optional extension is <else> followed by a statement.
if...else: Variant of
<if> statement.
ifstream: Standard
input stream class.
implementation: Information
about a class that is not public, such as the definitions of member functions
include directive: Preprocessor
command to read contents of a file into main source file.
increment: To add one
to.
indentation: Extra
spacing at the beginning of a line of text.
infinite loop: An
interation control structure with an exit condition that will never be
satisfied. (It has been shown that some
endless loops can be detected by examining program code, but not all.)
infinite recursion: A
state of affairs in which a subprogram will calls itself indefinitely, leading
always to a crash due to stack overflow.
This happens when the subprogram calls itself without modifying its
parameters so as to lead to an eventual non-recursive call. Inf
information: Meaningful
data, i.e., that represents knowledge.
The smallest unit of information is the bit, which denotes a yes or no
answer to a question. The word
initialization: A way
to assign a value to a data item in the same statement that declares it.
initialize: To assign
a starting value to a variable before using it.
input: Data that is
communicated from the outside world into the computer memory.
input/output: Communication
between a computer's CPU and outside devices, such as the screen, keyboard, or
printer.
instruction: A member
of a set of standard commands that may be given to a computer via a program.
instruction register: The
data-manipulation component in the central processing unit that at any time
holds the program instruction currently being executed or about to be executed.
instruction statement: An
executable command in a machine-language program. The other kind of command is a data statement.
int: The standard
integer data type.
iomanip.h: Standard
library file that supplies output-formatting functions.
ios: Base class for
all stream classes.
ios::fixed: Constant
that sets numeric output to fixed-point, rather than scientific, notation.
ios::showpoint: Standard
constant that sets numeric output to display decimal point even if data item is
an integer.
iostream.h: Standard
stream input/output header file.
IR: See instruction
register.
iteration: Repetition,
or looping. Iteration is one of the the
three control structures used in structured design or modular programming.
itoa: Standard
function that accepts integer and string parameters, assigns to string the
string representation of integer parameter.
jump instruction: A
machine-language instruction that causes a particular instruction address to be
placed in the program counter in order to change the order of execution of
instructions.
JUMP-:
JUMP0: Assembler-language
mnemonic for conditional jump on 0 in accumulator.
keyword: See reserved
word
label: A name chosen
by the programmer for an address in memory.
language: In
programming and in human communication, a system for using symbols to represent
commands, things, ideas, etc. In
mathematics, a language is any set of strings of symbols. Usually these are not enumerated one at a
time but specified by structure rules
linker: System program
that binds together separately compiled files to produce an executable
machine-language file.
load: To copy data
from memory into a processor register; also, to copy a program into memory from
secondary storage.
local identifier: A
name for a constant, type, variable, or subprogram declared within a subprogram
declaration.
local variable: An
identifier declared within a function declaration. The variable's scope is the
function and the memory space it occupies is freed up when the subprogram
terminates.
log: Standard math
function declared in <math.h>, returns logarithm of its parameter in base
e.
logarithm: The
exponent to which a base must be raised to reach a certain value. The logarithm
of 8 in base 2 is 3, because 2 to the 3rd power is 8.
logical error: A
programming mistake that causes output of incorrect results. A logical error is different from a syntax
error, which causes the compiler to output an error message instead of a
compiled program.
logical expression: Any
program element with a Boolean value.
logical operator: The
operators !, &&, and ||, which operate on Boolean expressions and yield
Boolean expressions.
long: Type qualifier
that gives an <int> item double precision.
loop: A control
structure that repeats an instruction sequence until some condition is met.
loop body: The part of
a loop separate from the exit test and exit code.
loop invariant: Assertion
that should be true at beginning of the body of an iteration structure.
low-level language: A
language whose structure is close to that recognized by a microprocessor; i.e.,
machine language or assembly language.
More sophisticated, human-like expression is possible with high-level
languages like C++..
LPT1: A standard DOS
name for the parallel printer port.
machine code: Program
statements expressed in the native language of the microprocessor.
machine language: The
set of instructions that a processor recognizes and executes; the language of
the hardware. Machine-language programs
are in the form of binary digits.
mainframe: A class of
computers in the continuum of microcomputers, minicomputers, mainframes, and
supercomputers. Each of these
categories has generally greater memory capacity and processing speed than the
previous one. The mainframe computers
of today are as po
maintain: To modify a
program after it has been put into use, in order to correct any logical errors
and to enable it to meet changing requirements.
manipulator: Any of a
set of standard functions that helps format floating-point output.
math.h: Standard
header file that declares mathematical functions.
megabyte: 2^20, or
1,048,576, bytes of data. A personal
computer is likely to have at least two megabytes of memory and 80 or more
megabytes of hard disk storage.
member function: A
subprogram associated with a class.
member item: A data
item that is a component of a structure or object.
memory: Computer data
storage capacity, especially random-access storage.
menu: A list of
options displayed on a computer screen, from which the user may choose, usually
by pressing one key.
microcomputer: A
personal computer. Microcomputers are
generally less powerful than the minicomputers, mainframes, and
supercomputers. They are in a class
with the generally more powerful workstations.
microprocessor: The
central processing unit of present-day computers, in which the circuitry is on
a single chip. Examples: 80486 (Intel),
86040 (Motorola).
minicomputer: A class
of computers more powerful than microcomputers, often used with more than one
terminal.
mnemonic: A name
(often an abbreviation) for a machine operation, which suggests what the
operation does.
module: A
self-contained component of a program, with a single purpose.
module hierarchy: The
organization of functions in a program. The top module in the hierarchy is the
one that calls others.
most significant digit: The
leftmost digit in the representation of a number, i.e., the one whose place
value is greatest.
named constant: A
memory location associated with an identifier declared under the <const>
reserved word and given a value there, which may not be changed. A named constant, or symbolic constant, is
distinguished from a literal constant.
nested if: An
<if> statement that appears within another <if> statement.
nested loop: A
repetition statement located inside the body of another loop statement.
nesting: The placement
of one control structure, subprogram declaration, or record declaration, within
another.
NOT gate: The logic
gate that outputs the logical complement of its single intput.
null statement: The
empty statement, represented by no characters.
It does nothing and its purpose is to allow us to immediately precede
and END with a semicolon; the semicolon separates the statement preceding it
from a null statement.
object: A data item of
a data type that is defined by both its data components and its behavior.
object-oriented programming: The practice of writing plans for programs with an eye to
the concepts being modeled, as defined by their data components and behaviors.
ofstream: Standard
file stream output class declared in <fstream.h>.
open(): Stream class
member function used to open a file.
operand: A symbol for
a data item to be operated on by a command.
In machine and assembly language, an operand is an address or register
reference associated with a machine instruction, indicating where the data is
that is to be manipulated or where the next inst
operation code: A
number that represents a member of a machine-language instruction set. One machine-language instruction consists of
an operation code and one or more operands, which stand for addresses or
registers.
operator: A symbol or
reserved word that appears before or between expressions or in an assignment
statement.
OR gate: The logic
gate that accepts two inputs, and outputs 1 if either of the inputs is 1;
otherwise, 0.
order of precedence: A
hierarchy of operators that determines which are applied first in an
expression, when parentheses are absent.
overloaded operator: An
operator whose meaning depends on the data types of its operands.
parameter: An
expression that is enclosed in parentheses in a subprogram call and is used as
input, and perhaps output, by the subprogram.
parameter list: One or
more data items, separated by commas, which must be present in the procedure
heading of any procedure with arguments, and also in any call to such a
procedure.
parameter passing: Language
mechanism for communicating data between functions.
pass a parameter: To
furnish a value or a variable address to a subprogram in the parenthesized part
of the subprogram call.
pass by reference: To
communicate a variable to a subprogram as a parameter via its address.
pass by value: To
communicate data to a subprogram as a parameter through its value.
peripheral device: Hardware
that is not part of the central processing unit or memory; an input/output or
secondary storage device.
pointer: A data item
that stores the memory address of another data item. Link fields in dynamic data structures are pointers, and variable
parameters are passed as pointers.
pop: To remove the top
object from a stack data structure. The
complement of POP is PUSH.
precedence rules: An
ordering of operators that specifies which apply first in evaluating an
expression with more than one.
predefined identifier: The
name for a type, constant, enumerated-type value, file variable, or subprogram
for which the compiler automatically reserves memory, so that the programmer
does not need to declare it. Examples:
Integer, MaxInt, True, Chr.
PRINT: Mnemonic for
screen output.
printf: Standard
output function defined in <stdio.h>. First parameter is format string,
others are data items to be output.
procedural abstraction: The
separation of the details of how a problem is to be solved from what is to be
accomplished as an end result.
Replacing a series of statements with a procedure call and putting the
statements in a procedure is an act of procedural abstraction.
procedural language: One
of a class of programming languages in which the programmer specifies how a
task is to be done, step by step, as opposed to higher-level, non-procedural,
languages, considered to be fourth-generation, in which the user needs to
specify only what is to
program counter: The
register in the processor that at any instant specifies the location in memory
where the next instruction to be executed is to be found.
program design: Plan
for solution to a problem.
programming: The work
of designing, coding, testing, and maintaining sequences of instructions for a
computer.
programming language: A
particular vocabulary (lexical elements), set of structure rules (syntax), and
meanings of these formal aspects (semantics), used in building computer
programs. Well-known languages include
COBOL, assembler, Pascal, and C.
prompt: A screen
display signalling to a user of a program that input is expected. The MS-DOS command prompt looks like this
when the current disk drive is A: A>.
A prompt in an application may range from a word to a sentence to a
full-screen menu.
prototype: A function
declaration, consisting of its header and a semicolon.
pseudocode: An
informal way of representing algorithms in text form without adhering to strict
grammar rules. Like flowcharts and
module diagrams, pseudocode is used in program design.
push: To place a data
item on the top of a stack data structure.
The complementary operation is Pop.
quoted string: A
sequence of characters, surrounded by double quotes, that serves as a literal
constant of the string data type.
radian: A unit
representing the size of an angle. In a
full circle there are 2 * PI radians; a radian is 57.3 degrees.
radius: The distance
between any point on a circle and the circle's center. The radius is half the diameter, and the
circumference is equal to twice the radius times.
RAM: Random-access
memory.
random access: A way
to read or write data by reaching any item directly and immediately, rather
than necessarily having to reach an item after a particular sequence of others.
randomize: A
predefined function that initializes a random-number generator to a 'seed' value
obtained from the system clock.
real number: One of a
set of numbers consisting of the integers, the rational numbers (fractions),
and the irrationals (numbers that may not be represented as the quotient of two
integers). Whereas the integers are
infinite but countable, the reals are not countable.
record: Database
component storing data about a single entity.
recursion: The use of
recurring or self-referencing structures or processes.
recursive case: In a
recursive subprogram, the case in which a function calls itself.
recursive definition: A
way of specifying the meaning of something by referring to the definition
itself, as in
reference parameter: A
parameter declared with & after the type name. It may pass data back to the
calling function.
reference, parameter passing by:
register: A short-term
storage location for data and instructions, inside the processor. Data is in registers at the time it is
manipulated. Three commonly used
registers are the program counter, the instruction register, and the
accumulator.
repetition: The loop
or iteration control structure.
representational error: A
discrepancy between the mathematical value of an expression and its internal
representation in a computer. It is due
to the limits on the ability of a binary numeral, of restricted size, to
precisely express a real number of arbitrary precision.
reserved word: A
vocabulary element in a programming language, whose use and and meaning are
restricted to the definition in the language and which may not be used as an
identifier.
return value: Mechanism
for passing a value to calling statement using the function call as an
expression.
runtime error: A kind
of error detected at the time of program execution. It is due to unexpected input or undefined operations, such as
division by zero. Compile-time errors,
on the other hand, are due to syntax violations.
scanf: Standard C
input function. First parameter is format string, others are addresses of
variables to receive values of input items. Defined in <stdio.h>.
scope: The parts of a
program that may use a particular identifier.
An identifier's scope of access is the block in which it is
declared. The scope of a global
identifier is the entire program; the scope of one declared within a subprogram
is that subprogram,
scope resolution operator: :: -- gives access to members of a class from outside.