Dangling Pointers In C++ – Pointers.co.in

Introduction to Dangling Pointers:

In C++, a dangling pointer is a pointer that points to a memory location that has been deallocated or freed. Accessing the memory through such pointers can lead to undefined behavior, including crashes, data corruption, or unpredictable results. Dangling pointers often occur when memory is allocated dynamically using new or malloc, and then the memory is deallocated using delete or free, but the pointer still holds the address of the deallocated memory.

Example C++ Code:

Here’s an example C++ code demonstrating the concept of dangling pointers:

#include <iostream>

int main() {
    int* ptr = new int(5); // Dynamically allocate memory and assign value 5
    std::cout << "Value at ptr: " << *ptr << std::endl;

    delete ptr; // Deallocate memory

    std::cout << "Value at ptr after deletion: " << *ptr << std::endl; // Accessing memory through dangling pointer
    return 0;
}

Line-by-Line Explanation:

#include <iostream>: This line includes the necessary header file for input/output operations.
int main() {: Beginning of the main function.
int* ptr = new int(5);: This line dynamically allocates memory for an integer and initializes it with the value 5. The address of the allocated memory is stored in the pointer variable ptr.
std::cout << "Value at ptr: " << *ptr << std::endl;: This line prints the value stored at the memory location pointed to by ptr.
delete ptr;: This line deallocates the memory previously allocated using new. After this line, ptr becomes a dangling pointer.
std::cout << "Value at ptr after deletion: " << *ptr << std::endl;: This line tries to access the memory pointed to by ptr, which has been deallocated. This is an attempt to dereference a dangling pointer, leading to undefined behavior.
return 0;: End of the main function, returning 0 to indicate successful execution.

In this example, accessing the memory through ptr after it has been deallocated results in undefined behavior, often leading to a segmentation fault or crash. This illustrates the danger of using dangling pointers in C++ programs. To avoid dangling pointers, it’s essential to ensure that pointers are either pointing to valid memory locations or set to nullptr after deallocation.