Why does the indexing start with zero in C# arrays?

In C#, array indexing starts at zero because arrays are fundamentally based on memory addressing and offset calculations. This design choice has deep roots in computer science and provides both efficiency and logical consistency.

When an array is created, it occupies a contiguous block of memory. The array name acts as a pointer to the first element's memory address, and accessing elements involves calculating offsets from this base address.

Memory Layout and Addressing

Consider an integer array with 5 elements stored in memory. Since each int occupies 4 bytes, the memory layout would look like this −

Memory Address    Value    Array Index
0xFF000          35       arr[0]
0xFF004          23       arr[1] 
0xFF008          67       arr[2]
0xFF012          88       arr[3]
0xFF016          90       arr[4]

Why Zero-Based Indexing Makes Sense

The formula for calculating an element's memory address is −

Element Address = Base Address + (Index × Element Size)

With zero-based indexing, accessing the first element requires no offset calculation: arr[0] is simply at the base address. This makes array access efficient and mathematically elegant.

Length vs Index Relationship

Zero-based indexing creates a consistent relationship between array length and valid indices −

• Empty array: length = 0, no valid indices

• One element: length = 1, valid index = 0

• Two elements: length = 2, valid indices = 0, 1

• n elements: length = n, valid indices = 0 to (n-1)

Example: Array Creation and Access

using System;

class Program {
   public static void Main() {
      int[] numbers = {35, 23, 67, 88, 90};
      
      Console.WriteLine("Array length: " + numbers.Length);
      Console.WriteLine("Valid indices: 0 to " + (numbers.Length - 1));
      Console.WriteLine();
      
      for (int i = 0; i 

The output of the above code is −

Array length: 5
Valid indices: 0 to 4

numbers[0] = 35
numbers[1] = 23
numbers[2] = 67
numbers[3] = 88
numbers[4] = 90


Practical Benefits of Zero-Based Indexing

Example: Loop Patterns

using System;

class Program {
   public static void Main() {
      int[] arr = new int[5];
      
      // Initialize array with zero-based indexing
      for (int i = 0; i 

The output of the above code is −

Array elements:
Index 0: 10
Index 1: 20
Index 2: 30
Index 3: 40
Index 4: 50
Sum: 150


Mathematical Consistency

Conclusion

Zero-based indexing in C# arrays stems from the underlying memory addressing model where the first element requires no offset from the base address. This design provides computational efficiency, mathematical consistency, and aligns with the fundamental way computers access memory, making array operations both fast and intuitive.