When working with the C programming language, it is essential to understand the fundamental concepts of arrays and pointers. Both these constructs play a crucial role in manipulating and storing data. However, to write efficient and error-free programs, you must comprehend the distinct dissimilarities between arrays and pointers.  In this article, we will delve into the difference between array and pointer, shedding light on their unique characteristics and usage.

What is an Array?

An array in C is a data structure that allows you to store a fixed-size sequence of elements of the same data type. These elements are organized in a contiguous block of memory, and each member can be accessed by its index. The array index starts from zero, making it easy to locate and retrieve specific elements within the array. Let’s consider a practical example to illustrate the concept of an array:

int temperatures[5];
temperatures[0] = 23;
temperatures[1] = 25;
temperatures[2] = 22;
temperatures[3] = 24;
temperatures[4] = 21;

In the above example, we create an array called temperatures with a size of 5. We then assign values to each element using the array index. This organization allows us to work with a collection of temperature values efficiently.

Arrays are incredibly useful when dealing with large amounts of data that need to be accessed sequentially. However, arrays in C have a fixed size, meaning that you cannot change the size once you define it.

What is a Pointer?

A pointer, on the other hand, is a variable capable of holding the memory address of another variable. In C, pointers enable you to perform operations on variables indirectly, providing a level of flexibility and convenience. Here’s an example to illustrate the concept:

int *temperaturePtr;
int temperature = 23;
temperaturePtr = &temperature;

In the above code snippet, we declare a pointer called temperaturePtr, which can point to an integer variable. We then assign the memory address of the temperature variable to the pointer using the & operator. This allows us to indirectly manipulate the value of temperature via the pointer.

Pointers are particularly useful when it comes to dynamic memory allocation, passing arguments to functions by reference, and optimizing memory usage. However, they require careful handling to avoid memory leaks or accessing invalid memory locations.

Difference between Array and Pointer

While arrays and pointers may seem similar at first glance, they have distinct characteristics that set them apart:

Memory Allocation

  • Arrays allocate a fixed amount of memory when declared, depending on their size and data type. The compiler performs this memory allocation at compile-time.

  • Pointers, on the other hand, only store the memory address of a variable. They do not allocate memory for the data itself. Instead, they point to the memory allocated to the variable they are pointing to.


  • Arrays are primarily used for storing collections of data that can be accessed and manipulated using index-based notation. They provide a structured and straightforward approach to handling multiple values of the same type.

  • Pointers find extensive use in more complex scenarios, such as dynamic memory allocation, passing parameters by reference, and creating complex data structures like linked lists. They offer flexibility and efficiency in manipulating memory addresses.


  • Arrays have a fixed size determined at compile time, and you cannot change their size during runtime. This limitation can pose challenges when dealing with variable-sized data or dynamically changing requirements.

  • Pointers, being able to store memory addresses, offer the flexibility to point to different variables or dynamically allocate memory during runtime. This flexibility makes them suitable for scenarios that require dynamic memory management.

Accessing Elements

  • In arrays, we access individual elements using index notation. The index represents the position of the element within the array. Array indexing starts from 0.

  • Pointers, by dereferencing, allow access to the value stored at the memory location they point to. They provide a more indirect way of accessing data.

Size Calculation

  • The size of an array can be calculated using the sizeof operator, which returns the total number of bytes allocated to the array.

  • Pointers do not inherently store information about the size or type of the data they point to. Therefore, determining the size of the data pointed to by a pointer requires additional information or conventions.


Q: Can a pointer be used to access an array?

A: Yes, You can use a pointer to access array elements by incrementing the pointer’s value.

Q: Is it possible to change the size of an array during program execution?

A: No, Compile-time fixes the size of an array, and you cannot alter it during runtime.

Q: How is memory allocated to an array?

A: Memory allocation for an array occurs at compile-time based on the defined size and data type.

Q: Can arrays and pointers be used interchangeably?

A: No, arrays and pointers are distinct concepts in C and serve different purposes.

Q: What advantage does using pointers provide?

A: Pointers allow for dynamic memory allocation, efficient memory management, and the creation of complex data structures.

Q: Can a pointer be NULL?

A: Yes, You can assign a pointer a NULL value, indicating that it currently does not point to any valid memory location.


In summary, arrays and pointers serve distinct purposes in the C programming language. Arrays provide a structured way to store and access multiple values of the same type, whereas pointers offer flexibility and efficient memory management. Understanding the differences between arrays and pointers is essential for writing efficient and robust C programs.

Remember, understanding the nuances between arrays and pointers is crucial for mastering the use of these constructs in C programming. By leveraging their unique capabilities, you can write more efficient and versatile code.