Section 1
Preview this deck
automatic variable
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
6 years ago
Date created
Mar 1, 2020
Cards (414)
Section 1
(50 cards)
automatic variable
a variable for which memory is allocated and deallocated when control enters and exits the block in which it is declared
assignment statement
a statement that stores the value of an expression into a variable
chain
a linked list of elements that share the same hash location char a data type whose values consist of one alphanumeric character (letter, digit, or special symbol)
batch processing
a technique for entering data and executing programs without intermediate user interaction with the computer
branching control structure
selection control structure
abstraction
a model of a complex system that includes only the details essential to the perspective of the viewer of the system; the separation of the logical properties of data or actions from their implementation details
array data type
a collection of components, all of the same type, ordered on N dimensions (N >= 1); each component is accessed by N indexes, each of which represents the component's position within that dimension
Boolean expression
an assertion that is evaluated as either true or false, the only values of the Boolean data type
activation record (stack frame)
a record used at run time to store information about a function call, including the parameters, local variables, register values, and return address
ALU
arithmetic/logic unit
auxiliary storage device
a device that stores data in encoded form outside the computer's memory
assertion
a logical proposition that is either true or false
cancellation error
a form of representational error that occurs when numbers of widely differing magnitudes are added or subtracted
booting the system
the process of starting up a computer by loading the operating system into its main memory
assignment expression
a C++ expression with a value and the side effect of storing the expression value into a memory location
adjacent nodes
two nodes in a graph that are connected by an edge
binary search
a search algorithm for sorted lists that involves dividing the list in half and determining, by value comparison, whether the item would be in the upper or lower half; the process is performed repeatedly until either the item is found or it is determined that the item is not on the list
binding time
the time at which a name or symbol is bound to an address or to the appropriate code
brainstorming
the stage in an object-oriented design in which the first pass is made to determine the classes in a design
abstract data type
a data type whose properties (domain and operations) are specified independently of any particular implementation; a class of data objects with a defined set of properties and a set of operations that process the data objects while maintaining the properties
aggregate operation
an operation on a data structure as a whole, as opposed to an operation on an individual component of the data structure
base class
the class being inherited from
binary
expressed in terms of combinations of the numbers 1 and 0 only
bit
short for binary digit; a single 1 or 0
actual parameter
a variable, constant, or expression listed in the call to a function or procedure
adjacency list a
a linked list that identifies all the vertices to which a particular vertex is connected; each vertex has its own adjacency list
base address
the memory address of the first element in an array
Boolean
a data type consisting of only two values: true and false; bool in C++
call
the point at which the computer begins following the instructions in a subprogram is referred to as the subprogram call
atomic data type
a data type that allows only a single value to be associated with an identifier of that type
anonymous type
a user-defined type that does not have an identifier (a name) associated with it
binary tree
a structure with a unique starting node (the root), in which each node is capable of having two child nodes, and in which a unique path exists from the root to every other node
big-O notation
a notation that expresses computing time (complexity) as the term in a function that increases most rapidly relative to the size of a problem
byte
eight bits
branch
a code segment that is not always executed; for example, a switch statement has as many branches as there are case labels
block
In C++ a group of zero or more statements enclosed in braces body the statement(s) to be repeated within the loop; the executable statement(s) within a function
abstraction (in OOD)
the process of testing the system in its real environment with real data
central processing unit (CPU)
the part of the computer that executes the instructions (program) stored in memory; consists of the arithmetic/logic unit and the control unit
bucket
a collection of elements associated with a particular hash location
arithmetic/logic unit (ALU)
the component of the central processing unit that performs arithmetic and logical operations
assembler
a program that translates an assembly language program into machine code
character set
a standard set of alphanumeric characters with a given collating sequence and binary representation
adjacency matrix
for a graph with N nodes, an N?N table that shows the existence (and weights) of all edges in the graph
Boolean operators
operators applied to values of the type Boolean; in C++ these are the special symbols &&, ||, and !
abstract step
an algorithmic step for which some implementation details remain unspecified
base case
the case for which the solution can be stated nonrecursively
algorithm
a logical sequence of discrete steps that describes a complete solution to a given problem, computable in a finite amount of time; a step-by-step procedure for solving a problem in a finite amount of time; a verbal or written description of a logical sequence of actions
binary search tree
a binary tree in which the key value in any node is greater than the key value in its left child and any of its children (the nodes in the left subtree) and less than the key value in its right child and any of its children (the nodes in the right subtree)
assembly language
a low-level programming language in which a mnemonic represents each of the machine language instructions for a particular computer
black-box testing
testing a program or function based on the possible input values, treating the code as a "black box"
Section 2
(50 cards)
data type
the general form of a class of data items; a formal description of the set of values (called the domain) and the basic set of operations that can be applied to it data
conversion function
a function that converts a value of one type to another type so that it can be assigned to a variable of the second type; also called transfer function or type cast
clustering
the tendency of elements to become unevenly distributed in the hash table, with many elements clustering around a single hash location
composition (containment)
a mechanism by which an internal data member of one class is defined to be an object of another class type
collating sequence
the ordering of the elements of a set or series, such as the characters (values) in a character set
communication complexity
a measure of the quantity of data passing through a module's interface
coding
translating an algorithm into a programming language; the process of assigning bit patterns to pieces of information
conditional test
the point at which the Boolean expression is evaluated and the decision is made to either begin a new iteration or skip to the first statement following the loop
data coverage
black-box testing
class constructor
a special member function of a class that is implicitly invoked when a class object is defined
CRC card
(Class, Responsibility, Collaboration) a visualization technique that uses 4 ? 6 cards to represent a class
data
information that has been put into a form a computer can use
constant
an item in a program whose value is fixed at compile time and cannot be changed during execution
data abstraction
the separation of a data type's logical properties from its implementation
class
an unstructured type that encapsulates a fixed number of data components with the functions that manipulate them; the predefined operations on an instance of a class are "whole assignment" and "component access"
complete binary tree
a binary tree that is either full or full through the next-to-last level, with the leaves on the last level as far to the left as possible
constant time
an algorithm whose Big-O work expression is a constant
cursor control keys
a special set of keys on a computer keyboard that allow the user to move the cursor up, down, right, and left to any point on the screen
computer programming
the process of planning a sequence of steps for a computer to follow
client
software that declares and manipulates objects (instances) of a particular class
control structure
a statement used to alter the normally sequential flow of control
compiler
a program that translates a high-level language (such as C++, Pascal, or FORTRAN) into machine code
circular linked list
a list in which every node has a successor; the "last" element is succeeded by the "first" element
data structure
a collection of data elements whose organization is characterized by accessing operations that are used to store and retrieve the individual data elements; the implementation of the composite data members in an abstract data type
collision
the condition resulting when two or more keys produce the same hash location
constructor
an operation that builds new instances of an abstract data type (such as a list)
control abstraction
the separation of the logical properties of a control structure from its implementation
counter
a variable whose value is incremented to keep track of the number of times a process or event occurs
crash
the cessation of a computer's operations as a result of the failure of one of its components; cessation of program execution due to an error
data validation
a test added to a program or a function that checks for errors in the data
CPU
central processing unit
data encapsulation
the separation of the representation of data from the applications that use the data at a logical level; a programming language feature that enforces information hiding
clear- (white-) box testing
testing a program or function based on covering all of the branches or paths of the code
computer program
a list of instructions to be performed by a computer
compiler listing
a copy of a program into which have been inserted messages from the compiler (indicating errors in the program that prevent its translation into machine language if appropriate)
code walk-through
a verification process for a program in which each statement is examined to check that it faithfully implements the corresponding algorithmic step, and that the preconditions and postconditions of each module are preserved
computer
a programmable device that can store, retrieve, and process data
complete graph
a graph in which every vertex is directly connected to every other vertex
composite type
a data type that allows a collection of values to be associated with an object of that type
copy constructor
a special member function of a class that is implicitly invoked when passing parameters by value, initializing a variable in a declaration, and returning an object as the value of a function
control unit
the component of the central processing unit that controls the action of other components so that instructions (the program) are executed in sequence
class destructor
a special member function of a class that is implicitly invoked when a class object goes out of scope
class member
a component of a class; class members may be either data or functions
data flow
the flow of information from the calling code to a function and from the function back to the calling code
code coverage
clear- (white-) box testing
complexity
a measure of the effort expended by the computer in performing a computation, relative to the size of the computation
concrete step
a step for which the implementation details are fully specified
class object (class instance)
a variable of a class type
count-controlled loop
a loop that executes a predetermined number of times
data representation
the concrete form of data used to represent the abstract values of an abstract data type
Section 3
(50 cards)
enumerator
one of the values in the domain of an enumeration type
deskchecking
tracing an execution of a design or program on paper
execution trace
a testing procedure that involves simulating by hand the computer executing a program
dynamic data structure
a data structure that can expand and contract during program execution
event counter
a variable that is incremented each time a particular event occurs
editor
an interactive program used to create and modify source programs or data
filtering
the stage in an object-oriented design in which the classes determined during brainstorming are reexamined
flow of control
the order of execution of the statements in a program
edge (arc)
a pair of vertices representing a connection between two nodes in a graph
debugging
the process of removing known errors decision
external representation
the printable (character) form of a data value
documentation
the written text and comments that make a program easier for others to understand, use, and modify
executing
the action of a computer performing as instructed by a given program
delete
a C++ operator that returns the space allocated for a dynamic variable back to the heap to be used again
flag
a Boolean variable that is set in one part of the program and tested in another to control the logical flow of a program
file
a named area in secondary storage that is used to hold a collection of data; the collection of data itself
execution summary
a computer-generated list of all commands processed and any system messages generated during batch processing
development environment
a single package containing all of the software required for developing a program
echo printing
printing the data values input to a program to verify that they are correct
enumeration data type
a data type in which the formal description of the set of values is an ordered list of literal values
deep copy
an operation that not only copies one class object to another but also makes copies of any pointed-to data
delimiter
a symbol or keyword that marks the beginning or end of a construct (e.g., statement, comment, declaration, and parameter list)
driver
a simple dummy main program that is used to call a function being tested; a main function in an object-oriented program
decision
selection control structure
dynamic allocation
allocation of memory space for a variable at run time (as opposed to static allocation at compile time)
field identifier (member identifier in C++)
the name of a component in a record (struct)
field of a record
a component of a record data type
dynamic binding
the run-time determination of which implementation of an operation is appropriate
external file
a file that is used to communicate with people or programs and is stored externally to the program
declaration
a statement that associates an identifier with a process or object so that the user can refer to that process or object by name
expression
an arrangement of identifiers, literals, and operators that can be evaluated to compute a value of a given type
floating point number
the value stored in a type float variable, so called because part of the memory location holds the exponent and the balance of the location the mantissa, with the decimal point floating as necessary among the significant digits
dereference operator
an operator that when applied to a pointer variable denotes the variable to which the pointer points
exception report
a set of messages in a program that explains the actions taken when an invalid data item is encountered during execution
expression statement
a statement formed by appending a semicolon to an expression
demotion (narrowing)
the conversion of a value from a "higher" type to a "lower" type according to a programming language's precedence of data types. Demotion may cause loss of information
dynamic variable
a variable created during execution of a program by the new operator
fetch-execute cycle
the sequence of steps performed by the central processing unit for each machine language instruction
field member selector
the expression used to access components of a record variable; formed by using the record variable name and the field identifier, separated by a period
down
a descriptive term applied to a computer when it is not in a usable condition
external pointer
a named pointer variable that references the first node in a linked structure
exception
a situation associated with an unusual, usually unpredictable event, detectable by software or hardware, which requires special processing
directed graph (digraph)
a graph in which each edge is directed from one vertex to another (or the same) vertex
derived class
the class that inherits
event-controlled loop
a loop that terminates when something happens inside the loop body to signal that the loop should be exited
finite state machine
an idealized model of a simple computer consisting of a set of states, the rules that specify when states are changed, and a set of actions that are performed when changing states
flat implementation
the hierarchical structure of a solution written as one long sequence of steps; also called inline implementation
field
a group of character positions in a line of output
doubly linked list
a linked list in which each node is linked to both its successor and its predecessor
encapsulation (in OOD)
the bundling of data and actions in such a way that the logical properties of the data and actions are separated from the implementation details; the practice of hiding a module implementation in a separate block with a formally specified interface
Section 4
(50 cards)
inorder traversal
a systematic way of visiting all the nodes in a binary tree that visits the nodes in the left subtree of a node, then visits the node, and then visits the nodes in the right subtree of the node
input transformation
an operation that takes input values and converts them to the abstract data type representation
functional problem description
a description that clearly states what a program is to do
functional equivalence
a property of a module that performs exactly the same operation as the abstract step it defines, or when one module performs exactly the same operation as another module
functional cohesion
a property of a module in which all concrete steps are directed toward solving just one problem, and any significant subproblems are written as abstract steps
functional domain
the set of valid input data for a program or function
implementation phase
the second set of steps in programming a computer: translating (coding) the algorithm into a programming language; testing the resulting program by running it on a computer, checking for accuracy, and making any necessary corrections; using the program implementing
function type
function result type
formal parameter declaration
the code that associates a formal parameter identifier with a data type and a passing mechanism
header node
a placeholder node at the beginning of a list; used to simplify list processing
information hiding
The practice of hiding the details of a function or data structure with the goal of controlling access to the details of a module or structure; the programming technique of hiding the details of data or actions from other parts of the program
hierarchical implementation
a process in which a modular solution is implemented by subprograms that duplicate the hierarchical structure of the solution
general (recursive) case
the case for which the solution is expressed in terms of a smaller version of itself
function result
the value computed by the function and then returned to the main program; often just called the result
inheritance
a design technique used with a hierarchy of classes by which each descendant class inherits the properties (data and operations) of its ancestor class; the language mechanism by which one class acquires the properties—data and operations—of another class; a mechanism for automatically sharing data and methods among members of a class and its subclasses
in place
describes a kind of sorting algorithm in which the components in an array are sorted without the use of a second array
function result type
the data type of the result value returned by a function; often referred to simply as function type
implementing
coding and testing an algorithm
hashing
the technique used for ordering and accessing elements in a list in a relatively constant amount of time by manipulating the key to identify its location in the list
function
a subprogram in C++
input prompts
messages printed by an interactive program, explaining what data is to be entered
garbage
memory locations that can no longer be accessed
graph
a data structure that consists of a set of nodes and a set of edges that relate the nodes to each other
input
the process of placing values from an outside data set into variables in a program; the data may come from either an input device (keyboard) or an auxiliary storage device (disk or tape)
high-level programming language
any programming language in which a single statement translates into one or more machine language instructions
infinite recursion
the situation in which a subprogram calls itself over and over continuously
implementing a test plan
running the program with the test cases listed in the test plan
index
a value that selects a component of an array
information
any knowledge that can be communicated
folding
a hash method that breaks the key into several pieces and concatenates or exclusive-ORs some of them to form the hash value
homogeneous
a descriptive term applied to structures in which all components are of the same data type (such as an array)
heap
a complete binary tree, each of whose elements contains a value that is greater than or equal to the value of each of its children; see also free store
implicit matching
positional matching
formal parameter
a variable declared in a function heading
function definition
a function declaration that includes the body of the function
functional modules
in top-down design, the structured tasks and subtasks that are solved individually to create an effective program
generic data type
a type for which the operations are defined but the types of the items being manipulated are not
heuristics
assorted problem-solving strategies
hierarchy (in OOD)
structuring of abstractions in which a descendant object inherits the characteristics of its ancestors
function prototype
a function declaration without the body of the function
hardware
the physical components of a computer
formatting
the planned positioning of statements or declarations and blanks on a line of a program; the arranging of program output so that it is neatly spaced and aligned
hierarchical records
records in which at least one of the fields is itself a record
function call
an expression or statement in the main program requiring the computer to execute a function subprogram
global
a descriptive term applied to an identifier declared outside any function, so- called because it is accessible to everything that follows it
hash function
a function used to manipulate the key of an element in a list to identify its location in the list
infinite loop
a loop whose termination condition is never reached and which therefore is never exited without intervention from outside of the program
identifier
a name associated with a process or object and used to refer to that process or object
free store (heap)
a pool of memory locations reserved for dynamic allocation of data full binary tree a binary tree in which all of the leaves are on the same level and every nonleaf node has two children
inline implementation
flat implementation
Section 5
(50 cards)
interpreter
a program that inputs a program in a high-level language and directs the computer to perform the actions specified in each statement; unlike a compiler, an interpreter does not produce a machine language version of the entire program
linear time
for an algorithm, when the Big-O work expression can be expressed in terms of a constant times N, where N is the size of the problem
insertion sort
a sorting algorithm in which values are placed one at a time into their proper position within a list that was originally empty
modular programming
top-down design
memory leak
the loss of available memory space that occurs when memory is allocated dynamically but never deallocated
mantissa
with respect to floating point representation of real numbers, the digits representing a number itself and not its exponent
iteration
an individual pass through, or repetition of, the body of a loop
lifetime
the period of time during program execution when an identifier has memory allocated to it
metric based testing
testing based on measurable factors
loop control variable (LCV)
a variable whose value is used to determine whether the loop executes another iteration or exits
mainframe
a large computing system designed for high-volume processing or for use by many people at once
loop invariant
assertions about the characteristics of a loop that must always be true for a loop to execute properly; the assertions are true on loop entry, at the start of each loop iteration, and on exit from the loop, but are not necessarily true at each point in the body of the loop
microcomputer
personal computer
modularity (in OOD)
meaningful packaging of objects
loop exit
the point when the repetition of the loop body ends and control passes to the first statement following the loop
minicomputer
a computer system larger than a personal computer but smaller than a mainframe; sometimes called an entry-level mainframe
inspection
a verification method in which one member of a team reads the program or design line by line and the others point out errors
iterator
an operation that allows us to process all the components in an abstract data type sequentially
length
the actual number of values stored in a list or string
mixed mode expression
an expression that contains operands of different data types
module
a self-contained collection of steps that solves a problem or subproblem; can contain both concrete and abstract steps
local variable
a variable declared within a block; it is not accessible outside of that block
machine language
the language, made up of binary-coded instructions, that is used directly by the computer
loop test
the point at which the loop expression is evaluated and the decision is made either to begin a new iteration or skip to the statement immediately following the loop
logging on
taking the preliminary steps necessary to identify yourself to a computer so that it accepts your commands
linear probing
resolving a hash collision by sequentially searching a hash table beginning at the location returned by the hash function
integration testing
testing performed to integrate program modules that have already been independently unit tested
maintenance
the modification of a program, after it has been completed, in order to meet changing requirements or to take care of any errors that show up
leaf node
tree node that has no children
method
a function declared as a member of a class object
member selector
the expression used to access components of a struct or class variable; it is formed by using the variable name and the member name, separated by a dot (period)
loop
a method of structuring statements so that they are repeated while certain conditions are met
module nesting chart
a chart that depicts the nesting structure of modules and shows calls among them
metalanguage
a language that is used to write the syntax rules for another language
internal file
a file that is created but not saved; also called a scratch file
logging off
informing a computer—usually through a simple command—that no fur- ther commands follow
loop entry
the point at which the flow of control first passes to a statement inside a loop
logical order
the order in which the programmer wants the statements in the program to be executed, which may differ from the physical order in which they appear
iteration counter
a counter variable that is incremented with each iteration of a loop
invoke
to call on a subprogram, causing the subprogram to execute before control is returned to the statement following the call
integer number
a positive or negative whole number made up of a sign and digits (when the sign is omitted, a positive sign is assumed)
maintenance phase
period during which maintenance occurs
interface
a connecting link (such as a computer terminal) at a shared boundary that allows independent systems (such as the user and the computer) to meet and act on or communicate with each other; the formal definition of the behavior of a subprogram and the mechanism for communicating with it
logarithmic order
for an algorithm, when the Big-O work expression can be expressed in terms of the logarithm of N, where N is the size of the problem
input/output (I/O) devices
the parts of a computer that accept data to be processed (input) and present the results of that processing (output)
memory unit
internal data storage in a computer
listing
a copy of a source program, output by a compiler, containing messages to the programmer
interactive system
a system that allows direct communication between the user and the computer
literal value
any constant value written in a program
linked list
a list in which the order of the components is determined by an explicit link field in each node, rather than by the sequential order of the components in memory
Section 6
(50 cards)
pass by name
a parameter-passing mechanism in which the actual parameter is passed to a procedure as a literal character string and interpreted by a thunk
one-dimensional array
a structured collection of components of the same type given a single name; each component is accessed by an index that indicates its position within the collection
operating system
a set of programs that manages all of the computer's resources
object-based programming language
a programming language that supports abstraction and encapsulation, but not inheritance
pass by reference
pass by address
overflow
the condition that arises when the value of a calculation is too large to be represented
nested if
an if statement that is nested within another if statement
polymorphic operation
an operation that has multiple meanings depending on the type of the object to which it is bound at run time
out-of-bounds array index
an index value that, in C++, is either less than zero or greater than the array size minus one
observer
an operation that allows us to observe the state of an instance of an abstract data type without changing it
precision
a maximum number of significant digits
parameter
a literal, constant, variable, or expression used for communicating values to or from a subprogram
nodes
the building blocks of dynamic structures, each made up of a component (the data) and a pointer (the link) to the next node
pass by value
a parameter-passing mechanism in which a copy of an actual parameter's value is passed to the formal parameter
positional matching
a method of matching actual and formal parameters by their relative positions in the two parameter lists; also called relative or implicit matching
personal computer (PC)
a small computer system (usually intended to fit on a desktop) that is designed to be used primarily by a single person
object program
the machine-language version of a source program
object class (class)
the description of a group of objects with similar properties and behaviors; a pattern for creating individual objects
preconditions
assertions that must be true before a module begins execution prefix
password
a unique series of letters assigned to a user (and known only by that user) by which that user identifies himself or herself to a computer during the logging-on procedure; a password system protects information stored in a computer from being tampered with or destroyed
polymorphism
The ability to determine which of several operations with the same name is appropriate; a combination of static and dynamic binding
priming read
an initial reading of a set of data values before entry into an event-controlled loop, in order to establish values for the variables
overriding
reimplementing a member function inherited from a parent class
postfix operator
an operator that follows its operand(s)
named constant
a location in memory, referenced by an identifier, where a data value that cannot be changed is stored
overloading
giving the same name to more than one function or using the same operator symbol for more than one operation; usually associated with static binding
name precedence
the priority treatment accorded a local identifier in a block over a global identifier with the same spelling in any references that the block makes to that identifier
pointer
a simple data type consisting of an unbounded set of values, each of which addresses or otherwise indicates the location of a variable of a given type; operations defined on pointer variables are assignment and test for equality
postorder traversal
a systematic way of visiting all the nodes in a binary tree that visits the nodes in the left subtree of a node, then visits the nodes in the right subtree of the node, and then visits the node
prefix operator
an operator that precedes its operand(s)
postconditions
assertions that must be true after a module is executed
pass by address
a parameter-passing mechanism in which the memory address of the actual parameter is passed to the formal parameter; also called pass by reference
named type
a type that has an identifier (a name) associated with it
object-oriented design
a building-block design technique that incorporates abstraction, encapsulation, modularity, and hierarchy
PC
personal computer
nested control structure
a program structure consisting of one control statement (selection, iteration, or subprogram) embedded within another control statement
preorder traversal
a systematic way of visiting all the nodes in a binary tree that visits a node, then visits all the nodes in the left subtree of the node, and then visits the nodes in the right subtree of the node
output transformation
an operation that takes an instance of an abstract data type and converts it to a representation that can be output
nonlocal access
access to any identifier declared outside of its own block
peripheral device
an input, output, or auxiliary storage device attached to a computer
object-oriented programming
a method of implementation in which programs are organized as cooperative collections of objects, each of which represents an instance of some class, and whose classes are all members of a hierarchy of classes united via inheritance relationships
nybble
four bits; half of a byte
nested loop
a loop that is within another loop
nonlocal
a descriptive term applied to any identifier declared outside of a given block
named matching
explicit matching
path testing
a testing technique whereby the tester tries to execute all possible paths in a program or function
null statement
an empty statement
parameter list
a mechanism by which functions communicate with each other
path
a combination of branches that might be traversed when a program or function is executed; a sequence of vertices that connects two nodes in a graph
new
a C++ operator that returns the address of new space allocated for a dynamic variable
Section 7
(50 cards)
program verification
the process of determining the degree to which a software product fulfills its specifications
reference parameter
a formal parameter that receives the location (memory address) of the caller's actual parameter
scenarios
the stage in an object-oriented design in which the behavoir of each class is determined
scope
the region of program code where it is legal to reference (use) an identifier
right-justified
placed as far to the right as possible within a fixed number of character positions
programming language
a set of rules, symbols, and special words used to construct a program
pseudocode
a mixture of English statements and C++-like control structures that can easily by translated into a programming language
side effect
any effect of one function on another that is not part of the explicitly defined interface between them
reference type
a simple data type consisting of an unbounded set of values, each of which is the address of a variable of a given type. The only operation defined on a reference variable is initialization, after which every appearance of the variable is implicitly dereferenced
recursive definition
a definition in which something is defined in terms of a smaller version of itself
recursion
the situation in which a subprogram calls itself
regression testing
reexecution of program tests after modifications have been made in order to ensure that the program still works correctly
recursive call
a subprogram call in which the subprogram being called is the same as the one making the call
scratch file
internal file
reserved word
a word that has special meaning in a programming language; it cannot be used as an identifier
problem-solving phase
the first set of steps in programming a computer: analyzing the problem; developing an algorithm; testing the algorithm for accuracy
range of values
the interval within which values must fall, specified in terms of the largest and smallest allowable values
selection control structure
a form of program structure allowing the computer to select one among possible actions to perform based on given circumstances; also called a branching control structure
representational error
arithmetic error caused when the precision of the true result of arithmetic operations is greater than the precision of the machine
record (struct) data type
a composite data type with a fixed number of components called fields (members); the operations are whole record assignment and selection of individual fields by name
random probing
resolving a hash collision by generating pseudorandom hash values in successive applications of the rehash function
procedural abstraction
the separation of the logical properties of an action from its implementation
self-documenting code
a program containing meaningful identifiers as well as judiciously used clarifying comments
root
the top node of a tree structure; a node with no parent
shallow copy
an operation that copies one class object to another without copying any pointed-to data
sequence
a structure in which statements are executed one after another
semantics
the set of rules that gives the meaning of instruction written in a programming language
result
function result
programming
planning, scheduling, or performing a task or an event; see also computer programming
significant digits
those digits from the first nonzero digit on the left to the last nonzero digit on the right (plus any zero digits that are exact)
relative matching
positional matching
radix
the number of possibilities for each position; the digits in a number system
scope rules
the rules that determine where in a program a given identifier may be accessed, given the point at which the identifier is declared
simulation
a problem solution that has been arrived at through the application of an algorithm designed to model the behavior of physical systems, materials, or processes
run-time stack
a data structure that keeps track of activation records during the execution of a program
semihierarchical implementation
a modular solution implemented by functions in a manner that preserves the hierarchical design, except that a function used by multiple modules is implemented once, outside of the hierarchy, and called in each place it is needed
return
the point at which the computer comes back from executing a function
queue
a data structure in which elements are added to the rear and removed from the front; a "first in, first out" (FIFO) structure
relational operators
operators that state that a relationship exists between two values; in C++, symbols that cause the computer to perform operations to verify whether the indicated relationship exists
robust
a descriptive term for a program that can recover from erroneous inputs and other errors and keep running
responsibility algorithms
the stage in an object-oriented design in which algorithms are written for each of the responsibilities outlined on the CRC cards
program validation
the process of determining the degree to which software fulfills its intended purpose
refinement
in top-down design, the expansion of a module specification to form a new module that solves a major step in the computer solution of a problem
robustness
the ability of a program to recover following an error; the ability of a program to continue to operate within its environment
secondary storage device
auxiliary storage device
self
the instance object (class) used in the invocation of a method
quadratic probing
resolving a hash collision by using the rehashing formula (Hash- Value ? I 2) % array-size, where I is the number of times that the rehash function has been applied
recursive case
general case
real number
real number
sentinel
a special data value used in certain event-controlled loops as a signal that the loop should be exited
Section 8
(50 cards)
temporary file
a file that exists only during the execution of a program
sorting
arranging the components of a list in order (for instance, words in alphabetical order, numbers in ascending or descending order)
stack frame
activation record
tail recursion
a recursive algorithm in which no statements are executed after the return from the recursive call
source program
a program written in a high-level programming language
string
a collection of characters that is interpreted as a single data item; in C++, a null-terminated sequence of characters stored in a char array
software life cycle
the phases in the life of a large software project including requirements analysis, specification, design, implementation, testing, and maintenance
team programming
the use of two or more programmers to design a program that would take one programmer too long to complete
syntax
the formal rules governing how valid instructions (constructs) are written in a programming language
unary operator
an operator that has just one operand
stepwise design
top-down design
trailer node
a placeholder node at the end of a list; used to simplify list processing
size (of an array)
the physical space reserved for an array
software engineering
the application of traditional engineering methodologies and techniques to the development of software
stepwise refinement
top-down design
style
the individual manner in which computer programmers translate algorithms into a programming language
standardized
made uniform; most high-level languages are standardized, as official descriptions of them exist
static variable
a variable for which memory remains allocated throughout the execution of the entire program
test plan implementation
using the test cases specified in a test plan to verify that a program outputs the predicted results
text file
a file in which each component is a character; each numeric digit is represented by its code in the collating sequence
traverse a list
to access the components of a list one at a time from the beginning of the list to the end
transfer function
conversion function
type coercion
an automatic conversion of a value of one type to a value of another type
underflow
the condition that arises when the value of a calculation is too small to be represented
software
computer programs; the set of all programs available on a computer
transformer
an operation that builds a new value of an ADT, given one or more previous values of the type
testing
checking a program's output by comparing it to hand-calculated results; running a program with data sets designed to discover any errors
test plan
a document that specifies how a program is to be tested
testing the state of a stream
the act of using a C++ stream variable in a logical expression as if it were a Boolean variable; the result is true if the last I/O operation on that stream succeeded, and false otherwise
test driver
driver
system software
a set of programs—including the compiler, the operating system, and the editor—that improves the efficiency and convenience of the computer's processing
undirected graph
a graph in which the edges have no direction
two-dimensional array
a collection of components, all of the same type, structured in two dimensions; each component is accessed by a pair of indexes that represent the component's position within each dimension
type definition
the association of a type identifier with the definition of a new data type
stack underflow
the condition resulting from trying to pop an empty stack
termination condition
the condition that causes a loop to be exited
stack overflow
the condition resulting from trying to push an element onto a full stack
template
a C++ language construct that allows the compiler to generate multiple versions of a class type or a function by allowing parameterized types
top-down design
a technique for developing a program in which the problem is divided into more easily handled subproblems, the solutions of which create a solution to the overall problem; also called stepwise refinement and modular programming
software piracy
the unauthorized copying of software for either personal use or use by others
stable sort
a sorting algorithm that preserves the order of duplicates
stack
an abstract data type in which elements are added and removed from only one end; a "last in, first out" (LIFO) structure
static binding
the compile-time determination of which function to call for a particular objec
stub
a dummy function that assists in testing part of a program; it has the same function that would actually be called by the part of the program being tested, but is usually much simpler
type cast
conversion function
subprogram
function
unit testing
testing a module or function by itself
switch expression
the expression in a switch statement whose value determines which case label is selected; it cannot be a floating point expression
supercomputer
the most powerful class of computers
unstructured data type
a collection consisting of components that are not organized with respect to one another
Section 9
(14 cards)