Cop 3014 Final

Front 1

member function substr() for

Back 1

retrieving a substring from a string.
The new result is a new string object that is copied from the source string.

Front 2

10 int main()
11 {
12 string string1( ”The airplane landed on time.” );
13
14 // retrieve substring ”plane” which
15 // begins at subscript 7 and consists of 5 characters
16 cout << string1.substr( 7, 5 ) << endl;

does what?

Back 2

It is using a substring function to display the string at line 16

Front 3

Pointer variables contain memory ____ as their values.

Back 3

addresses as their values.

Front 4

Normally, a variable directly contains a specific value. However, a pointer contains the memory address of a variable that, in turn, contains a

Back 4

specific value.

Front 5

a pointer _______references a value

Back 5

indirectly

Front 6

a variable name ______references a value

Back 6

directly

Front 7

Referencing a value through a pointer is often called

Back 7

indirection

Front 8

Pointers, like any other variables, must be ______before they can be used.

Back 8

declared

for example

int *countPtr, count;

declares the variable countPtr to be of type int

Front 9

Each variable being declared as a pointer must be preceded by an

Back 9

asterisk (*)

Front 10

double *xPtr, *yPtr;

indicates?

Back 10

indicates that both xPtr and yPtr are pointers to double values.

Front 11

Although it is not a requirement, including the letters ___ in pointer variable names makes it clear that these variables are pointers and that they must be handled accordingly.

Back 11

Ptr

Front 12

Pointers should be initialized either when they are

Back 12

declared or in an assignment.

Front 13

A pointer may be initialized to

Back 13

0, NULL or an address of the corresponding type.

Front 14

A pointer with the value 0 or NULL points to nothing and is known as a

Back 14

null pointer.

Front 15

Symbolic constant NULL is defined in header file _______ to represent the value 0.

Back 15

<iostream>

Front 16

Initializing a pointer to NULL is equivalent to initializing a pointer to

Back 16

0

Front 17

The value 0 is the only integer value that can be assigned directly to a pointer variable without first casting the

Back 17

integer to a pointer type.

Front 18

The address operator ____ is a unary operator that obtains the memory address of its operand

Back 18

(&)

Front 19

When declaring a reference, the & is part of the

Back 19

type

Front 20

something to which a value can be assigned, such as a variable name or a reference

Back 20

lvalue

Front 21

the address operator cannot be applied

Back 21

to constants or to expressions that do not result in references.

Front 22

The * operator, commonly referred to as the

Back 22

indirection operator or dereferencing operator

Front 23

The * operator (indirection operator or dereferencing operator) returns what?

Back 23

returns a synonym (i.e., an alias or a nickname) for the object to which its pointer operand points.

Front 24

int y = 5;
int *yPtr;
yPtr = &y;

the statement

cout << *yPtr << endl;

prints the ?

Back 24

prints the value of variable y, namely, 5, just as the statement

cout << y << endl;

Front 25

cout << *yPtr << endl;

Using * in this manner is called

Back 25

dereferencing a pointer.

Front 26

a dereferenced pointer may also be used on the left side of an assignment statement, as in

*yPtr = 9;

which would

Back 26

which would assign 9 to y

Front 27

Dereferencing a pointer that has not been properly initialized or that has not been assigned to point to a specific location in memory could cause

Back 27

a fatal execution-time error, or it could accidentally modify important data and allow the program to run to completion, possibly with incorrect results.

Front 28

There are three ways in C++ to pass arguments to a function—

Back 28

pass-by-value, pass-by-reference with reference arguments and pass-by-reference with pointer arguments.

Front 29

In C++, programmers can use pointers and the indirection operator (*) to accomplish

Back 29

pass-by-reference

Front 30

When calling a function with an argument that should be modified, the address of the argument is passed. This is normally accomplished by

Back 30

This is normally accomplished by applying the address operator (&) to the name of the variable whose value will be modified.

Front 31

arrays are not passed using operator &, because

Back 31

the name of the array is the starting location in memory of the array

Front 32

Not dereferencing a pointer when it is necessary to do so to obtain the value to which the pointer points is an

Back 32

error.

Front 33

A function receiving an address as an argument must define

Back 33

a pointer parameter to receive the address.

Front 34

Always award a function enough access to the data in its parameters to accomplish its specified task, but

Back 34

no more.

Front 35

The size of the array is used in the function body to determine the highest subscript of the array so the loop can terminate when the printing completes. The size of the array does not change in the function body, so

Back 35

it should be declared const.

Front 36

the array is only being printed, it, too, should be declared ____.

This is important because

Back 36

const

This is especially important because an entire array is always passed by reference and could easily be changed in the called function.

Front 37

If a value does not (or should not) change in the body of a function to which it is passed, the parameter should be declared ----- to ensure that it is not accidentally modified.

Back 37

const

Front 38

There are four ways to pass a pointer to a function:

Back 38

a nonconstant pointer to nonconstant data, a nonconstant pointer to constant data , a constant pointer to nonconstant data and a constant pointer to constant data (

Front 39

The highest access is granted by

Back 39

a nonconstant pointer to nonconstant data

Front 40

in a nonconstant pointer to nonconstant data

The declaration for such a pointer does not include _____

Back 40

the data can be modified through the dereferenced pointer, and the pointer can be modified to point to other data.


const

Front 41

nonconstant pointer to nonconstant data pointer can used to receive a ______ ______ ______ in a function that changes the pointer to process ( and possibly modify) each character of the string.

Back 41

null-terminated string

Front 42

A nonconstant pointer to constant data is a pointer that can be modified to point to any data item of the appropriate type, but the

Back 42

data to which it points cannot be modified through that pointer.

Front 43

A nonconstant pointer to constant data might be used to

Back 43

receive an array argument to a function that will process each element of the array, but should not be allowed to modify the data.

Front 44

A constant pointer to nonconstant data is a

Back 44

pointer that always points to the same memory location; the data at that location can be modified through the pointer.

An example would be an array name.

Front 45

A constant pointer to nonconstant data can be used to receive an array as an

Back 45

argument to a function that accesses array elements using array subscript notation.

Front 46

The least amount of access privilege is granted by a

Back 46

constant pointer to constant data.

Front 47

C++ provides the unary operator ______ to determine the size of an array (or of any other data type, variable or constant) in bytes during program compilation.

Back 47

sizeof

Front 48

When applied to the name of an array, the sizeof operator returns the total number of bytes in the array as a value of type _____

Back 48

size_t

Front 49

size_t is

Back 49

an unsigned integer type that is at least as big as unsigned int

Front 50

Operator sizeof can be applied to

Back 50

any expression or type name.

Front 51

When sizeof is applied to a variable name (which is not an array name) or other expression, the number of

Back 51

bytes used to store the specific type of the expression’s value is returned.

Front 52

sizeof is an operator, not a function, and that it has its effect at

Back 52

at compile time, not execution time.

Front 53

Pointers are valid operands in



but

Back 53

arithmetic expressions, assignment expressions and comparison expression

not all the operators normally used in these expressions are valid with pointer variables.

Front 54

Several arithmetic operations may be performed on pointers. A pointer may be

Back 54

incremented (++) or decremented (--), an integer may be added to a pointer (+ or +=), an integer may be subtracted from a pointer (- or -=) or one pointer may be subtracted from another of the same type.

Front 55

When an integer is added to, or subtracted from, a pointer, the pointer is not simply incremented or decremented by that integer, but by that integer times the

Back 55

the size of the object to which the pointer refers.

Front 56

The number of bytes depends on the object’s data type. For example, the statement

vPtr += 2;

would produce

Back 56

3008 (3000 + 2 * 4), assuming that an int is stored in four bytes of memory.

Front 57

Each of the statements

++vPtr;
vPtr++;

Back 57

increments the pointer to point to the next element of the array.

Front 58

Each of the statements

--vPtr;
vPtr--;

Back 58

decrements the pointer to point to the previous element of the array.

Front 59

Pointer variables pointing to the same ____ may be subtracted from one another.

Back 59

array

Front 60

Using pointer arithmetic on a pointer that does not refer to an array of values is a .

Back 60

logic error

Front 61

Subtracting or comparing two pointers that do not refer to elements of the same array is a

Back 61

logic error.

Front 62

A pointer can be assigned to another pointer if both pointers are of the same type. Otherwise, a

Back 62

cast operator must be used to convert the value of the pointer on the right of the assignment to the pointer type on the left of the assignment.

Front 63

All pointer types can be assigned to a pointer of type void *

Back 63

without casting.

Front 64

a pointer of type void * cannot be assigned directly to a pointer of another type—the pointer of type void * must first be

Back 64

cast to the proper pointer type.

Front 65

A void * pointer cannot be

Back 65

dereferenced.

Front 66

Pointers can be compared using .

Back 66

equality and relational operators

comparisons using relational operators are meaningless unless the pointers point to members of the same array.

Front 67

Arrays and pointers are intimately related in C++ and may be used almost .

Back 67

interchangeably

Front 68

An array name can be thought of as a

Back 68

constant pointer.

Front 69

Pointers can be used to do any operation involving

Back 69

array subscripting.

Front 70

Array element b[ 3 ] can alternatively be referenced with the pointer expression

*( bPtr + 3 )

The 3 in the preceding expression is the

Back 70

offset to the pointer.

Front 71

When the pointer points to the beginning of an array, the offset indicates which element of the array should be

Back 71

referenced, and the offset value is identical to the array subscript.


known as the pointer/offset notation

Front 72

Pointers can be subscripted exactly as arrays can. For example, the expression

bPtr[ 1 ]

refers to the array element b[ 1 ]; this expression uses

Back 72

pointer/subscript notation.

Front 73

an array name is a

Back 73

constant pointer

Front 74

an array name is a constant pointer; it always

Back 74

it always points to the beginning of the array.

Front 75

pointers can be modified in arithmetic expressions, array names

Back 75

cannot be modified in arithmetic expressions because array names are constant pointers

Front 76

Arrays may contain pointers. A common use of such a data structure is to form an array of pointer-based strings, referred to simply as a

Back 76

string array.

Front 77

each entry in an array of strings is simply a pointer to the

Back 77

first character of a string.

Front 78

String arrays are commonly used with ________ that are passed to function main when a program begins execution.

Back 78

command-line arguments

Front 79

type-safe I/O.

Back 79

Each I/O operation is executed in a manner sensitive to the data type. If an I/O member function has been defined to handle a particular data type, then that member function is called to handle that data type. If there is no match between the type of the actual data and a function for handling that data type, the compiler generates an error

Thus, improper data cannot “sneak” through the system (as can occur in C, allowing for some subtle and bizarre errors).

Front 80

Low-level I/O capabilities (i.e., unformatted I/O) specify that some number of bytes should be

Back 80

transferred device-to-memory or memory-to-device.

In such transfers, the individual byte is the item of interest

Front 81

low-level I/O capabilities provide

Back 81

high-speed, high-volume transfers but are not particularly convenient for programmers.

Front 82

Programmers generally prefer a higher-level view of I/O (i.e., formatted I/O), in which bytes are

Back 82

grouped into meaningful units, such as integers, floating-point numbers, characters, strings and user-defined types.

Front 83

use unformatted I/O for the

Back 83

best performance in high-volume file processing.

Front 84

Using unformatted I/O can lead to portability problems, because

Back 84

unformatted data is not portable across all platforms.

Front 85

classic stream libraries enabled input and output of chars. Because a char normally occupies one byte, it can represent

Back 85

only a limited set of characters (such as those in the ASCII character set).