Pointers and arrays are two important concepts in C programming. Since array names often behave like pointers, beginners frequently assume that pointers and arrays are the same. While they are closely related, they are not identical.
An array is a collection of elements stored in contiguous memory locations, whereas a pointer is a variable that stores the memory address of another variable. Understanding the differences between pointers and arrays is essential for writing efficient and error-free C programs.
In this article, you will learn the difference between pointers and arrays in C with syntax, examples, comparison tables, and practical applications.
 

Table of Contents

---

What is an Array in C?

An array is a collection of elements of the same data type stored in consecutive memory locations.
Syntax:

data_type array_name[size];

Example:

int numbers[5] = {10, 20, 30, 40, 50};

In this example, numbers contain five integer values stored sequentially in memory.

Advantages of Arrays

1. Easy Storage of Multiple Values: Arrays allow multiple values of the same type to be stored under a single name.
2. Faster Element Access: Elements can be accessed directly using their index, making retrieval efficient.
3. Contiguous Memory Allocation: Array elements are stored sequentially, which improves cache performance.
4. Simplifies Data Management: Managing a group of related data becomes easier with arrays.
5. Useful for Sorting and Searching: Many algorithms, such as sorting and searching, are designed to work efficiently with arrays.

What is a Pointer in C?

A pointer is a variable that stores the memory address of another variable.
Syntax:

data_type *pointer_name;

Example:

int num = 10;
int *ptr = #

Here, ptr stores the address of the variable num.

Advantages of Pointers

1. Dynamic Memory Management: Pointers enable dynamic memory allocation using functions like malloc() and calloc().
2. Efficient Function Calls: Pointers allow call-by-reference, reducing memory usage and execution time.
3. Flexible Data Handling: A pointer can point to different variables during program execution.
4. Supports Complex Data Structures: Linked lists, trees, graphs, and other structures rely heavily on pointers.
5. Direct Memory Access: Pointers provide direct access to memory locations for advanced programming tasks.

Can an Array Name Be Modified?

No. An array name acts as a constant pointer to the first element of the array.
Invalid Example:

int arr[5];
arr++;

Error:

Error: lvalue required as increment operand

The array name cannot be incremented or assigned a new address.

Can a Pointer Be Modified?

Yes. A pointer variable can point to different memory locations.
Example:

// C program to modify a pointer
#include stdio.h

int main()
{
    int a = 10;
    int b = 20;
    int *ptr = &a;
    printf("%d\n", *ptr);
    ptr = &b;
    printf("%d\n", *ptr);
    return 0;
}

Output:

10
20

Difference Between Pointer and Array in C

Basis of Comparison	Array	Pointer
Definition	An array is a collection of elements of the same data type stored in contiguous memory locations.	A pointer is a variable that stores the memory address of another variable.
Memory Allocation	Memory for all elements is allocated when the array is declared.	Memory is allocated only for storing an address.
Nature	An array is not a variable; it represents a fixed block of memory.	A pointer is a variable and can store different addresses.
Address Storage	An array stores actual data values.	A pointer stores memory addresses.
Reassignment	The array name cannot be reassigned to another memory location.	A pointer can be reassigned to point to different variables.
Increment Operation	Array names cannot be incremented using operators like ++.	Pointers can be incremented and decremented.
Memory Size	Size depends on the number of elements and their data type.	Size depends on the system architecture, typically 4 or 8 bytes.
Data Storage	Stores actual values directly.	Stores addresses of values.
Flexibility	Less flexible because its size is fixed after declaration.	More flexible because it can point to different memory locations.
Initilaization	Values are stored directly inside the array.	Must be assigned an address before use.
Access Method	Elements are accessed using indices.	Data is accessed using dereferencing.
Dynamic Memory Support	Arrays cannot dynamically change their size.	Pointers can work with dynamically allocated memory.
Memory Modification	Array location remains fixed throughout execution.	Pointer value can change during execution.
Usage	Primarily used for storing collections of data.	Used for dynamic memory management, function arguments, and efficient data access.
Relationship with Address	Array name represents the base address of the array.	Pointer explicitly stores an address.

Example Showing Pointers and Arrays

Below is the C program implementing pointers and arrays:

// C program implementing pointers 
// and arrays
#include stdio.h

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

    printf("First array element: %d\n", arr[0]);
    printf("Using pointer: %d\n", *ptr);

    ptr++;

    printf("Next element using pointer: %d\n", *ptr);

    return 0;
}

Output:

First array element: 10
Using pointer: 10
Next element using pointer: 20

Common Mistakes When Working with Arrays and Pointers

1. Assuming Arrays and Pointers Are Identical: Although array names often behave like pointers, arrays and pointers are different concepts.
2. Incrementing an Array Name: Array names cannot be incremented or reassigned.
3. Using Uninitialized Pointers: Dereferencing an uninitialized pointer may lead to undefined behavior.
4. Accessing Elements Outside Array Bounds: Accessing invalid indices can cause memory corruption.
5. Forgetting to Dereference Pointers: A pointer stores an address. To access the value, the dereference operator (*) must be used.

Conclusion

Pointers and arrays are closely related in C, but they are not the same. An array stores a collection of elements in contiguous memory locations, while a pointer stores memory addresses. Array names act like constant pointers to the first element, but they cannot be modified or reassigned. Pointers, on the other hand, are variables that can point to different memory locations and support dynamic memory management. Understanding these differences helps programmers write more efficient and reliable C programs.

Frequently Asked Questions

1. Are pointers and arrays the same in C?

No. Arrays store data, while pointers store memory addresses. They are related but not identical.

2. Why does an array name behave like a pointer?

The array name represents the address of the first element, allowing pointer-style access to array elements.

3. Can an array name be reassigned?

No. The array name is fixed and cannot be assigned a different address.

4. Can a pointer point to an array?

Yes. A pointer can store the address of the first element of an array and access its elements.

5. Which is better, an array or a pointer?

Neither is universally better. Arrays are suitable for fixed-size collections, while pointers provide flexibility and support dynamic memory management.