Question

For each of the following, write a single statement that performs the specified task. Assume that long integer variables value1 and value2 have been declared and value1 has been initialized to 200000. a. Declare the variable longPtr to be a pointer to an object of type long. b. Assign the address of variable value1 to pointer variable longPtr. c. Print the value of the object pointed to by longPtr. d. Assign the value of the object pointed to by longPtr to variable value2. e. Print the value of value2. f. Print the address of value1. g. Print the address stored in longPtr. Is the value printed the same as value1's address

Short answer

The address stored in `longPtr` is the same as `value1`'s address.

Step-by-step solution

Declare Pointer Variable

Declare a pointer variable named `longPtr` that can store the address of a long integer using the following statement in C:\[\text{long *longPtr;}\] This initializes `longPtr` as a pointer capable of holding addresses of long integer type variables.

Assign Address to Pointer

Assign the address of `value1` to the pointer `longPtr` using the following statement in C:\[\text{longPtr = \&value1}\] This statement uses the address-of operator `&` to obtain the memory address of `value1` and stores it in `longPtr`.

Print Value at Pointer Address

Print the value stored at the memory address pointed to by `longPtr` using:\[\text{printf("Value pointed to by longPtr is: \%ld", *longPtr);}\] The asterisk `*` is used to dereference the pointer, accessing the value stored at the address `longPtr` points to.

Assign Value to Another Variable

Assign the value of the object pointed to by `longPtr` to `value2` with:\[\text{value2 = *longPtr;}\] This dereferences `longPtr` to get the current value of `value1` and assigns it to `value2`.

Print Value of Second Variable

Print the value of `value2` using:\[\text{printf("Value of value2 is: \%ld", value2);}\] This statement confirms that `value2` now holds the same value as `value1` after assignment.

Print Address of Original Variable

Print the address of `value1` using:\[\text{printf("Address of value1 is: \%p", (void*)\&value1);}\] This prints the memory address where `value1` is stored, using `&value1`.

Compare Address Stored in Pointer

Print the address stored in `longPtr` using:\[\text{printf("Address stored in longPtr is: \%p", (void*)longPtr);}\] This prints the same address as `value1` since `longPtr` was assigned this address in Step 2.

Key concepts

Pointer Declaration

In C++, pointers are variables that store memory addresses rather than data values directly. When declaring a pointer, you must indicate that it is a pointer and specify the data type it will point to. For example, to declare a pointer

• that can point to a `long` integer, we write the statement: `long *longPtr;`.

This tells the compiler that `longPtr` is a pointer variable capable of holding the address of a `long` integer. The asterisk (`*`) in the declaration signifies that we are defining a pointer, not a regular variable.

Memory Addressing

Every variable in a C++ program is stored somewhere in the computer's memory, and each location has its own address. When you need to access the location of a variable, you use its memory address. To obtain the address,

• you use the address-of operator `&`.
• For example: `longPtr = &value1;` assigns the address of `value1` to the pointer `longPtr`.

This operation allows us to access or manipulate the variable `value1` indirectly through the pointer.

Pointer Dereferencing

Dereferencing a pointer means accessing the value stored in the memory location the pointer refers to. In C++, this is done using the asterisk (`*`) operator. If you have a pointer like `longPtr`, you can access

• the value it points to by writing: `*longPtr`.

Whenever you see the dereference operator `*` in the context of a pointer, think of it as the key to open the box into which the pointer is looking.

Variable Assignment

In any programming language, assigning values to variables is a fundamental task. In the context of pointers, this can mean assigning an address to a pointer or a value to a variable.
Once you have dereferenced a pointer to get a value,

• you can use that value in expressions or assign it to another variable as follows: `value2 = *longPtr;`.

This assigns the value pointed to by `longPtr` to `value2`, effectively copying the value from the original variable to another.

Printf Function

The `printf` function is a staple of C and C++ programming, used for formatted output to the screen. When working with pointers and addresses, `printf` can display both values and memory locations.
For example, to print the value pointed by a pointer

• we use: `printf("Value pointed to by longPtr is: %ld", *longPtr);`.

In another scenario, to print the address stored in a pointer, use `%p` in the format string: `printf("Address stored in longPtr is: %p", (void*)longPtr);`. This helps visualize what's happening in memory.