Releasing or deleting temporary memory

• The pointer continues to point to freed space even after memory is deallocated. Here’s an illustration to show how that occurs:

#include <stdio.h>
int main()
{
    int a = 80;
    int *ptr = (int *)malloc(sizeof(int));
    ptr = &a;
    free(ptr);
    return 0;
}

The code shown above shows how to construct a variable pointer *ptr and an integer variable a with the value 80. The malloc() function is used to generate the pointer variable *ptr. Given that we are aware that the malloc() function produces a void, we type-convert the void pointer into an int pointer using the int * function.

Function Call

• We will now examine how the function call causes the pointer to become dangling.

#include <stdio.h>
int *myvalue()
{
    int a = 10;
    return &a;
}

int main()
{
    int *ptr = myvalue();
    printf(“%d”, *ptr);
    return 0;
}

Output: Segmentation Fault!

The func() method’s return value is contained in the pointer ptr, which is declared in the main() function of the code above. The programme control is transferred to the context of the int *func when the function func() is called (). The address of the integer variable an is then returned by the method func().

The integer variable an is no longer accessible for the remainder of the program’s execution at this point, and programme control returns to the main() function. And because it points to a memory location that has been removed or freed from the stack, the pointer ptr becomes dangling. The application consequently causes a segmentation fault.

The outcome would have been 10 had the code been modified and the integer variable, which is static and is declared globally, been local rather than global.

The best way to prevent dangling pointer errors

Our applications get unpleasant defects from the hanging pointer, and these issues frequently lead to security flaws. These errors that result from the generation of a dangling pointer can be prevented by simply initialising the pointer value to NULL. The pointer won’t then point to the space in memory that was freed. While the purpose of giving the pointer the NULL value was to prevent it from pointing to any previously or arbitrarily designated memory location.

The post Dangling Pointer first appeared on Student Projects.

In many applications memory is allocated for holding data objects. After using these objects, tha aplication will de-allocate this memory so that the memory can be re-used. In some cases the alications may use a pointer to an object whose memory is already de-allocated. This may lead to application crash or an unpredictable behavior.

scenarios which leads to dangling pointer

1. Application makes use of a object after it has been released, and there by access to an invalid memory location.
2. A function returns a pointer to one of its local variables, and since this local variable is defined only fro the function, the pointer becomes invalid once the function ends.

The most common result of this bug is the crash of the application or its running thread.

Examle 1:

#include "stdlib.h"
 
void func()
{
    char *dp = malloc(A_CONST);
    /* ... */
    free(dp);         /* dp now becomes a dangling pointer */
    /* ... */
}

Example 2:

{
   char *dp = NULL;
   /* ... */
   {
       char c;
       dp = &c;
   } /* c falls out of scope */
     /* dp is now a dangling pointer */
} 

Example 3:

#include "stdio.h"

int *call();
void main(){

int *ptr;
ptr=call();

fflush(stdin);
printf("%d",*ptr);
}

int * call(){

int x=25;
++x;

return &x;
}

The post What is dangling pointer? first appeared on Student Projects.