Why does the indexing start with zero in 'C'?

Question

Why does the indexing in an array start with zero in C and not with 1?

Answer 1

Suppose we want to create an array of size 5
int array[5] = [2,3,5,9,8]

let the 1st element of the array is pointed at location 100

and let we consider the indexing starts from 1 not from 0.

now we have to find the location of the 1st element with the help of index
(remember the location of 1st element is 100)

since the size of an integer is 4-bit
therefore --> considering index 1 the position would be
size of index(1) * size of integer(4) = 4
so the actual position it will show us is

100 + 4 = 104

which is not true because the initial location was at 100.
it should be pointing to 100 not at 104
this is wrong

now suppose we have taken the indexing from 0
then
position of 1st element should be
size of index(0) * size of integer(4) = 0

therefore -->
location of 1st element is 100 + 0 = 100

and that was the actual location of the element
this is why indexing starts at 0;

I hope it will clear your point.

Answer 2

The most elegant explanation I've read for zero-based numbering is an observation that values aren't stored at the marked places on the number line, but rather in the spaces between them. The first item is stored between zero and one, the next between one and two, etc. The Nth item is stored between N-1 and N. A range of items may be described using the numbers on either side. Individual items are by convention described using the numbers below it. If one is given a range (X,Y), identifying individual numbers using the number below means that one can identify the first item without using any arithmetic (it's item X) but one must subtract one from Y to identify the last item (Y-1). Identifying items using the number above would make it easier to identify the last item in a range (it would be item Y), but harder to identify the first (X+1).

Although it wouldn't be horrible to identify items based upon the number above them, defining the first item in the range (X,Y) as being the one above X generally works out more nicely than defining it as the one below (X+1).

Answer 3

Because 0 is how far from the pointer to the head of the array to the array's first element.

Consider:

int foo[5] = {1,2,3,4,5};

To access 0 we do:

foo[0] 

But foo decomposes to a pointer, and the above access has analogous pointer arithmetic way of accessing it

*(foo + 0)

These days pointer arithmetic isn't used as frequently. Way back when though, it was a convenient way to take an address and move X "ints" away from that starting point. Of course if you wanted to just stay where you are, you just add 0!

Answer 4

Array name is a constant pointer pointing to the base address.When you use arr[i] the compiler manipulates it as *(arr+i).Since int range is -128 to 127,the compiler thinks that -128 to -1 are negative numbers and 0 to 128 are positive numbers.So array index always starts with zero.

Answer 5

The technical reason might derive from the fact that the pointer to a memory location of an array is the contents of the first element of the array. If you declare the pointer with an index of one, programs would normally add that value of one to the pointer to access the content which is not what you want, of course.

Answer 6

Because 0-based index allows...

array[index]

...to be implemented as...

*(array + index)

If index were 1-based, compiler would need to generate: *(array + index - 1), and this "-1" would hurt the performance.