Question 1

Pointers, both as variables and function parameters, are used to store addresses.

Accepted Answer

Pointers are variables that store memory addresses of other variables, and when used as function parameters, they can point to the actual data rather than a copy, allowing functions to modify the original data.

Question 2

Pointers are closely associated with array names.

Accepted Answer

In C and C++, array names are often used as pointers to the first element of the array, allowing for pointer arithmetic to navigate through the array elements.

Question 3

Offsets may be included in expressions using pointers.

Accepted Answer

Offsets can be added to or subtracted from pointers to access specific memory locations relative to another address, which is a common operation in pointer arithmetic.

Question 4

If gPtr is a pointer that points to the first element of an integer array (and each integer requires four bytes of storage), *(gPtr + 4 * 4) references the variable that is four integers beyond the variable pointed to by gPtr.

Accepted Answer

The expression *(gPtr + 4) would reference the variable that is four integers beyond the variable pointed to by gPtr, not *(gPtr + 4 * 4). Adding 4 to the pointer moves it to the fifth element, as pointer arithmetic is based on the size of the pointed-to type, not byte offsets.

Question 5

When working with pointers and offsets, the correspondence between the number of bytes and number of variables is not handled by the compiler, so you must perform the conversions yourself.

Accepted Answer

The compiler automatically handles the conversion between the number of bytes and the number of variables when working with pointers and offsets, based on the data type of the pointer.

Question 6

Any subscript used by a programmer is automatically converted to an equivalent pointer expression by the compiler.

Accepted Answer

In C and C++ programming, array subscripting is essentially equivalent to pointer arithmetic. When you use a subscript to access an element of an array, the compiler automatically converts this into an equivalent pointer expression to access the same element. This conversion is based on the relationship between arrays and pointers in these languages, where the array name can be considered as a pointer to its first element.

Question 7

The parentheses in the pointer expression *(gPtr + 3) are not necessary to access the desired array element correctly.

Accepted Answer

The parentheses are necessary because the addition operation (+) has a higher precedence than the dereference operator (*). Without parentheses, the expression would attempt to dereference `gPtr` first and then add 3 to the resulting value, which is not the intended operation. The parentheses ensure that the addition is performed first, calculating the correct address, and then the dereference operator is applied to access the array element.

Question 8

The expression *(gPtr + 3) changes the address stored in gPtr.

Accepted Answer

The expression *(gPtr + 3) accesses the value at the address 3 elements beyond what gPtr points to, without changing the address stored in gPtr.

Question 9

A pointer constant is equivalent to a symbolic constant, in that the address stored in the pointer constant cannot be changed once it is set.

Accepted Answer

A pointer constant, once initialized with an address, cannot have its address changed, similar to how a symbolic constant's value cannot be changed once it is set. This immutability of the address in a pointer constant is what makes the comparison valid.

Question 10

Access to an array using a subscript can always be replaced by an equivalent access using the array name as a pointer.

Accepted Answer

Accessing an array using a subscript, like `array[index]`, is equivalent to `*(array + index)` when using the array name as a pointer. This is because array indexing is essentially pointer arithmetic in C and C++ languages.

Question 11

In every respect, an array name and a pointer can be used interchangeably.

Accepted Answer

An array name is not a variable and cannot be reassigned to point to another memory location, whereas a pointer is a variable that can be reassigned to point to different locations. Additionally, sizeof operator on an array name gives the size of the entire array, while on a pointer, it gives the size of the pointer itself.

Question 12

The address stored in the array name cannot be changed by an assignment statement.

Accepted Answer

The array name in C acts as a constant pointer to the first element of the array, and thus its address cannot be altered through assignment.

Question 13

Attempting to assign the address of an array name is invalid.

Accepted Answer

In C and C++, the name of an array is essentially a pointer to its first element, and its address is a constant value that cannot be changed. Therefore, attempting to assign a new address to the array name itself is invalid.

Question 14

A pointer access can sometimes (but not always) be replaced using subscript notation.

Accepted Answer

The answer of A pointer access can sometimes (but not...

Question 15

One advantage of using subscripts for array processing is that they are more efficient than using pointers directly.

Accepted Answer

Using pointers directly can be more efficient than using subscripts for array processing because it eliminates the need for the compiler to generate additional code to calculate the address of the element, which is what happens when subscripts are used.

Question 16

By adding numbers to and subtracting numbers from pointers, we can obtain different addresses.

Accepted Answer

Pointer arithmetic allows us to add or subtract integers from pointers, which results in moving the pointer to point to different memory addresses, typically to access different elements in an array.

Question 17

The addresses in pointers can be compared using any of the relational operators (==, !=, <, >, etc.) that are valid for comparing other variables.

Accepted Answer

In C and C++, pointers can be compared using relational operators to determine if they point to the same memory location or to establish the relative positions of the addresses they point to in memory.

Question 18

When adding or subtracting numbers to pointers, the computer automatically adjusts the number to ensure that the result still "points to" a value of the original data type.

Accepted Answer

When performing arithmetic operations on pointers, the compiler scales the integer operand by the size of the data type to which the pointer points, ensuring that pointer arithmetic results in addresses that correctly correspond to the intended data type elements.

Question 19

Addresses cannot be incremented or decremented using prefix or postfix increment and decrement operators.

Accepted Answer

In C and C++, pointers (which store addresses) can be incremented or decremented using prefix or postfix increment and decrement operators to move to the next or previous memory locations, respectively.

Question 20

When initializing pointers you must be careful to set an address in the pointer.

Accepted Answer

Initializing pointers with a valid address is crucial to avoid undefined behavior or accessing invalid memory locations.

Quiz 11: Arrays, Addresses, and Pointers