Pointers and arrays are two closely related concepts in C programming. An array stores multiple values of the same data type in contiguous memory locations, while a pointer stores the address of a memory location. Since the name of an array represents the address of its first element, pointers and arrays often work together to access and manipulate data efficiently.
Understanding the relationship between pointers and arrays helps programmers write optimized code, perform dynamic memory operations, and pass arrays to functions effectively.
 

Table of Contents

---

What are Pointers and Arrays in C?

An array is a collection of elements stored in consecutive memory locations. A pointer is a variable that stores the address of another variable. When an array name is used without an index, it acts as a pointer to the first element of the array.
Syntax:

data_type array_name[size];
data_type *pointer_name;
pointer_name = array_name;

Example:

// C program to access array elements 
// using a pointer
#include stdio.h

int main()
{
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr;
    ptr = arr;
    printf("First Element = %d\n", *ptr);
    printf("Second Element = %d\n", *(ptr + 1));
    printf("Third Element = %d\n", *(ptr + 2));
    return 0;
}

Output:

First Element = 10
Second Element = 20
Third Element = 30

Explanation:

1. arr stores five integer values.
2. ptr = arr makes the pointer point to the first element of the array.
3. *ptr accesses the first element.
4. *(ptr + 1) accesses the second element.
5. *(ptr + 2) accesses the third element.

Relationship Between Pointers and Arrays

The array name represents the address of its first element.

arr == &arr[0]

Both expressions refer to the same memory location.

Example:

// C program to implement the 
// relationship between arrays and pointers
#include stdio.h

int main()
{
    int arr[3] = {5, 10, 15};
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    return 0;
}

Output:

0x7ffcbbc5cf74
0x7ffcbbc5cf74

Same address displayed in both statements.

Explanation:

1. arr points to the first element of the array.
2. &arr[0] explicitly gives the address of the first element.
3. Both expressions produce the same address.

Accessing Array Elements Using Pointer Notation

Array elements can be accessed through pointer arithmetic.
Syntax:

*(ptr + index)

Example:
 

// C program to print array elements
// uusing pointer
#include stdio.h

int main()
{
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr;

    for(int i = 0; i  5; i++)
    {
        printf("%d ", *(ptr + i));
    }

    return 0;
}

Output:

1 2 3 4 5

Explanation:

1. The pointer starts from the first element.
2. The pointer moves to the next element using ptr + i.
3. Dereferencing accesses the value stored at that location.

Accessing Array Elements Using Array Notation on Pointers

Pointers can also be used with array indexing. Below is the C program to access array elements using pointer indexing:
Example:
 

// C program to access array elements
// uusing pointer indexing
#include stdio.h

int main()
{
    int arr[4] = {10, 20, 30, 40};
    int *ptr = arr;

    for(int i = 0; i  4; i++)
    {
        printf("%d ", ptr[i]);
    }

    return 0;
}

Output:

10 20 30 40 

Explanation:

1. ptr[i] is equivalent to *(ptr + i).
2. Both methods access the same memory location.
3. This notation improves code readability.

Traversing an Array Using Pointers

Pointers provide an efficient way to traverse arrays. Below is the C program to traverse an array using pointer increment:
Example:
 

// C program to traverse an array using pointers
#include stdio.h

int main()
{
    int arr[5] = {11, 22, 33, 44, 55};
    int *ptr = arr;

    for(int i = 0; i  5; i++)
    {
        printf("%d ", *ptr);
        ptr++;
    }

    return 0;
}

Output:

11 22 33 44 55 

Explanation:

1. The pointer initially points to the first element.
2. ptr++ moves the pointer to the next array element.
3. Each dereference prints the current value.

Arrays of Pointers

An array can store multiple pointers.
Syntax:

data_type *array_name[size];

Example: 

// C program to store and print strings 
// using an array of pointers.
#include stdio.h

int main()
{
    char *names[] = {"Alice", "Bob", "Charlie"};

    for(int i = 0; i  3; i++)
    {
        printf("%s\n", names[i]);
    }

    return 0;
}

Output:

Alice
Bob
Charlie

Explanation:

1. Each array element stores the address of a string.
2. The array acts as a collection of pointers.
3. This approach is commonly used for string handling.

Passing Arrays to Functions Using Pointers

Arrays are passed to functions as pointers. Below is the C program to calculate the sum of array elements using a function:

// C program to pass array to functions 
// using pointers
#include stdio.h

int sum(int *arr, int size)
{
    int total = 0;

    for(int i = 0; i  size; i++)
    {
        total += *(arr + i);
    }

    return total;
}

int main()
{
    int numbers[] = {10, 20, 30, 40, 50};

    printf("Sum = %d", sum(numbers, 5));

    return 0;
}

Output:

Sum = 150

Explanation:

1. The array name is passed as an argument.
2. The function receives the address of the first element.
3. Pointer arithmetic is used to access each element.

Key Features of Pointers and Arrays

1. Direct Memory Access: Pointers allow direct access to array elements through memory addresses, making operations faster and more efficient.
2. Efficient Array Traversal: Pointer arithmetic enables quick traversal of arrays without repeatedly using indexing operations.
3. Easy Function Parameter Passing: Arrays can be passed to functions using pointers, reducing memory overhead because the entire array is not copied.
4. Dynamic Data Handling: Pointers can work with dynamically allocated arrays, allowing programs to manage memory at runtime.
5. Foundation for Advanced Data Structures: Pointers and arrays are widely used in linked lists, stacks, queues, trees, and other data structures.

Advantages of Using Pointers with Arrays

1. Faster Data Access: Pointers can access array elements directly through memory addresses, improving execution speed.
2. Reduced Memory Usage: Passing arrays as pointers avoids creating duplicate copies of large arrays.
3. Simplified Array Processing: Pointer arithmetic makes array traversal and manipulation easier.
4. Better Performance in Functions: Functions can process large arrays efficiently through pointers.
5. Support for Dynamic Arrays: Pointers enable dynamic memory allocation when the array size is not known at compile time.

Common Mistakes While Using Pointers and Arrays

1. Accessing Elements Beyond Array Bounds: Accessing memory outside the array range results in undefined behavior and may cause program crashes.

int arr[5];
printf("%d", arr[5]);

2. Dereferencing an Uninitialized Pointer: Using an uninitialized pointer can lead to unpredictable results because it points to an unknown memory location.

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

3. Incorrect Pointer Arithmetic: Moving a pointer beyond valid array boundaries can cause invalid memory access.

int arr[3] = {1,2,3};
int *ptr = arr;
ptr = ptr + 10;

4. Confusing Arrays with Pointers: Although arrays and pointers are closely related, they are not the same. Arrays allocate storage, while pointers only store addresses.

int arr[5];
int *ptr = arr;

5. Modifying the Array Name: The array name is a constant address and cannot be modified.

int arr[5];
arr++;

Difference Between Array and Pointer

Feature	Array	Pointer
Definition	An array is a collection of elements of the same data type.	A pointer is a variable that stores a memory address.
Memory Allocation	Memory is allocated for all elements at declaration time.	Memory is allocated only for storing an address.
Address	The array name represents a fixed address.	The pointer value can be changed to point to different locations.
Size	Array size is fixed after declaration.	A pointer can point to different arrays or variables.
Stored Value	Arrays directly store data values.	Pointers store the addresses of data.
Increment/ Decrement	Array names cannot be incremented.	Pointers can be incremented or decremented.

Conclusion

Pointers and arrays are fundamental concepts in C programming that work closely together. Since an array name represents the address of its first element, pointers can efficiently access and manipulate array data. Understanding pointer arithmetic, array traversal, arrays of pointers, and passing arrays to functions helps developers write efficient, optimized, and flexible C programs.

Frequently Asked Questions

1. What is the relationship between pointers and arrays in C?

The array name acts as a pointer to the first element of the array, which allows pointers to access array elements efficiently.

2. Is an array the same as a pointer?

No. An array stores multiple values, while a pointer stores the address of a memory location.

3. What does arr represent in an array?

arr represents the address of the first element, which is equivalent to &arr[0].

4. Why are pointers used with arrays?

Pointers provide efficient access, traversal, and manipulation of array elements while reducing memory overhead.

5. Can arrays be passed to functions in C?

Yes. Arrays are passed to functions as pointers to their first element.