Question

What is wrong with the following code? int *p; //Line 1 int *q; //Line 2 p = new int; //Line 3 *p = 43; //Line 4 q = p; //Line 5 *q = 52; //Line 6 delete q; //Line 7 cout << *p << " " << *q << endl; //Line 8

Short answer

The code accesses deleted memory, leading to undefined behavior on line 8.

Step-by-step solution

Understanding Pointer Assignment

In line 3, the pointer `p` is assigned a new integer on the heap (`new int`). Line 4 then assigns the value 43 to this integer. Line 5 assigns the pointer `q` the same address as `p`, meaning both `p` and `q` point to the same memory location.

Modifying through a Secondary Pointer

Line 6 modifies the value at the memory location pointed by `q` to 52. Since both `p` and `q` point to the same location, the value at the memory location is now 52, affecting what `p` would also read.

Deleting Memory through the Secondary Pointer

Line 7 deletes the memory allocated that both `p` and `q` point to via `delete q`. This deletes the memory address and makes the pointer dangling, i.e., both pointers become invalid.

Accessing Deleted Memory

Line 8 tries to print the values pointed by `p` and `q`. Since the memory was deleted in line 7, both pointers `p` and `q` are now dangling, leading to undefined behavior in accessing the invalid memory location. This can cause a program crash or garbage output.

Key concepts

Pointer Assignment

In C++, one powerful feature is the use of pointers, which manage and manipulate memory addresses directly. This offers flexibility and functionality that are not available in high-level programming languages. Let's break down pointer assignment.

When you assign a pointer, like the statement `p = new int;`, you are making the pointer `p` point to a new integer in the heap memory. This does not immediately give `p` a value, but reserves space for an integer.

If `p` is assigned to `q` using `q = p;`, both `p` and `q` now reference the same memory location.

Caution is crucial here: each pointer can still operate independently on the memory it points to, but any changes made through either pointer reflect instantly at the shared memory address.

Memory Management

Memory management in C++ is a fundamental concept due to the language's ability to allocate and deallocate memory manually. However, this power comes with the responsibility to manage it correctly.

The `new` operator dynamically allocates memory on the heap, while `delete` deallocates that memory. When you use `new int;` in the code, you are creating room for one integer on the heap.
It's very important to use `delete` to free up the memory once you no longer need it.

Failure to do so results in memory leaks, causing your program to use more memory than necessary, possibly leading to its eventual slowdown or crash. This careful balance of allocating and deallocating memory is key to robust and optimal C++ programming.

Dangling Pointers

Dangling pointers are pointers in C++ that reference a memory location which has already been freed, rendering them invalid. This critical issue often arises after deallocating memory with `delete` while pointers still point to that now-gone memory.

In the provided code, both `p` and `q` point to the same memory location. When you use `delete q;`, you are deallocating that memory. This action leaves `q`, and inherently `p`, as dangling pointers.
Accessing or modifying these pointers post-deallocation can lead to erratic behavior, as the pointers are no longer valid or predictable.

Prevent dangling pointers by setting them to `nullptr` after `delete` operations.

Undefined Behavior

Undefined behavior in C++ refers to operations that result in behavior that is unpredictable or not specified by the standard. Accessing memory through dangling pointers, as shown in the final lines of the code, exemplifies undefined behavior.
When memory pointed to by `p` and `q` is deleted, any subsequent access is unpredictable and can vary between compilers or even executions.

Common outcomes of undefined behavior include program crashes, unexpected output, or security vulnerabilities.
To avoid undefined behavior, always ensure pointers point to valid memory locations, and avoid using pointers that become invalid after deleting their assigned memory.