Dangling Pointer in C with Example

Last Updated on August 9, 2023 by Mayank Dham

In the upcoming sections of this article, we will delve into the concept of dangling pointer in C programming language. We will explore different scenarios in which an ordinary pointer can become a dangling pointer, and subsequently, we will discuss multiple strategies to prevent the occurrence of dangling pointer in C. As we progress through the blog, we will gain a comprehensive understanding of the intricacies associated with dangling pointers.

What is Dangling Pointer in C

A dangling pointer within the C programming context denotes a pointer that points to memory that has been previously deallocated, including instances where dynamically allocated memory blocks have been freed. Attempting to dereference such a dangling pointer can result in unpredictable behavior or even trigger a segmentation fault. Put simply, a dangling pointer in C is a pointer that directs to memory that is no longer in use due to deallocation.
The creation of these pointers occurs when an object, variable, or memory location is released or deallocated without modifying the value stored within the respective pointer. Many common issues arising from the handling of C pointers and their treatment are often associated with the presence of dangling pointers. This often occurs when a programmer inadvertently overlooks the initialization of a pointer with a valid address. The term "dangling pointer in C" encapsulates this specific scenario of uninitialized pointers.

How does Dangling Pointer in C work?

The dangling pointer in c can always point to a memory region or variable that contains the whole application code or the operating system’s code. The operating system or application code will replace any value that has been set to the dangling pointer in c, which will always have an unpleasant outcome or even cause the program to crash.
The segmentation fault will result in the dereference of the dangling pointer in c
if the memory is later relocated to another piece of code. The dangling pointer in c value won’t ever be changed, thus it could still refer to the location of the other deallocated memory.
The dangling pointer in c can be created when we do not modify the value of the pointer after the variable goes out of scope or deallocation memory.

Dangling Pointer is Created

There are generally three ways to create dangling pointers in c we will discuss all of them in this section of the article.

1. De-allocation of Memory
   The allocation and deallocation of memory blocks are carried out using library functions, such as malloc(), calloc(), and free(). The former is used to allocate a memory block, while the latter is carried out using the former. Therefore, the pointer will behave as a Dangling Pointer in c when we deallocate a memory block using the free() method without changing the pointer value.
   The only input for the free() method is a pointer referring to the memory that has to be deallocated.

   Example

   • C

   #include <stdio.h>
   #include <stdlib.h>
    
   int main() {
        int *ptr = (int *)malloc(sizeof(int)); // normal pointer
    
       *ptr = 15;
    
       // memory block deallocated using free() function
       free(ptr);
    
    
       // here ptr acts as a dangling pointer
       printf("%d", *ptr);
   }

   Output

   0

   Explanation of the above code
   In the above example, we declared a pointer dynamically using malloc and after that, we freed the pointer after freeing the pointer we have not initialized it with null or anything so now that pointer will be a dangling pointer in c.
   First, using the malloc() method, a memory block of sizeof(int) (typically 4 bytes) has been given to an integer pointer ptr. Right now, it functions like a typical pointer. The number 10 has been put into the integer memory block referred to by ptr. The 4 bytes of memory referred to by the ptr pointer and holding the value 15 are then deallocated by free(ptr). Due to the fact that ptr is currently pointing at a deallocated memory block, it will behave as a dangling pointer. and

2. Function Call
   When a variable is declared inside a function, it becomes local to that function’s execution and cannot be accessible from outside of that function. Now, imagine that the main() function’s pointer stores the address of that local variable inside the function. In this case, we can access the address of that local variable while the function is running, but when the function is finished, all internal variables go through garbage collection and are no longer in memory, but the main() function’s pointer is still pointing to that specific address, which is no longer available in memory, creating a dangling condition and would cause an error. So this will create a dangling pointer in c. And we cannot access that variable and the pointer pointing to that variable is known as a dangling pointer in c.

   Example
   In this section, we will discuss an example of creating a dangling pointer in c using a function call.

   Code Implementation:

   • C

   #include <stdio.h>
   
   int *danglingPointer() {
       int x = 15;
   
       return &x;
   }
   
   int main() {
       int *ptr = danglingPointer();
   
       printf("%d", *ptr);
   
       return 0;
   }
   

   Output

   Runtime error

   Explanation of the above Code
   In the above example, we have seen that we have created a function using a pointer and then we have freed the memory using flash after that, we have seen the value of the pointer and that pointer has now become a dangling pointer in c and hence the output is shown accordingly.

3. Variable Goes out of the Scope
   In this section, we will see how can we create a dangling pointer in c when a variable goes out of scope. A variable will have a local scope and be destroyed after the inner block’s execution is complete if it is declared inside some inner code block. It will behave as a Dangling Pointer in c outside the inner block of code if the address of this local variable is assigned to a pointer declared outside the scope.

   Example
   Here we will look at the example of the dangling pointer in c when we create a dangling pointer in c in the cases when a variable goes out of the scope.

   Code Implementation:

   • C

   // Variable goes out of scope
   #include <stdio.h>
   
   int main()  {
   
       int *ptr; 
   
       
       {
           int temp = 22;
           ptr = &temp; // acting as normal pointer
       }
   
       // now ptr is a dangling pointer
       printf("%d %d", *ptr, temp);
   
   
       // prints garbage value
       printf("%d", *ptr);
   
   
       return 0;
   }
   

   Output

   prog.c: In function ‘main’:
   prog.c:15:27: error: ‘temp’ undeclared (first use in this function)
        printf("%d %d", *ptr, temp);
                              ^~~~
   prog.c:15:27: note: each undeclared identifier is reported only once for each function it appears in

   Explanation of the above code
   It is known as a Wild Pointer because, in the first step, we defined an integer pointer, ptr, without initializing it.
   The second stage included inserting a code block with a restricted scope inside of which an integer variable named temp was defined and whose scope lasted only as long as the block was still being executed. The ptr pointer now refers to the location of the temp and has the address of the temp allocated to it. Assume that the temp has been assigned the base address 1000.
   The memory used by temp has been deallocated by the operating system since it was declared inside this block, while ptr remains untouched because it is defined in the outside block of code.
   The address 1000 is still there in ptr at step three, but there is nothing there. As a consequence, the pointer will become a "Dangling Pointer in c."
   Since the temp variable is no longer in memory, we are unable to change its value with the ptr pointer.

Methods to Avoid Errors in Dangling Pointer in C

There are three main ways to avoid errors in dangling pointers in c. In this section we will discuss all of them:

1. Perform de allocation of memory blocks using free() method.
   To prevent the dangling pointer issue in our software, we should assign NULL to the ptr pointer as soon as the memory block referenced to by the ptr has been deallocated using the free() method.
2. Variable having limited scope during a function call
   Static variables are those that stay in memory throughout the course of a program’s execution. In our application, we may declare a static variable by using the static keyword.
3. Varibles can go out of scope if declared inside some inner block of code
   By employing strategies like setting NULL to the pointer as soon as the memory is deallocated and using static variables, which keep the variable in memory until the programme has finished running, we may prevent such issues.

Conclusion
Dangling pointers in the C programming language can pose significant challenges and risks to the stability and reliability of your code. Understanding what dangling pointers are, how they occur, and how to avoid them is crucial for writing robust and error-free C programs. By following best practices and adopting proper memory management techniques, you can minimize the occurrence of dangling pointers and enhance the overall quality of your software.

Frequently Asked Questions (FAQs) related to Dangling Pointer in C

Here are some FAQs related to the Dangling Pointer in C:

1. What is a dangling pointer in C?
A dangling pointer in C refers to a pointer that continues to point to a memory location after the memory it references has been deallocated or released. Accessing or dereferencing such a pointer can lead to undefined behavior or crashes.

2. How does a dangling pointer occur?
Dangling pointers often occur when memory is deallocated, but the corresponding pointer is not updated or set to NULL. This can happen when using dynamically allocated memory, function returns, or when a variable goes out of scope.

3. What are the risks of using a dangling pointer?
Using a dangling pointer can result in accessing invalid memory, causing unexpected program behavior, crashes, or data corruption. These issues can be difficult to diagnose and fix.

4. How can I avoid creating dangling pointers?
To avoid dangling pointers, always set pointers to NULL after freeing or deallocating memory. Additionally, ensure that pointers are only used within their valid scope and are properly initialized.

5. What is the significance of NULL pointers in relation to dangling pointers?
NULL pointers are pointers that do not point to any valid memory location. Assigning a NULL value to a pointer after deallocating its memory helps prevent it from becoming a dangling pointer, making it safe to test before using.

6. Can a stack variable become a dangling pointer?
While stack variables can become invalid if accessed outside their scope, they typically do not become dangling pointers in the same way as pointers to dynamically allocated memory. Stack variables’ lifetimes are usually well-defined by their scope.