CristGuard

Programming

How come an arrays address is equal to its value in C

19 September 2026 · 10 min read

How come an arrays address is equal to its value in C

Understanding how memory works in C is crucial for any aspiring programmer, and a common point of confusion arises when considering arrays. How come an array’s address is equal to its value in C? This intriguing behavior stems from the way C treats arrays and pointers. In essence, the name of an array, when used in most contexts, decays into a pointer to its first element. This doesn’t mean the array is a pointer, but rather, the compiler often interprets it as one. This subtle difference is at the heart of why the array’s name, when printed, yields the memory address of its initial element, which is often perceived as its “value.” We’ll explore this relationship in detail, uncovering the underlying mechanisms that make this happen, diving into pointer arithmetic, and looking at practical code examples to solidify your understanding. This deep dive will ensure a solid foundation for working with arrays and pointers in C.

The Array Name as a Pointer

In C, the name of an array is intrinsically linked to the memory location where its elements are stored. When you declare an array, for instance, int numbers[5];, the compiler allocates a contiguous block of memory to hold five integer values. The name numbers acts as a symbolic label for the starting address of this memory block. Now, here’s the crucial part: in many expressions, the C compiler implicitly converts the array’s name into a pointer to its first element. This conversion is known as “array decaying.”

Consider the following code snippet: int ptr = numbers;. Here, numbers decays into a pointer of type int, pointing to the first integer in the array. Therefore, ptr now holds the same address as numbers. Printing both numbers and ptr using printf("%p", (void)numbers); and printf("%p", (void)ptr); will yield identical memory addresses. This behavior is fundamental to how C handles arrays and allows for efficient manipulation using pointers. It’s also important to note that this decay doesn’t happen in all contexts; for example, when using the sizeof operator on an array, the array’s name represents the entire array, not just a pointer to the first element. Understanding these nuances is essential for writing correct and efficient C code.

The automatic conversion of an array’s name to a pointer to its first element is not just a syntactic convenience; it’s deeply rooted in C’s design philosophy of providing low-level access to memory. This design choice allows for highly optimized code but also necessitates careful attention to detail to avoid common pitfalls, such as out-of-bounds access or incorrect pointer arithmetic. For example, using numbers + 1 will give the address of the second element, demonstrating how pointers and array indexing are intimately related.

Understanding Pointer Arithmetic

Pointer arithmetic is the key to effectively working with arrays in C. Since the array’s name often behaves as a pointer to its first element, you can perform arithmetic operations on it to access other elements within the array. Adding an integer n to a pointer advances the pointer by n times the size of the data type it points to. For instance, if numbers is an array of integers, then numbers + 2 points to the third element in the array (remember, array indexing starts at 0).

Featured Snippet: The beauty of pointer arithmetic lies in its efficiency. Instead of using array indexing like numbers[i], which involves multiplication and addition, you can directly calculate the memory address using pointer arithmetic: (numbers + i). This dereferences the memory location pointed to by numbers + i, giving you the value of the element at index i. While the compiler often optimizes array indexing to be as efficient as pointer arithmetic, understanding the underlying mechanism is crucial for advanced C programming and performance tuning. According to Kernighan and Ritchie, the creators of C, “Pointer arithmetic is consistent; it automatically takes into account the size of the object pointed to.” [1]

However, it’s crucial to exercise caution when using pointer arithmetic. C doesn’t perform bounds checking on array accesses. If you accidentally increment a pointer beyond the bounds of the array, you’ll be accessing memory outside the allocated region, leading to undefined behavior, crashes, or security vulnerabilities. Always ensure that your pointer arithmetic stays within the valid bounds of the array. This is why using tools like static analyzers and debuggers is important during C development. This becomes especially critical when working with dynamically allocated arrays using malloc and calloc, where the potential for memory errors is even greater.

Practical Examples and Code Demonstrations

Let’s look at some code examples to illustrate how an array’s address is equal to its value in C:

include <stdio.h> int main() { int numbers[5] = {10, 20, 30, 40, 50}; printf("Address of the array: %p\n", (void)numbers); printf("Address of the first element: %p\n", (void)&numbers[0]); printf("Value of the first element: %d\n", numbers[0]); int ptr = numbers; printf("Address pointed to by ptr: %p\n", (void)ptr); printf("Value pointed to by ptr: %d\n", ptr); return 0; }

In this example, you’ll observe that the output of printf(“Address of the array: %p\n”, (void)numbers); and printf(“Address of the first element: %p\n”, (void)&numbers[0]); will be identical. This reinforces the concept that the array name numbers decays into a pointer to the first element. Furthermore, printf(“Value of the first element: %d\n”, numbers[0]); shows that accessing numbers[0] gives you the actual value stored at that memory location (which is 10 in this case), while printf(“Address of the array: %p\n”, (void)numbers); gives you the address of that location. When the array name is used in a context where an address is expected, it automatically provides the starting address.

Here’s another example demonstrating pointer arithmetic:

include <stdio.h> int main() { int numbers[5] = {10, 20, 30, 40, 50}; int ptr = numbers; printf("Value of the second element (using pointer arithmetic): %d\n", (ptr + 1)); printf("Value of the third element (using array indexing): %d\n", numbers[2]); return 0; }

This example demonstrates the equivalence between pointer arithmetic and array indexing. (ptr + 1) is equivalent to numbers[1], both accessing the second element of the array. These examples showcase the practical implications of understanding the relationship between arrays, pointers, and memory addresses in C. [2]

Array Decay and its Implications

Array decay, the implicit conversion of an array name to a pointer to its first element, has significant implications for function arguments. When you pass an array to a function, you’re not actually passing the entire array; instead, you’re passing a pointer to its first element. This means that within the function, you cannot determine the size of the original array using sizeof.

Consider this function:

void printArray(int arr[], int size) { for (int i = 0; i < size; i++) { printf("%d ", arr[i]); } printf("\n"); }

In this function, arr is declared as int arr[], which is equivalent to int arr. The size parameter must be explicitly passed because the function cannot determine the size of the array from the pointer alone. This is a crucial point to remember when working with arrays as function arguments. A common mistake is to omit the size parameter, leading to potential buffer overflows or incorrect processing of the array. Because of this design, C relies heavily on the programmer to manage memory and size information explicitly, contributing to both its power and its potential for errors.

Here’s a summary of key points to remember about array decay:

  • Array decay occurs when an array name is used in most expressions, converting it to a pointer to its first element.
  • Functions receive a pointer to the first element of an array, not a copy of the entire array.
  • The sizeof operator, when applied to an array name within the scope where the array is defined, returns the size of the entire array. However, within a function, sizeof applied to an array parameter will return the size of a pointer, not the size of the original array.

FAQ: Arrays and Pointers in C

Q: Is an array the same as a pointer in C?
A: No, an array is not the same as a pointer, although the array name often decays to a pointer to its first element. An array is a contiguous block of memory allocated to store elements of the same data type, while a pointer is a variable that stores the memory address of another variable.
Q: When does array decay not happen?
A: Array decay does not happen when the array is the operand of the sizeof operator or the & (address-of) operator, or when it is a string literal used to initialize a character array.
Q: How do I pass an array to a function in C?
A: You pass an array to a function by passing the array name, which decays to a pointer to the first element. You typically also need to pass the size of the array as a separate argument.
Q: What are the benefits of using pointers with arrays?
A: Using pointers with arrays allows for efficient memory manipulation, dynamic memory allocation, and the ability to pass arrays to functions without copying the entire array.
Here's a quick recap:
  • The array name often decays to a pointer to the first element.
  • Pointer arithmetic allows efficient array manipulation.
  • Functions receive a pointer to the first element, not the entire array. Understanding why an array’s address is equal to its value in C provides a powerful lens through which to view memory management and pointer manipulation. It’s a fundamental concept that unlocks more advanced programming techniques and allows you to write efficient and optimized C code. Continue experimenting with code, exploring different scenarios, and deepening your understanding of how C handles arrays and pointers. This knowledge will be invaluable as you tackle more complex programming challenges. [3] Ready to take your C skills to the next level? Consider diving into dynamic memory allocation with malloc and free, or exploring more advanced pointer techniques like function pointers. You might also want to check out resources on data structures and algorithms to see how these concepts are applied in real-world programming scenarios.

Question & Answer :
In the following bit of code, pointer values and pointer addresses differ as expected.

But array values and addresses don’t!

How can this be?

Output

my_array = 0022FF00 &my_array = 0022FF00 pointer_to_array = 0022FF00 &pointer_to_array = 0022FEFC 

#include <stdio.h> int main() { char my_array[100] = "some cool string"; printf("my_array = %p\n", my_array); printf("&my_array = %p\n", &my_array); char *pointer_to_array = my_array; printf("pointer_to_array = %p\n", pointer_to_array); printf("&pointer_to_array = %p\n", &pointer_to_array); printf("Press ENTER to continue...\n"); getchar(); return 0; }

The name of an array usually evaluates to the address of the first element of the array, so array and &array have the same value (but different types, so array+1 and &array+1 will not be equal if the array is more than 1 element long).

There are two exceptions to this: when the array name is an operand of sizeof or unary & (address-of), the name refers to the array object itself. Thus sizeof array gives you the size in bytes of the entire array, not the size of a pointer.

For an array defined as T array[size], it will have type T *. When/if you increment it, you get to the next element in the array.

&array evaluates to the same address, but given the same definition, it creates a pointer of the type T(*)[size] – i.e., it’s a pointer to an array, not to a single element. If you increment this pointer, it’ll add the size of the entire array, not the size of a single element. For example, with code like this:

char array[16]; printf("%p\t%p", (void*)&array, (void*)(&array+1));

We can expect the second pointer to be 16 greater than the first (because it’s an array of 16 char’s). Since %p typically converts pointers in hexadecimal, it might look something like:

0x12341000 0x12341010