What is an Uninitialized or Illegal Pointer in C?

Pointers are a powerful feature in C programming. They help manage memory and work efficiently with data. But if not used correctly, pointers can cause serious problems. Two common issues are uninitialized pointers and illegal pointers. This tutorial explains what they are, why they happen, what problems they cause, and how to avoid them.

Uninitialized Pointers

An uninitialized pointer is a pointer that has been declared but not assigned a specific memory address. Using such a pointer leads to undefined behavior because it may point to an arbitrary memory location.

Example:

#include <stdio.h>
 
int main()
{
    int *ptr;       // Uninitialized pointer
    *ptr = 5;      // Dangerous! Undefined behavior
    return 0;
}

In this example, ptr is declared but not initialized. Attempting to dereference it (*ptr = 5;) can lead to unpredictable results, including program crashes.

Consequences of Using Uninitialized Pointers

• Undefined Behavior: The pointer may point anywhere leading to crashes or wrong results.
• Security Risks: Hackers can exploit uninitialized pointers to access or tamper with memory.
• Hard to Debug: Bugs may appear later, making them tricky to find and fix.

Illegal Pointers

An illegal pointer refers to a pointer that points to a memory location that is not valid or accessible. This includes pointers that have been freed, pointers to local variables that have gone out of scope, or pointers that were never properly initialized.

Types of Illegal Pointers

Dangling Pointers

A dangling pointer arises when an object is deleted or deallocated, but the pointer still references the memory location of the deallocated object.

int *ptr = malloc(sizeof(int));
*ptr = 10;
free(ptr); // Memory is deallocated
*ptr = 20; // Dangling pointer usage

After free(ptr);, the memory is deallocated, but ptr still holds the address of the freed memory. Using *ptr after this point leads to undefined behavior.

Wild Pointers

A wild pointer is a pointer that has not been initialized and points to a random memory location.

int *ptr; // Wild pointer
*ptr = 10; // Undefined behavior

Using a wild pointer can corrupt data or crash the program.

Examples

Example 1: Uninitialized Pointer

#include <stdio.h>
 
int main() {
    int *ptr;      // Uninitialized pointer
    *ptr = 20;     // Dangerous: leads to undefined behavior
    printf("%d", *ptr);
    return 0;
}

Output: Undefined behavior (likely a segmentation fault)

This program shows the danger of using an uninitialized pointer. The pointer ptr is declared but not given a valid memory address. When we try to assign *ptr = 20;, the program writes to an unknown location. This causes undefined behavior, which might crash the program or give unexpected results. Always initialize pointers before using them.

Example 2: Initialized Pointer (Safe)

#include <stdio.h>
 
int main() {
    int a = 10;
    int *ptr = &a;   // Proper initialization
    printf("%d", *ptr);
    return 0;
}

Output:

10

This program shows how to properly use a pointer in C. It declares an integer a with the value 10 and a pointer ptr that stores the address of a. By using *ptr, it accesses the value stored at that address and prints 10. This example demonstrates correct pointer initialization and usage.

Example 3: NULL Pointer Check

#include <stdio.h>
 
int main() {
    int *ptr = NULL;   // Initialized to NULL
 
    if (ptr != NULL) {
        *ptr = 100;    // Safe check
    } else {
        printf("Pointer is NULL.\n");
    }
 
    return 0;
}

Output:

Pointer is NULL.

This program demonstrates safe pointer handling in C. It initializes a pointer ptr to NULL, meaning it doesn’t point to any valid memory yet. Before using the pointer, it checks if ptr is not NULL. Since it is NULL, it safely prints a message: “Pointer is NULL.” This prevents undefined behavior or crashes.

Example 4: Dangling Pointer

#include <stdio.h>
#include <stdlib.h>
 
int* create() {
    int a = 5;
    return &a;    // Returning address of local variable (BAD!)
}
 
int main() {
    int *ptr = create();
    printf("%d", *ptr);  // Dangling pointer: 'a' no longer exists
    return 0;
}

Output: Undefined behavior

You’re returning the address of a local variable that no longer exists after create() returns. ptr becomes a dangling pointer.

Best Practices to Avoid Pointer Issues

1. Initialize Pointers

Always initialize pointers when declaring them.

int *ptr = NULL;

2. Set Pointers to NULL After Freeing

After freeing memory, set the pointer to NULL to avoid dangling pointers.

free(ptr);
ptr = NULL;

3. Use dynamic memory allocation carefully:

int *ptr = (int *)malloc(sizeof(int));
if (ptr != NULL)
{
    *ptr = 10;
    free(ptr);
}

Sanfoundry Global Education & Learning Series – 1000 C Tutorials.