Use LEFT and RIGHT arrow keys to navigate between flashcards;
Use UP and DOWN arrow keys to flip the card;
H to show hint;
A reads text to speech;
65 Cards in this Set
- Front
- Back
unary
|
one operand
|
|
binary
|
two operands
|
|
ternary
|
three operands
|
|
infix
|
appearing between their operands
|
|
prefix
|
appearing before the operand
|
|
postfix
|
appearing after the operand
|
|
operator precedence
|
define the order in which operators at different precedence levels are evaluated
|
|
identity operator
|
Unary plus is called the _ _
|
|
associativity
|
rules which determine which operator is evaluated first, during occurrence of adjacent operators with same precedence
|
|
side effect
|
when an operator or function call performs some other action in addition to returning a value
|
|
referential transparency
|
A program has the property of _ _ if any two expressions with the same value can be substituted for each other without affecting the programs behavior
|
|
operator overloading
|
allowing an operator to have multiple meanings
|
|
narrowing conversion
|
converts a value to a type that cannot store even approximations of all the values of the original type eg float to int
|
|
widening conversion
|
converts a value to a type that can include at least approximations of all the values of the original type eg int to float
|
|
mixed-mode expressions
|
expressions containing different data types
|
|
cast
|
Explicit type conversions are called _
|
|
overflow
|
result of an operation is too large to store in the designated memory
|
|
underflow
|
result of an operation is too small to represent
|
|
exception
|
run time error
|
|
relational operator
|
A _ _ compares the values of its two operands
|
|
short-circuit evaluation
|
value of an expression is determined without evaluating all of its subexpressions
|
|
compound assignment operator
|
combines assignment with some other operation
|
|
control statements
|
statements that provide the two capabilities : repeatedly execute sequences of statements and select from alternative control flow paths
|
|
control structure
|
control statement + collection of statements whose execution it controls
|
|
selection statement
|
provides a way of choosing between two or more execution paths in a program
|
|
multiple selection construct
|
allows the selection of one of any number of statements or statement groups
|
|
else-if clauses
|
provide for options to appear inside an if stmt
|
|
iterative statement/loop
|
causes a statement or collection of statements to be executed zero, one or more times
|
|
body
|
_ of a loop is the collection of statements whose execution is controlled by an iterative stmt
|
|
iteration construct
|
the iterative stmt together with the associated loop body
|
|
pretest
|
A _ loop tests the condition for loop completion before the loop body is executed
|
|
posttest
|
A _ loop tests the condition for loop completion after the loop body is executed
|
|
loop variable
|
A counter-controlled loop has a _ _ in which the count is stored.
|
|
loop parameters
|
Initial value of the loop variable Terminal value of the loop variable Step size—the difference between sequential values of the loop variable
|
|
iteration count
|
The loop parameters are evaluated at the beginning of the execution of the DO statement, and the values are used to compute an _ _.
|
|
iterator
|
a function that can visit each element of a data structure.
|
|
unconditional branch statement
|
or goto, transfers control to a specified location in a program.
|
|
subprogram definition
|
describes the interface to a subprogram as well as the actions of the subprogram.
|
|
subprogram call
|
is an explicit request that a subprogram be executed.
|
|
subprogram header
|
the first line of a definition
|
|
parameter profile
|
of a subprogram is the number, order, and types of its formal parameters.
|
|
protocol
|
of a subprogram is its parameter profile plus, if it is a function, its return type.
|
|
prototype
|
Function declarations are called _ in C and C++. Such declarations are often placed in header files.
|
|
formal parameters
|
Parameters in a subprogram header are called _ _.
|
|
actual parameters
|
A subprogram call specifies the name of the subprogram and a list of _ _ to be bound to the subprogram’s formal parameters.
|
|
positional parameters
|
In nearly all languages, the correspondence between actual and formal parameters is done by position: The first actual parameter is bound to the first formal parameter and so forth. Such parameters are called _ _.
|
|
keyword parameters
|
_ _, in which names of formal parameters are explicitly connected with actual parameters.
|
|
in mode
|
parameter in which data is received from the corresponding actual parameter.
|
|
out mode
|
parameter in which data is sent to the actual parameter.
|
|
inout mode
|
parameter in which data is both sent and received.
|
|
pass-by-value
|
The value of the actual parameter is used to initialize the corresponding formal parameter, which then serves as a local variable. _ is normally implemented by copy, since data accesses often are more efficient.
|
|
pass-by-result
|
_ is an implementation model for out-mode parameters. A _ formal parameter behaves like a local variable. Just before control returns to the caller, the parameter’s value is copied to the caller’s actual parameter. _ requires that the actual parameter be a variable.
|
|
pass-by-value-result
|
_ is a combination of pass-by-value and pass-by-result. It is an implementation model for inout-mode parameters in which actual values are moved. With _, the value of the actual parameter is used to initialize the formal parameter, which then acts as a local variable. At subprogram termination, the value of the formal parameter is sent back to the actual parameter.
|
|
pass-by-copy
|
Pass-by-value-result is sometimes called _ because the actual parameter is copied to the formal parameter at subprogram entry and then copied back at subprogram termination.
|
|
pass-by-reference
|
_ is a second implementation model for inout-mode parameters. _ transmits an access path, usually just an address, to the called subprogram. Pass-by-reference allows the called subprogram to access the actual parameter in the caller. In effect, the actual parameter is shared with the called subprogram. The advantage of pass-by-reference is its time and space efficiency. Duplicate space is not required, nor is any copying.
|
|
pass-by-name
|
_ is an inout-mode parameter transmission method that does not correspond to a single implementation model. With pass-by-name, the actual parameter is, in effect, textually substituted for each occurrence of the corresponding formal parameter. Normally, formal parameters are bound to actual values or addresses at the time of the subprogram call.
|
|
shallow binding
|
When a sub-program is passed as a parameter, what referencing environment should be used for executing the passed subprogram? The environment of the statement that calls the passed subprogram
|
|
deep binding
|
When a sub-program is passed as a parameter, what referencing environment should be used for executing the passed subprogram? The environment in which the passed subprogram was defined
|
|
ad hoc binding
|
When a sub-program is passed as a parameter, what referencing environment should be used for executing the passed subprogram? The environment of the call that passed the subprogram as an actual parameter
|
|
overloaded subprogram
|
An overloaded subprogram is a subprogram that has the same name as another subprogram in the same scope.
|
|
polymorphic
|
A _ subprogram will accept parameters of different types during different calls.
|
|
ad hoc polymorphism
|
Overloaded subprograms provide a kind of polymorphism called _ _ _. However, there is no guarantee that subprograms with the same name behave similarly.
|
|
parametric polymorphism
|
Parametric polymorphism is provided by a subprogram that takes generic parameters describing the types of the subprogram’s parameters. Different instantiations of the subprogram can be given different generic parameters.
|
|
generic
|
Parametrically polymorphic subprograms are often called _ subprograms.
|
|
generic units
|
Ada allows the creation of multiple versions of a program unit, with each version accepting parameters of different types. Program units of this sort are sometimes called _ units.
|