Question

What is the output of the following C++ code? int *p; int *q; p = new int; q = new int; *p = 27; *q = 35; cout << *p << " " << *q << endl; *q = *p; *p = 73; cout << *p << " " << *q << endl; p = new int; *p = 36; q = p; cout << *p << " " << *q << endl;

Short answer

The output of the code is: 27 35 73 27 36 36.

Step-by-step solution

Initializing Pointers and Assigning Values

The code begins by declaring two integer pointers, `p` and `q`. It then allocates memory for them using `new int`. After this, the code assigns the values 27 and 35 to the locations pointed to by `p` and `q`, respectively. Thus, `*p = 27` and `*q = 35`.

First Output

The code outputs the values at the addresses to which `p` and `q` point. Since `*p` is 27 and `*q` is 35 at this point, the first output line displays `27 35`.

Copying and Changing Values

The pointer `q` is then assigned the value at which pointer `p` points, so `*q = *p` makes `*q` equal to 27. The variable pointed by `p` is then updated to 73, so now `*p = 73`, but `*q` remains 27. As a result, the second line outputs `73 27`.

Assigning New Memory and Final Output

The code allocates new memory to `p` and assigns the value 36 to it (`*p = 36`). Then, `q` is set to point to the new address held by `p`. Consequently, both `*p` and `*q` are now 36, so the final output line is `36 36`.

Key concepts

Memory Allocation

In C++, memory allocation is a crucial process where we reserve space in the computer’s memory for variables to store data. When we use the `new` keyword for memory allocation, the program dynamically assigns memory and returns a pointer to the beginning of the memory block. This process allows for flexible data storage as it can accommodate varying data sizes and makes efficient use of memory.

• Dynamic Allocation: In our example, `new int` is used to allocate memory for integers. This means the program reserves enough space in memory to hold an integer and returns the address, which is stored in a pointer variable.
• Usage of Memory: By dynamically allocating memory, we ensure that the memory is used only as needed during runtime, avoiding wastage.

Remember, every bit of dynamically allocated memory must eventually be freed using `delete` to prevent memory leaks.

Pointer Initialization

Pointer initialization ensures that a pointer holds a valid memory address before you use it. In our code, `int *p;` and `int *q;` are declared. Yet, they initially don’t point to any valid memory.
To correctly initialize these pointers, we use `p = new int;` and `q = new int;`, which assign valid memory addresses to them.

• Uninitialized Pointers: If not initialized, pointers contain garbage values leading to undefined behavior.
• Ensuring Safeguards: Always initialize pointers either by pointing to a valid memory location or setting them to `nullptr` if they aren’t used right away.

This practice avoids accessing random memory locations, which can cause crashes or unexpected behavior.

Dereferencing Pointers

Dereferencing a pointer means accessing or modifying the value stored at the memory location the pointer is pointing to. This is done using the asterisk (*) operator in C++.
For instance, after memory allocation with `new int`, the statements `*p = 27;` and `*q = 35;` assign values to the allocated memory spaces pointed at by `p` and `q` respectively.

• Accessing Values: To read the memory content, use `*p`, and to change it, also use `*p` on the left-hand side of an assignment.
• Risks: Make sure the pointer is initialized; otherwise, dereferencing can lead to undefined behavior, including program crashes.

Properly dereferencing ensures you interact with intended memory addresses.

Pointer Assignment

Pointer assignment involves assigning a new address to an existing pointer variable. This operation changes where the pointer aims without altering the data it holds.
In the example, the pointer `q` is reassigned in different instances:

• `*q = *p;` makes `*q` equal to 27 by copying the value from `*p`.
• `q = p;` updates `q` to point to the same address as `p`, which means both now access and modify the same memory space.

By reassignment, pointer `q` starts pointing to new memory, leaving the old memory unreferenced in the final act unless cleaned up, which may lead to memory leaks. Always ensure correct management of what pointers are addressing to prevent unintended consequences.