Lecture 10

Question 1

______ alerts compile that the contents of a variable or an array will not be changed by
the program

Answer 1

const

Question 2

Can a pointer be declared as a const

Answer 2

Yes, A const pointer is a pointer whose address can not be changed after initialization

Question 3

If the pointer variable is always set pointing to c?

char c = ‘X’;
char *charPtr = &c;

Answer 3

char * const charPtr = &c;

Question 4

If, the contents within the location pointed to by charPtr will not change through the pointer variable charPtr

char c = ‘X’;
char *charPtr = &c;

Answer 4

const char *charPtr = &c;

Question 5

If the pointer variable is always set pointing to c?

char c = ‘X’;
char *charPtr = &c;

Answer 5

char * const charPtr = &c;

Question 6

if both the pointer variable itself and the contents of the location it points to will not be changed through the pointer.

char c = ‘X’;
char *charPtr = &c;

Answer 6

const char * const charPtr = &c;

Question 7

Write the following statement:
You have an array of 100 integers called values and want to define a pointer variable called valuesPtr, to access the integers contained in this array

Answer 7

int values[100];
int *valuesPtr

Question 8

you must designate the pointer as pointing to the type of element that is contained in the array when ___

Answer 8

you define a pointer that is used to point to the elements of an array

Question 9

To set valuesPtr to point to the
first element in the values array,
you simply write

Answer 9

valuesPtr = values

Question 10

When do you not use the address operator

Answer 10

When the name of the
array without an address
operator is a pointer to the first
element of the array

Question 11

When we’re passing arrays to functions, why isn’t a copy being made?

Answer 11

because we are actually passing the pointer to the array

Question 12

An equivalent way of producing a pointer to the start of values is to apply the address operator to the first element of the array

Answer 12

valuesPtr =&values[0]

Question 13

Are the following statements equivalent:
valuesPtr[i] = 3; to values[i] = 3;

Answer 13

Yes, because after the initialization, (valuesPtr) points to the start of the array (values) and therefore, we can sequence through the elements of the array with the pointer variable as we would just as with the array itself

Question 14

Would (values) be considered a Pointer?

Answer 14

Yes, because the compiler gives you a const pointer variable called (values) after declaring the int array (values), that is pointing to the address of the first element of the array (the start of the array)

Question 15

Why must we use a pointer to (const char)

Answer 15

Because string literals are constants (in the initialized data section)

Question 16

What happens when you add an integer n to a pointer?

Answer 16

Adding an integer n to a pointer moves the pointer ahead by n elements of the type it points to. For example, adding n to an int* pointer moves it forward by n integer-sized elements

Question 17

If you have an int* ptr, how many spaces does adding n to the pointer move it?

Answer 17

It moves the pointer by n spaces, where each space corresponds to the size of an int. So, if ptr points to an int, ptr + n points to the n-th integer after the one ptr currently points to.

Question 17

What is the equivalent of valuesPtr[3] using pointer arithmetic and dereferencing?

Answer 17

The expression valuesPtr[3] is equivalent to *(valuesPtr + 3). Both expressions access the 4th element in the array (since indexing is 0-based).

Question 17

How can you set a pointer to point to the second element of an array using the address-of operator (&)?

Answer 17

You can set a pointer to the second element of the array using valuesPtr = &values[1];. This assigns the address of the second element of the array to the pointer.

Question 17

How can you use pointer arithmetic to access the n-th element of an array that a pointer points to?

Answer 17

You can access the n-th element by using pointer arithmetic like this: *(ptr + n). This moves the pointer n elements forward and then dereferences it to get the value at that position.

Question 17

What is the alternative way to set a pointer to the second element of an array using pointer arithmetic?

Answer 17

Instead of using the address-of operator, you can also use pointer arithmetic: valuesPtr = values + 1;. This moves the pointer from the first element to the second element by adding 1.

Question 18

How does pointer subtraction work, and what effect does it have on the pointer’s location in memory?

Answer 18

Pointer subtraction works similarly to addition but in reverse. Subtracting n from a pointer moves it backward by n elements of the type it points to, effectively moving it to earlier positions in the array

Question 19

How can the increment (++) and decrement (–) operators be used with pointers to move through an array?

Answer 19

The increment (++) operator moves the pointer to the next element in the array, while the decrement (–) operator moves it to the previous element. For example, ptr++ moves the pointer forward by one element, and ptr– moves it backward.

Question 20

What is the difference between accessing an element using valuesPtr[1] and *(valuesPtr + 1)?

Answer 20

There is no difference in functionality. Both valuesPtr[1] and *(valuesPtr + 1) access the second element in the array. The former uses array indexing, while the latter uses pointer arithmetic.

Question 20

How does valuesPtr += 2; affect where the pointer is pointing in an array?

Answer 20

It moves valuesPtr to point to the third element after the current one. If it originally pointed to the first element, it will now point to the third element.

Question 21

How can you use valuesPtr = &values[1]; to set the pointer to a specific element in the array?

Answer 21

The expression valuesPtr = &values[1]; sets valuesPtr to the address of the second element of the array, meaning it will now point to that element.

Question 22

is this a valid code?

int i1 = 0;
int *ptr = &i1;
ptr += 1

Answer 22

This is valid code, even though ptr now points to memory that the program
did not allocate.

Question 23

What would this code return if n=5?
int arraySum(int array[], const int n)
{
int sum = 0;
int *ptr;
int * const arrayEnd = array + n;
for (ptr = array; ptr < arrayEnd; ++ptr) {
sum += *ptr;
}
return sum;

Answer 23

15

Question 24

When working with pointers to functions, the C compiler needs to know the
following:

Answer 24

• the pointer variable points to a function,
• the type of value returned by that function, and
• the number and types of its arguments

Question 25

What is an in/out parameter?

Answer 25

An in/out parameter is a function parameter that serves a dual purpose: it is used to provide input to the function and also to return a value from the function. This is especially useful in C, which allows only a single return value.

Question 26

Why might a function use an in/out parameter instead of just returning a value?

Answer 26

Using an in/out parameter can be beneficial when you want the function to indicate success or failure (status indication) through the return value while still modifying additional data or values through parameters

Question 27

What is the main advantage of using pointers for in/out parameters in C?

Answer 27

The main advantage is that they allow functions to both modify data and communicate status effectively, facilitating more complex and flexible programming patterns while adhering to C’s single return value limitation.