What are the different types of pointers in C language?

---

A pointer is a variable that stores the address of another variable. The deceleration of a pointer is similar to that of a variable the only difference is while declaring a pointer we need to use "*".

Following is the syntax to declare a pointer −

type *variable_name;

Similar to variables, pointers can be declared in different types. Following is an example −

#Integer type pointer
int *integer_pointer;
#Character type pointer
char *character_pointer;

The following are the points to be noted −

• Pointers enable direct memory access and manipulation, which is crucial for efficient array handling.
• Using pointers we can allocate memory dynamically, which comes in handy while implementing data structures like linked lists.

Assigning value to a Pointer

The & symbol before a variable represents its address. Since the pointer holds the address of a variable, to initialize the value to a pointer using the & Following is the syntax to assign value to a pointer −

pointer = &variable;

Now, let us see an example of initializing a pointer, here we have declared a variable and a pointer respectively and (initialized the pointer with the address of the variable) assigned the address of the variable to the pointer using the *.

#include <stdio.h>
int main() {
   int my_variable = 1001;
   int *ptr = &my_variable;
   printf("Value of the variable = %d
", &my_variable );
   printf("Value of the pointer = %d
", * ptr);
   return 0;
}

Types of Pointers

There are seven different types of pointers which are as follows −

• Null pointer

• Void pointer

• Wild pointer

• Dangling pointer

• Complex pointer

• Near pointer

• Far pointer

Null Pointer

A null pointer is a special pointer that points to NULL and it doesn't reference any actual memory location. It's defined as an integer constant expression with the value 0, or an expression to the type void *. When this is converted to a pointer type, a null pointer is different from any pointer to an object or function.

Syntax

Following is the syntax for the Null Pointer is as follows −

ptr = NULL;

Example

The below example demonstrates how to declare a null pointer and check if it points to any memory location. If the pointer is null, it prints a message specifying that the pointer is null, otherwise it does not print anything. −

#include <stdio.h>
int main() {
   int *ptr = NULL;
   printf("The value inside variable ptr is: %p
", (void *)ptr);
   return 0;
}

Output

When the above program is executed, it produces the following result −

The value inside variable ptr is: (nil)

Void Pointer

A void pointer is a pointer without an associated data type. It can store the address of any type and can be retrieved to any type.

Example

Following is the C program for the void pointer −

#include <stdio.h>
#include <stddef.h>

int main() {
   void *p = NULL;
   printf("The size of pointer is: %zu
", sizeof(p));
   return 0;
}

Output

When the above program is executed, it produces the following result −

The size of pointer is:8

Wild Pointer

Wild pointers, also known as random pointers, point to arbitrary memory locations and can cause a program to behave differently. These pointers are unpredictable because they hold the reference of unknown memory locations.

Example

Following is the C program for the wild pointer −

#include <stdio.h>
int main() {
   int *p; //wild pointer
   printf("%d",*p);
   return 0;
}

Process returned -1073741819 (0xC0000005) execution time : 1.206 s Press any key to continue This means we won't get any output, and some compilers may display an error message.

Dangling Pointer

A Dangling Pointer in C is a pointer than points to a memory location that has been deallocated. This leads to various problems such as memory leaks, unpredictable behavior, and segmentation faults. These pointer often occur when an object is deallocated or deleted without updating the pointer's value.

Example

Following is the C program for the dangling pointer −

#include <stdio.h>
#include <stdlib.h>
int main() {
   int* ptr = (int*)malloc(sizeof(int));
   if (ptr == NULL) {
       printf("Memory allocation failed
");
       return 1;
   }
   free(ptr);
   printf("Deallocated memory
");
   ptr = NULL;
   return 0;
}

The result is generated as follows −

Deallocated memory

Complex Pointers

A complex pointer consists of [], *, (), an identifier and a datatype. These operators contain different levels of associativity and precedence. [] and () have the highest precedence and these are specified from left to right.

char(* ptr)[2]

Near pointer

A Near Pointer stores 16-bit addresses, which means it can only access memory within the current data on a 16-bit machine. This can only access the first 64kb of data using a near pointer.

Syntax

Following is the syntax for the Near Pointer is as follows −

ptr_type near * ptr_name;

Example

The following C program prints the size of a near pointer, which is 2 bytes on a 16bit system.

#include <stdio.h>
 
int main(){
  int near* ptr;
  printf("Size of Near Pointer: %d bytes", sizeof(ptr));
  return 0;
}

Following is the output of the above code −

Pointer Size: 8 

Far pointer

A Far Pointer uses 16-bit registers to store addresses, which allows access to enable the current segment. Each compiler assigns one register for the segment and another for the offset within the segment. Here, the address is obtained by adding the shifted offset segment address.

Syntax

Following is the syntax for the Far Pointer is as follows −

ptr_type far * ptr_name;

Example

The following C program prints the size of a far pointer, which is 4 bytes on a 16-bit system.

#include <stdio.h>
int main() {
   int far*ptr;
   printf("Far Pointer size: %d bytes", sizeof(ptr));
   return 0;
}

Output is generated as follows −

Far Pointer size: 4 bytes