Question

For each of the following, write C++ statements that perform the specified task. Assume that double-precision, floating-point numbers are stored in eight bytes and that the starting address of the array is at location 1002500 in memory. Each part of the exercise should use the results of previous parts where appropriate. a. Declare an array of type double called numbers with 10 elements, and initialize the elements to the values 0.0, 1.1, 2.2, ..., 9.9. Assume that the symbolic constant SIZE has been defined as 10. b. Declare a pointer nPtr that points to a variable of type double. c. Use a for statement to print the elements of array numbers using array subscript notation. Print each number with one position of precision to the right of the decimal point. d. Write two separate statements that each assign the starting address of array numbers to the pointer variable nPtr. e. Use a for statement to print the elements of array numbers using pointer/offset notation with pointer nPtr. f. Use a for statement to print the elements of array numbers using pointer/offset notation with the array name as the pointer. g. Use a for statement to print the elements of array numbers using pointer/subscript notation with pointer nPtr. h. Refer to the fourth element of array numbers using array subscript notation, pointer/offset notation with the array name as the pointer, pointer subscript notation with nPtr and pointer/offset notation with nPtr. i. Assuming that nPtr points to the beginning of array numbers, what address is referenced by nPtr + 8? What value is stored at that location? j. Assuming that nPtr points to numbers[ 5 ], what address is referenced by nPtr after nPtr -= 4 is executed? What is the value stored at that location?

Short answer

Initialize an array, declare a pointer, and print elements using various methods. Calculate addresses and values based on pointer arithmetic.

Step-by-step solution

Declare and Initialize the Array

To declare an array of type `double` called `numbers` with 10 elements initialized to the sequence 0.0, 1.1, 2.2, ..., 9.9, use the following C++ code: ```cpp double numbers[SIZE] = {0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9}; ``` Here, the symbolic constant `SIZE` is assumed to be defined as `const int SIZE = 10;`.

Declare a Pointer

Declare a pointer `nPtr` that can point to elements of type `double` using: ```cpp double *nPtr; ```

Print Elements Using Array Subscript Notation

To print the elements of the array `numbers` using array subscript notation with one decimal precision, use a `for` loop: ```cpp for (int i = 0; i < SIZE; i++) { std::cout << std::fixed << std::setprecision(1) << numbers[i] << " "; } std::cout << std::endl; ```

Assign the Address to Pointer

To assign the starting address of the array `numbers` to the pointer `nPtr`, use the following statements: ```cpp nPtr = numbers; // Or alternatively nPtr = &numbers[0]; ```

Print Elements Using Pointer/Offset Notation

Use pointer/offset notation to print elements using `nPtr`: ```cpp for (int offset = 0; offset < SIZE; offset++) { std::cout << std::fixed << std::setprecision(1) << *(nPtr + offset) << " "; } std::cout << std::endl; ```

Print Elements Using Array Name as a Pointer

Use the array name as a pointer with pointer/offset notation in a `for` loop: ```cpp for (int offset = 0; offset < SIZE; offset++) { std::cout << std::fixed << std::setprecision(1) << *(numbers + offset) << " "; } std::cout << std::endl; ```

Print Elements Using Pointer/Subscript Notation

Use pointer/subscript notation with `nPtr` to print array elements: ```cpp for (int i = 0; i < SIZE; i++) { std::cout << std::fixed << std::setprecision(1) << nPtr[i] << " "; } std::cout << std::endl; ```

Access the Fourth Element in Multiple Ways

Refer to the fourth element of `numbers` (3.3) in multiple ways: - Array subscript notation: `numbers[3]` - Pointer/offset with array name: `*(numbers + 3)` - Pointer subscript with `nPtr`: `nPtr[3]` - Pointer/offset with `nPtr`: `*(nPtr + 3)` All the above refer to the same value, 3.3.

Calculate Address and Value at nPtr + 8

Assuming `nPtr` points to the start of `numbers`, the address referenced by `nPtr + 8` is `1002564`. The value at this location is `8.8`, since each double takes up 8 bytes.

Calculate Address and Value After nPtr -= 4

Assuming `nPtr` points to `numbers[5]`, executing `nPtr -= 4` makes it point to `numbers[1]`. The new address is `1002508`, and the value stored at this location is `1.1`.

Key concepts

Array Declaration and Initialization

In C++, when you want to handle multiple data entries of the same type, arrays can be very helpful. An array is essentially a collection of elements that share the same type. Declaring an array involves specifying the type of its elements and the number of elements it can hold. For example, you can declare an array of 10 double values with the following code: ```cpp double numbers[10]; ```
Once declared, you might want to initialize this array with specific values. Let's say we want the values to progress sequentially from 0.0 to 9.9 in steps of 1.1. In C++, you can initialize an array during declaration like this: ```cpp double numbers[10] = {0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9}; ```
This way, not only have you declared the array, but you've also initialized it with predefined values in one go.

Pointer Arithmetic

Pointers are a powerful feature in C++ and serve to manage memory more directly. With pointer arithmetic, you can navigate through an array based on the memory addresses. A pointer is a variable that stores the address of another variable, and you can perform arithmetic operations to move through memory locations. A `double` type in C++ typically takes up 8 bytes. Suppose we have a pointer `nPtr` pointing to the start of our numbers array: ```cpp double *nPtr = numbers; ```
Pointer arithmetic allows you to move the pointer across the array by adding or subtracting offsets. For example, `nPtr + 1` will point to the next element in the `numbers` array. Whenever you add an integer to a pointer, it moves by that integer times the size of the data type it points to (in this case, 8 bytes each). ```cpp std::cout << *(nPtr + 2); // Outputs 2.2, the third element of the array ```
To effectively navigate arrays using pointers, understand that the pointer arithmetic takes into account the size of the data type of the array it points to.

Subscript and Offset Notation

When accessing elements in an array, C++ provides multiple ways to do it, primarily through subscript notation and pointer/offset notation. Each method offers a different way to interact with array data. **Subscript Notation**: This is the most common form of accessing array elements. It uses the square bracket notation `[]`. For instance, `numbers[3]` accesses the fourth element of the array. ```cpp std::cout << numbers[3]; // Outputs 3.3 ```
**Offset Notation**: This method involves using pointers to access array elements. It uses the `*` (dereference) operator in combination with pointer arithmetic. If `nPtr` is a pointer pointing to the array, `*(nPtr + 3)` accesses the same element as `numbers[3]`. ```cpp std::cout << *(nPtr + 3); // Outputs 3.3 ```
Using the array name as a pointer is also possible since the name of the array acts like a constant pointer to the first element. So, `*(numbers + 3)` performs the same function. Understanding these notations helps in choosing the appropriate method for accessing array elements based on context and the specific needs of your C++ program.