What is the difference between array and string in C?

Null pointer is a pointer which is pointing to nothing. Null pointer points to empty location in memory. Value of null pointer is 0. We can make a pointer to point to null as below.

int *p =  NULL;
char *p = NULL;

In C, a null pointer is a special value that represents the absence of a valid memory address. It is commonly denoted by the macro NULL, which expands to an implementation-defined null pointer constant.

A null pointer does not point to any valid memory location. It is used to indicate that a pointer variable does not currently point to an object or has not been assigned a valid memory address yet.

Null pointers are often used in conditional statements to check if a pointer is valid or uninitialized before dereferencing it. Attempting to dereference a null pointer can result in undefined behavior, such as program crashes or accessing invalid memory.

Here's an example illustrating the use of null pointers:

#include <stdio.h>

int main() {
    int* ptr = NULL;  // Assigning a null pointer

    if (ptr == NULL) {
        printf("The pointer is currently null.\n");
    } else {
        printf("The pointer is not null.\n");
    }

    return 0;
}

In the above example, a pointer variable ptr is initialized with a null pointer by assigning the NULL macro. The code then checks if ptr is equal to NULL using an if statement. Since ptr is a null pointer, the message "The pointer is currently null." is printed.

NULL is a macro which is defined in C header files. The value of NULL macro is 0. It is defined in C header files as below.

#define NULL (void *) 0;

NULL is used for pointers only as it is defined as (void *) 0. It should not be used other than pointers. If NULL is assigned to a pointer, then pointer is pointing to nothing.

• Void pointer is a generic pointer that can be used to point another variable of any data type.
• Void pointer can store the address of variable belonging to any of the data type. So, void pointer is also called as general purpose pointer.

Note:
int pointer can be used to point a variable of int data type and char pointer can be used to point a variable of char data type.

In C, a void pointer, also known as a generic pointer, is a special pointer type that can hold the address of an object of any data type. It is declared using the void * type.

The void * type is considered "generic" because it lacks a specific data type. It allows a pointer to be assigned and manipulated without specifying the data type of the object it points to. However, you cannot directly dereference a void pointer or perform pointer arithmetic on it, as the compiler does not know the size or type of the object being pointed to.

Here's an example illustrating the use of a void pointer:

#include <stdio.h>

int main() {
    int num = 42;
    float pi = 3.14159;
    char letter = 'A';

    void* ptr;

    ptr = &num;
    printf("Value pointed by ptr: %d\n", *(int*)ptr);

    ptr = &pi;
    printf("Value pointed by ptr: %.5f\n", *(float*)ptr);

    ptr = &letter;
    printf("Value pointed by ptr: %c\n", *(char*)ptr);

    return 0;
}

In the above example, a void pointer ptr is declared. It is then assigned the address of different variables (num, pi, and letter) successively. By explicitly casting ptr to the appropriate type (int*, float*, or char*) before dereferencing it, we can access the values pointed to by the void pointer.

Note that when using void pointers, you need to ensure proper type casting and handle them with caution, as there is no type checking at compile-time. It is crucial to cast the void pointer to the correct type before dereferencing it to avoid errors and maintain type safety.

When a pointer is pointing to non-existing memory location is called dangling pointer.

Uninitialized pointers are called as wild pointers in C which points to arbitrary (random) memory location. This wild pointer may lead a program to behave wrongly or to crash.

• File pointer is a pointer which is used to handle and keep track on the files being accessed. A new data type called “FILE” is used to declare file pointer. This data type is defined in stdio.h file. File pointer is declared as FILE *fp. Where, ‘fp’ is a file pointer.
• fopen() function is used to open a file that returns a FILE pointer. Once file is opened, file pointer can be used to perform I/O operations on the file. fclose() function is used to close the file.

In C, a file pointer is a variable that is used to point to a specific location within a file. It is used to read from or write to a file. The stdio.h library provides functions for file I/O operations, and the FILE type is used to define a file pointer.

Here is an example that demonstrates the use of a file pointer to read and write to a file:

#include <stdio.h>

int main() {
   FILE *fp;
   char buffer[100];

   // Open file for writing
   fp = fopen("test.txt", "w");
   fprintf(fp, "This is written to the file.\n");
   fclose(fp);

   // Open file for reading
   fp = fopen("test.txt", "r");
   fscanf(fp, "%s", buffer);
   printf("Contents of file: %s\n", buffer);
   fclose(fp);

   return 0;
}

In this example, a file pointer named fp is declared as a FILE type. The fopen() function is used to open the file named "test.txt" in write mode with the w mode argument. The fprintf() function is used to write a string to the file, and the fclose() function is used to close the file.

Next, the file is opened again using fopen() in read mode with the r mode argument. The fscanf() function is used to read the contents of the file into the buffer array. Finally, the contents of the buffer array are printed to the console using printf(), and the file is closed again using fclose().

When this program is run, it will write the string "This is written to the file." to the "test.txt" file, and then read the contents of the file and print them to the console.

Void pointer is a generic pointer that can be used to point another variable of any data type. Null pointer is a pointer which is pointing to nothing.

Const pointer is a pointer that can’t change the address of the variable that is pointing to.
Once const pointer is made to point one variable, we can’t change this pointer to point to any other variable. This pointer is called const pointer.