Pointer Declaration in C

Before using a pointer, it must be declared just like any other variable. A pointer declaration tells the compiler the type of data whose address the pointer will store.

A pointer declaration consists of three parts:

• The data type of the variable whose address will be stored.
• An asterisk (*), which indicates that the variable is a pointer.
• The pointer variable name.

data_type *pointer_name;

Examples of Pointer Declaration:

int *ptr1;
char *ptr2;
float *ptr3;
double *ptr4;

Each pointer is capable of storing the address of a variable having the corresponding data type.

Pointer Naming Rules

A pointer variable follows the same naming rules as any other variable in C. You can choose any meaningful name, provided it follows the identifier rules of the language.

Valid Pointer Names

int *ptr;
int *numberPointer;
float *salaryPtr;
char *studentName;

Initialization of a Pointer Variable

Declaring a pointer only creates the pointer variable; it does not assign any valid memory address to it. Before using a pointer, it should always be initialized with the address of an existing variable or with NULL.

Using an uninitialized pointer is unsafe because it may contain an unpredictable memory address, leading to undefined behavior or program crashes.

Example

int num = 26;
int *ptr;
ptr = #

In the above example:

• num stores the value 26.
• &num returns the memory address of num.
• The pointer ptr stores this memory address.

The Address-of Operator (&)

The address-of operator (&) is a unary operator that returns the memory address of a variable. It is commonly used while assigning an address to a pointer.

Example

int num = 50;
printf("%p", &num);

The expression &num returns the memory address where the variable num is stored.

The Dereference Operator (*)

The asterisk (*) is known as the dereference operator or indirection operator. It is used to access the value stored at the memory address held by a pointer.

Example

int num = 50;
int *ptr = #
printf("%d", *ptr);

Although ptr stores the address of num, the expression *ptr retrieves the value stored at that address.

Understanding Pointers with Memory Representation

To understand pointers properly, it is important to know how variables are stored in memory. Whenever a variable is declared, the compiler reserves some memory for it. Every memory location has a unique address, and the variable stores its data at that address.

A pointer does not store the actual data. Instead, it stores the memory address where the data is located. By using this address, the pointer can indirectly access or modify the value of the variable.

First Pointer Program

The following program demonstrates how a pointer stores the address of a variable and how the value can be accessed using the dereference operator.

#include <stdio.h>
int main()
{
    int num = 25;
    int *ptr;
    ptr = &num;
    printf("Value of num = %d\n", num);
    printf("Address of num = %p\n", &num);
    printf("Value stored in ptr = %p\n", ptr);
    printf("Value using *ptr = %d\n", *ptr);
    return 0;
}

Understanding Each Expression

The following table summarizes the meaning of the most commonly used pointer expressions.

Modifying a Variable Using a Pointer

One of the biggest advantages of pointers is that they allow us to modify the value of a variable indirectly. Instead of changing the variable directly, we can access its memory location through a pointer and update the value stored there.

Since a pointer stores the address of a variable, any modification made through the pointer is actually performed on the original variable.

Program: Changing the Value Through a Pointer

#include<stdio.h>
int main()
{
    int num = 25;
    int *ptr = &num;
    printf("Before Modification = %d\n", num);
    *ptr = 100;
    printf("After Modification = %d\n", num);
    return 0;
}

Another Example

A pointer can be used to update the value of a variable multiple times. Every change made through the pointer is immediately reflected in the original variable.

#include<stdio.h>
int main()
{
    int marks = 70;
    int *ptr = &marks;
    printf("Original Marks = %d\n", marks);
    *ptr = 85;
    printf("Updated Marks = %d\n", marks);
    return 0;
}

Output

Original Marks = 70
Updated Marks = 85

Direct Modification vs Pointer Modification

Size of a Pointer in C

One of the most common misconceptions among beginners is that the size of a pointer depends on the type of data it points to. In reality, the size of a pointer is determined by the computer architecture (or memory model), not by the data type.

Whether a pointer stores the address of an int, char, float, or double, it always stores only a memory address. Since every memory address on a particular system has the same size, all pointer variables occupy the same amount of memory.

Pointer Size on Different Architectures

The following table shows the typical size of pointers on different computer architectures.

Program: Finding the Size of Different Pointers

The following program demonstrates that pointers of different data types occupy the same amount of memory.

#include<stdio.h>
int main()
{
    int *iptr;
    char *cptr;
    float *fptr;
    double *dptr;
    printf("Size of int pointer = %u Bytes\n", sizeof(iptr));
    printf("Size of char pointer = %u Bytes\n", sizeof(cptr));
    printf("Size of float pointer = %u Bytes\n", sizeof(fptr));
    printf("Size of double pointer = %u Bytes\n", sizeof(dptr));
    return 0;
}

Why Do All Pointers Have the Same Size?

Regardless of the data type, every pointer stores only a memory address. Since all memory addresses on a particular architecture require the same number of bytes, every pointer occupies the same amount of memory.

The data type associated with a pointer is used only to tell the compiler how to interpret the data stored at that address. It does not affect the amount of memory required to store the address itself.

Common Misconceptions

Types of Pointers in C (Basic Introduction)

Depending on their state and usage, pointers can behave differently during program execution. Some pointers work correctly, while others may lead to unexpected behavior or even program crashes if not handled carefully.

The most commonly used pointer types are listed below:

• NULL Pointer
• Wild Pointer
• Dangling Pointer
• Void Pointer (Generic Pointer)

Let's understand each of them one by one.

1. NULL Pointer

A NULL pointer is a pointer that does not point to any valid memory location. Instead of storing the address of a variable, it stores the special value NULL.

Initializing a pointer with NULL is considered a good programming practice because it clearly indicates that the pointer is currently not pointing to any valid object.

int *ptr = NULL;

Example:

#include <stdio.h>

int main()
{
    int *ptr = NULL;
    printf("%p", ptr);
    return 0;
}

Important: A NULL pointer should never be dereferenced. Attempting to access *ptr when ptr is NULL results in undefined behavior and may crash the program.

2. Wild Pointer

A wild pointer is a pointer that has been declared but has not been initialized with a valid memory address. Since it contains an unknown (garbage) address, using it may lead to unpredictable results.

Example:

int *ptr;

In the above declaration, the pointer exists but does not point to any valid memory location.

Incorrect Usage

int *ptr;
*ptr = 10;// Dangerous

3. Dangling Pointer

A dangling pointer is a pointer that refers to a memory location that is no longer valid. This situation commonly occurs when dynamically allocated memory is freed, but the pointer still stores the old address.

Example:

int *ptr;
ptr = (int *)malloc(sizeof(int));
free(ptr);
/* ptr is now a dangling pointer */

After calling free(), the allocated memory is released, but ptr still contains the old address. Accessing this address results in undefined behavior.

free(ptr);
ptr = NULL;

4. Void Pointer (Generic Pointer)

A void pointer, also known as a generic pointer, can store the address of variables belonging to any data type. Unlike typed pointers, it is not associated with a specific data type.

Example

int num = 25;
void *ptr = #

Since a void pointer has no type information, it cannot be dereferenced directly. Before accessing the stored value, it must first be converted to the appropriate pointer type.

printf("%d",*(int*)ptr);

Comparison of Different Pointer Types

Pointer Arithmetic in C

A pointer stores the memory address of a variable. Just like numeric variables, pointers also support certain arithmetic operations. These operations are known as pointer arithmetic.

Pointer arithmetic allows a pointer to move from one memory location to another. It is widely used while working with arrays, strings, dynamic memory allocation, and data structures such as linked lists.

Operations Allowed on Pointers

The following arithmetic operations can be performed on pointers:

Why Does Not ptr+1 Increase by One Byte?

This is one of the most frequently asked interview questions.

When we add 1 to a pointer, the compiler automatically increases the address by the size of the data type to which the pointer points.

Pointer Arithmetic with Arrays

Pointer arithmetic becomes especially useful while working with arrays because array elements are stored in contiguous memory locations.

int arr[]={11,22,33,44};
int *ptr=arr;
printf("%d\n",*ptr);
printf("%d\n",*(ptr+1));
printf("%d\n",*(ptr+2));
printf("%d\n",*(ptr+3));

Output

11
22
33
44