Question

What is the output of the following C++ code? int *first = new int; int *second; *first = 85; second = first; *second = *second + *first; first = new int; *first = *second - 100; cout << *first << " " << *second << endl;

Short answer

70 170

Step-by-step solution

Analyzing Variables and Assignments

First, an integer pointer `first` is initialized by allocating memory using `new int`. Then, another integer pointer `second` is declared but not initialized with a memory block.

Value Assignments

The pointer `first` is dereferenced and assigned the value 85 (`*first = 85`). Then, the pointer `second` is set to point to the same memory location as `first`, making them both point to the integer with the value 85.

Value Modification

The expression `*second = *second + *first` results in the value at the shared memory location being doubled: since both pointers point to 85, this operation adds 85 to the existing 85, resulting in 170 stored in the shared memory location.

Changing Pointer Destination

A new integer memory block is allocated for `first` using `new int` again, effectively changing the memory location `first` points to. The previous memory block remains unchanged (still pointed to by `second`).

Calculating and Assigning New Values

The new memory location pointed to by `first` is set to `*second - 100`. Since `*second` is 170 (from Step 3), `*first` becomes 170 - 100, which equals 70.

Printing the Output

The values pointed by `first` and `second` are printed using `cout`. `*first` is 70 and `*second` remains 170.

Key concepts

Memory Allocation

Memory allocation in C++ is a crucial concept, especially when dealing with pointers. It allows you to reserve memory for future use. When you use `new int` in C++, it allocates a block of memory to store an integer. This memory lives on the heap, a special area where dynamic memory resides. Heap memory is not automatically reclaimed when the program exits a scope. You must explicitly release it using `delete`. Allocating memory dynamically is useful when you don't know the size of data needed at compile time. Memory allocation grants you flexibility and control over memory usage.
However, misuse can lead to memory leaks if the allocated memory is not properly freed. This is why understanding memory allocation is so fundamental for efficient C++ programming.

Pointer Assignment

Pointer assignment is the operation of assigning one pointer to another. In C++, this means making one pointer - like `second` in our exercise - point to the same memory location as another, `first` in this case. When assigning `second = first`, you only copy the address stored in `first` to `second`. It's important to remember that the actual integer value isn't directly copied. Instead, both pointers now reference the same memory location.
This makes pointer assignment a powerful tool, for example, when you want multiple pointers to refer to a single data instance, allowing synchronized manipulation of that data across different parts of your program.

Dereferencing

Dereferencing is the act of accessing or modifying the value that a pointer points to. In C++, you dereference a pointer by using the `*` operator. For instance, `*first = 85` sets the value of whatever `first` is pointing to, while `*second = *second + *first` modifies the value already stored at the memory location both pointers point to. Dereferencing is one of the core operations of pointer usage, letting you interact with the actual data rather than just the memory address itself.
It's crucial for various operations, such as accessing array elements, managing dynamic memory, or implementing complex data structures like linked lists.

Dynamic Memory Management

Dynamic Memory Management in C++ involves both allocating and freeing memory during the life of a program. This management is crucial for preventing memory leaks and ensuring efficient use of system resources. To allocate memory dynamically, C++ uses operators like `new`, and to free memory, it uses `delete`. Since dynamically allocated memory doesn’t automatically get cleaned up, every `new` should have a corresponding `delete`.
Failure to deallocate memory can lead to leaks, where used memory isn't available for new uses, potentially exhausting available memory over time. Thus, mastering dynamic memory management is vital for writing robust and efficient C++ programs.