{"id":130504,"date":"2024-02-09T18:00:57","date_gmt":"2024-02-09T12:30:57","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=130504"},"modified":"2024-03-09T14:12:03","modified_gmt":"2024-03-09T08:42:03","slug":"different-types-of-pointers-in-c","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/different-types-of-pointers-in-c\/","title":{"rendered":"Different Types of Pointers in C"},"content":{"rendered":"

Pointers in C are a fundamental concept that allows you to work directly with memory addresses. They serve as a powerful tool, enabling you to manipulate data and structures efficiently. However, improper use of pointers can lead to subtle and challenging-to-debug issues.<\/p>\n

In this guide, we will explore four important types of pointers in C: Dangling Pointers, Generic Pointers (Void Pointers), Null Pointers, and Wild Pointers.<\/p>\n

Dangling Pointer in C<\/h2>\n

1. De-allocation of Memory<\/h3>\n

A dangling pointer in C occurs when a pointer continues to reference a memory location after it has been deallocated or freed. This situation can lead to unexpected behavior and security vulnerabilities.<\/p>\n

Consider the following code snippet:<\/strong><\/p>\n

#include <stdlib.h>\r\n#include <stdio.h>\r\n\r\nint main() {\r\n    int* ptr = (int *)malloc(sizeof(int));\r\n    \r\n    \/\/ After the below free call, the pointer gets hanging.\r\n    free(ptr);\r\n\r\n    \/\/ No more dangling pointer\r\n    ptr = NULL;\r\n    \r\n    return 0;\r\n}<\/pre>\n
In this example, ptr initially points to a dynamically allocated memory location using malloc. However, after we call free(ptr), the memory is deallocated, and ptr becomes a dangling pointer. To avoid this, it’s a good practice to set dangling pointers to NULL.<\/p>\n
2. Function Call<\/h3>\n
Another common scenario for creating dangling pointers is when a pointer points to a local variable that goes out of scope. Local variables are typically destroyed when the function they belong to exits.<\/p>\n
Consider this example:<\/strong><\/p>\n
#include <stdio.h>\r\n\r\nint* fun() {\r\n    int x = 5;\r\n    return &x;\r\n}\r\n\r\nint main() {\r\n    int* p = fun();\r\n    printf(\"%d\\n\", *p);\r\n    \r\n    return 0;\r\n}<\/pre>\n
In this case, p points to the local variable x. When the fun function exits, x goes out of scope, leaving p dangling. It’s essential to be cautious when returning pointers to local variables from functions.<\/p>\n
3. Variable Goes Out of Scope<\/h3>\n
A similar situation to the one discussed earlier occurs when a variable goes out of scope, rendering a pointer dangling. Observe this code:<\/strong><\/p>\n
void main() {\r\n   int *ptr;\r\n   \/\/ ...\r\n   {\r\n       int ch;\r\n       ptr = &ch;\r\n   }\r\n }<\/pre>\n
In this example, ptr is assigned the address of ch, which is a local variable within an inner block. Once that block exits, ch goes out of scope, making ptr a dangling pointer. It’s crucial to be aware of the lifetimes of variables and pointers to avoid dangling situations.<\/p>\n
\"variable<\/a><\/p>\n
Generic Pointer (Void Pointer) in C<\/h3>\n
A generic pointer, often referred to as a void pointer, is a versatile pointer type. It is not associated with any specific data type, making it suitable for handling various types of data. However, working with void pointers requires typecasting to access the actual data.<\/p>\n
Characteristics of C Void Pointers<\/h4>\n