Plc Final Exam

Front 1

unary

Back 1

one operand

Front 2

binary

Back 2

two operands

Front 3

ternary

Back 3

three operands

Front 4

infix

Back 4

appearing between their operands

Front 5

prefix

Back 5

appearing before the operand

Front 6

postfix

Back 6

appearing after the operand

Front 7

operator precedence

Back 7

define the order in which operators at different precedence levels are evaluated

Front 8

identity operator

Back 8

Unary plus is called the _ _

Front 9

associativity

Back 9

rules which determine which operator is evaluated first, during occurrence of adjacent operators with same precedence

Front 10

side effect

Back 10

when an operator or function call performs some other action in addition to returning a value

Front 11

referential transparency

Back 11

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

Front 12

operator overloading

Back 12

allowing an operator to have multiple meanings

Front 13

narrowing conversion

Back 13

converts a value to a type that cannot store even approximations of all the values of the original type eg float to int

Front 14

widening conversion

Back 14

converts a value to a type that can include at least approximations of all the values of the original type eg int to float

Front 15

mixed-mode expressions

Back 15

expressions containing different data types

Front 16

cast

Back 16

Explicit type conversions are called _

Front 17

overflow

Back 17

result of an operation is too large to store in the designated memory

Front 18

underflow

Back 18

result of an operation is too small to represent

Front 19

exception

Back 19

run time error

Front 20

relational operator

Back 20

A _ _ compares the values of its two operands

Front 21

short-circuit evaluation

Back 21

value of an expression is determined without evaluating all of its subexpressions

Front 22

compound assignment operator

Back 22

combines assignment with some other operation

Front 23

control statements

Back 23

statements that provide the two capabilities : repeatedly execute sequences of statements and select from alternative control flow paths

Front 24

control structure

Back 24

control statement + collection of statements whose execution it controls

Front 25

selection statement

Back 25

provides a way of choosing between two or more execution paths in a program

Front 26

multiple selection construct

Back 26

allows the selection of one of any number of statements or statement groups

Front 27

else-if clauses

Back 27

provide for options to appear inside an if stmt

Front 28

iterative statement/loop

Back 28

causes a statement or collection of statements to be executed zero, one or more times

Front 29

body

Back 29

_ of a loop is the collection of statements whose execution is controlled by an iterative stmt

Front 30

iteration construct

Back 30

the iterative stmt together with the associated loop body

Front 31

pretest

Back 31

A _ loop tests the condition for loop completion before the loop body is executed

Front 32

posttest

Back 32

A _ loop tests the condition for loop completion after the loop body is executed

Front 33

loop variable

Back 33

A counter-controlled loop has a _ _ in which the count is stored.

Front 34

loop parameters

Back 34

Initial value of the loop variable Terminal value of the loop variable Step size—the difference between sequential values of the loop variable

Front 35

iteration count

Back 35

The loop parameters are evaluated at the beginning of the execution of the DO statement, and the values are used to compute an _ _.

Front 36

iterator

Back 36

a function that can visit each element of a data structure.

Front 37

unconditional branch statement

Back 37

or goto, transfers control to a specified location in a program.

Front 38

subprogram definition

Back 38

describes the interface to a subprogram as well as the actions of the subprogram.

Front 39

subprogram call

Back 39

is an explicit request that a subprogram be executed.

Front 40

subprogram header

Back 40

the first line of a definition

Front 41

parameter profile

Back 41

of a subprogram is the number, order, and types of its formal parameters.

Front 42

protocol

Back 42

of a subprogram is its parameter profile plus, if it is a function, its return type.

Front 43

prototype

Back 43

Function declarations are called _ in C and C++. Such declarations are often placed in header files.

Front 44

formal parameters

Back 44

Parameters in a subprogram header are called _ _.

Front 45

actual parameters

Back 45

A subprogram call specifies the name of the subprogram and a list of _ _ to be bound to the subprogram’s formal parameters.

Front 46

positional parameters

Back 46

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 _ _.

Front 47

keyword parameters

Back 47

_ _, in which names of formal parameters are explicitly connected with actual parameters.

Front 48

in mode

Back 48

parameter in which data is received from the corresponding actual parameter.

Front 49

out mode

Back 49

parameter in which data is sent to the actual parameter.

Front 50

inout mode

Back 50

parameter in which data is both sent and received.

Front 51

pass-by-value

Back 51

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.

Front 52

pass-by-result

Back 52

_ 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.

Front 53

pass-by-value-result

Back 53

_ 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.

Front 54

pass-by-copy

Back 54

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.

Front 55

pass-by-reference

Back 55

_ 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.

Front 56

pass-by-name

Back 56

_ 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.

Front 57

shallow binding

Back 57

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

Front 58

deep binding

Back 58

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

Front 59

ad hoc binding

Back 59

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

Front 60

overloaded subprogram

Back 60

An overloaded subprogram is a subprogram that has the same name as another subprogram in the same scope.

Front 61

polymorphic

Back 61

A _ subprogram will accept parameters of different types during different calls.

Front 62

ad hoc polymorphism

Back 62

Overloaded subprograms provide a kind of polymorphism called _ _ _. However, there is no guarantee that subprograms with the same name behave similarly.

Front 63

parametric polymorphism

Back 63

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.

Front 64

generic

Back 64

Parametrically polymorphic subprograms are often called _ subprograms.

Front 65

generic units

Back 65

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.