Chapter 9

Question 1

1. What does the indirection operator do?

Answer 1

It dereferences a pointer, allowing code to work with the value that the pointer
points to.

Question 2

Look at the following code.
int x = 7;
int *iptr = &x;
What will be displayed if you send the expression *iptr to cout ? What happens if you send the
expression ptr to cout ?

Answer 2

The value 7 will be displayed if the expression *iptr is sent to cout. If the
expression iptr is sent to cout, the address of the variable x will be displayed.

Question 3

3. So far you have learned three different uses for the * operator. What are they?

Answer 3

Multiplication operator, definition of a pointer variable, and the indirection
operator

Question 4

4. What math operations are allowed on pointers?

Answer 4

Addition and subtraction.

Question 5

5. Assuming that ptr is a pointer to an int , what happens when you add 4 to ptr ?

Answer 5

It adds 4 times the size of an int to the address stored in ptr

Question 6

Look at the following array definition.
int numbers[] = { 2, 4, 6, 8, 10 };

What will the following statement display?
cout &laquo_space;*(numbers + 3) &laquo_space;endl;

Answer 6

8

Question 7

7. What is the purpose of the new operator?

Answer 7

To dynamically allocate memory.

Question 8

What happens when a program uses the new operator to allocate a block of memory, but the
amount of requested memory isn’t available? How do programs written with older compilers
handle this?

Answer 8

An exception is thrown, which causes the program to terminate. Under older
compilers, the new operator returns the null address (address 0) when it cannot
allocate the requested amount of memory.

Question 9

9. What is the purpose of the delete operator?

Answer 9

To free memory that has been dynamically allocated with the

Question 10

10. Under what circumstances can you successfully return a pointer from a function?

Answer 10

You should only return a pointer from a function if it is
* A pointer to an object that was passed into the function as an argument
* A pointer to a dynamically allocated object

Question 11

11. What is the difference between a pointer to a constant and a constant pointer?

Answer 11

A pointer to a constant points to a constant item. The data that the pointer points
to cannot change, but the pointer itself can change. With a constant pointer, it is
the pointer itself that is constant. Once the pointer is initialized with an address, it
cannot point to anything else.

Question 12

12. What are two advantages of declaring a pointer parameter as a constant pointer?

Answer 12

Not only will this protect you from writing code in the function that accidentally
changes the argument, but the function will be able to accept the addresses of both
constant and non-constant arguments.

Question 13

13. Each byte in memory is assigned a unique __________.

Answer 13

address

Question 14

14. The __________ operator can be used to determine a variable’s address.

Answer 14

address (&)

Question 15

15. _________ variables are designed to hold addresses.

Answer 15

pointer

Question 16

16. The __________ operator can be used to work with the variable a pointer points to.

Answer 16

indirection (*)

Question 17

17. Array names can be used as __________, and vice versa.

Answer 17

pointers

Question 18

18. Creating variables while a program is running is called __________.

Answer 18

dynamic memory allocation

Question 19

19. The __________ operator is used to dynamically allocate memory.

Answer 19

new

Question 20

20. Under older compilers, if the new operator cannot allocate the amount of memory requested,
    it returns ________

Answer 20

0 or null

Question 21

21. A pointer that contains the address 0 is called a(n) __________ pointer.

Answer 21

null

Question 22

22. When a program is finished with a chunk of dynamically allocated memory, it should free it
    with the __________ operator

Answer 22

delete

Question 23

23. You should only use pointers with delete that were previously used with __________.

Answer 23

new

Question 24

Look at the following code.
double value = 29.7;
double *ptr = &value;
Write a cout statement that uses the ptr variable to display the contents of the value variable.

Answer 24

cout &laquo_space;*ptr &laquo_space;endl;

Question 25

Look at the following array definition.
int set[10];
Write a statement using pointer notation that stores the value 99 in set[7];

Answer 25

*(set + 7) = 99;

Question 26

Write code that dynamically allocates an array of 20 integers, then uses a loop to allow
the user to enter values for each element of the array

Answer 26

const int SIZE = 20;
int *ptr;
ptr = new int[SIZE];
for (int i = 0; i < SIZE; i++)
{
cout &laquo_space;“Enter a value: “;
cin&raquo_space; ptr[i];
}

Question 27

Assume that tempNumbers is a pointer that points to a dynamically allocated array.
Write code that releases the memory used by the array.

Answer 27

delete [] tempNumbers;

Question 28

Look at the following function definition.
void getNumber(int &n)
{
cout &laquo_space;“Enter a number: “;
cin&raquo_space; n;
}
3
In this function, the parameter n is a reference variable. Rewrite the function so that n is a
pointer.

Answer 28

void getNumber(int *n)
{
cout &laquo_space;“Enter a number: “;
cin&raquo_space; *n;
}

Question 29

29. Write the definition of ptr , a pointer to a constant int.

Answer 29

const int *ptr;

Question 30

30. Write the definition of ptr , a constant pointer to an int.

Answer 30

int * const ptr;

Question 31

Each byte of memory is assigned a unique address.

Answer 31

true

Question 32

The * operator is used to get the address of a variable.

Answer 32

false

Question 33

Pointer variables are designed to hold addresses.

Answer 33

true

Question 34

The & symbol is called the indirection operator.

Answer 34

false

Question 35

The & operator dereferences a pointer.

Answer 35

false

Question 36

When the indirection operator is used with a pointer variable, you are actually
working with the value the pointer is pointing to

Answer 36

true

Question 37

Array names cannot be dereferenced with the indirection operator.

Answer 37

false

Question 38

when you add a value to a pointer, you are actually adding that number times the
size of the data type referenced by the pointer

Answer 38

true

Question 39

The address operator is not needed to assign an array’s address to a pointer.

Answer 39

true

Question 40

You can change the address that an array name points to.

Answer 40

false

Question 41

Any mathematical operation, including multiplication and division, may be
performed on a pointer

Answer 41

false

Question 42

Pointers may be compared using the relational operators.

Answer 42

true

Question 43

When used as function parameters, reference variables are much easier to work
with than pointers

Answer 43

true

Question 44

The new operator dynamically allocates memory.

Answer 44

true

Question 45

A pointer variable that has not been initialized is called a null pointer.

Answer 45

false

Question 46

The address 0 is generally considered unusable.

Answer 46

true

Question 47

In using a pointer with the delete operator, it is not necessary for the pointer to
have been previously used with the new operator.

Answer 47

false

Question 48

48. int ptr* = nullptr;

Answer 48

The variable should be declared as int *ptr;

Question 49

49. int x, *ptr = nullptr;
    &x = ptr;

Answer 49

The assignment statement should read ptr = &x;

Question 50

50. int x, *ptr = nullptr;
    *ptr = &x;

Answer 50

The assignment statement should read ptr = &x;

Question 51

int x, *ptr = nullptr;
ptr = &x;
ptr = 100; // Store 100 in x
cout &laquo_space;x &laquo_space;endl;

Answer 51

The assignment statement should read *ptr = 100;

Question 52

Int numbers[] = {10, 20, 30, 40, 50};
cout &laquo_space;“The third element in the array is “;
cout &laquo_space;*numbers + 3 &laquo_space;endl;

Answer 52

The last line should read
cout &laquo_space;*(numbers + 3) &laquo_space;endl;

Question 53

int values[20], *iptr = nullptr;
iptr = values;
iptr *= 2;

Answer 53

Multiplication cannot be performed on pointers.

Question 54

float level;
int fptr = &level;

Answer 54

An int pointer is being used to reference a float value

Question 55

int *iptr = &ivalue;
int ivalue;

Answer 55

iptr cannot be initialized with the address of ivalue. ivalue is defined after
iptr

Question 56

6. void doubleVal(int val)
   {
   *val *= 2:
   }

Answer 56

The * operator is used on the parameter, but it is not a pointer.

Question 57

57. int *pint = nullptr;
    new pint;

Answer 57

The second statement should read pint = new int;

Question 58

int *pint = nullptr;
pint = new int;
if (pint == nullptr)
*pint = 100;
else
cout &laquo_space;“Memory allocation error\n”;

Answer 58

The program segment is storing a value at the address 0.

Question 59

int *pint = nullptr;
pint = new int[100]; // Allocate memory
.
.
Code that processes the array.
.
.
delete pint; // Free memorY

Answer 59

The last line should read delete [] pint;

Question 60

Int *getNum()
{
int wholeNum;
cout &laquo_space;“Enter a number: “;
cin&raquo_space; wholeNum;
return &wholeNum;
}

Answer 60

The function returns the address of a variable that no longer exists.

Question 61

const int arr[] = { 1, 2, 3 };
int *ptr = arr;
const int arr[] = { 1, 2, 3 };
int *ptr = arr;

Answer 61

The pointer definition should read:
const int *ptr = array;

Question 62

void doSomething(int * const ptr)
{
int localArray[] = { 1, 2, 3 };
ptr = localArray;
}

Answer 62

The function tries to change the contents of ptr, which is a constant pointer.
During the function’s execution, the value in ptr cannot be changed.