Array numbering starting from 0 instead of 1

[bintom]

Hi!

I teach C++ in schools in India. I don't have a good answer when
students ask me why arrays in C++ are numbered from 0 to n-1 for an
array of n elements. I hope somebody can tell me.

Thanks
Binoy

 

[Ian Collins]

Hi!

I teach C++ in schools in India. I don't have a good answer when
students ask me why arrays in C++ are numbered from 0 to n-1 for an
array of n elements. I hope somebody can tell me.

I guess one answer is because C does.

Having started many years ago as an assembler programmer, I've always
thought of arrays as pointers to memory. The offset of the first
element is zero, which is the array index zero. Thus given

char n[4];

n+0 is equivalent to n[0];

 

[Salt_Peter]

Hi!

I teach C++ in schools in India. I don't have a good answer when
students ask me why arrays in C++ are numbered from 0 to n-1 for an
array of n elements. I hope somebody can tell me.

Thanks
Binoy

You have a stack of books on a table. The book at the bottom of the
pile is 0 books away from the table, its offset is zero. The next book
is a book away from the table, offset of 1.

Humans invented the decimal system because we have 10 fingers, label
each finger using a digit only. 10 is not a single digit.

The best answer is one involving range. If you know you have 10 books
then 10 is an upper limit:

const int n = 10;
books stack[n];

for( int i = 0; i < n; ++i ) { /*do stuff*/ }

Cover binary arithmetic, where a computer only has 0's and 1's. After
all, a 0 has just as much weight that a binary 1 does.
In the decimal system isn't the first decade 0 -> 9 ? How weird would
it be to suggest that the first decade is 1 -> 10 and the second 11 ->
20. If you would exclude 0 why not exclude 10 and 20 as well?

Those languages that do use index 1->10 in an array[10] allocate 11
elements and the first one is ignored / waisted.

 

[Rolf Magnus]

Hi!

I teach C++ in schools in India. I don't have a good answer when
students ask me why arrays in C++ are numbered from 0 to n-1 for an
array of n elements. I hope somebody can tell me.

The reason why it's like that in C++: The array notion a is equivalent to *(a+b), where usually, a is the address of the array's first element, and b is the index. So if you want the first element, b must be 0. Basically, that's how all computers do it. So if you have a language that starts at 1, like e.g. Matlab does, the interpreter has to subtract 1 from every index or alternatively leave the first element blank.

Generally, I'd rather ask why we tend to start counting at 1 instead of 0, but my guess is that this has historical reasons (for quite a long time, there was no number 0). Sometimes, however, we do count from 0, and sometimes, we even mx it up, like e.g. time. A day starts at hour 0, but a month starts at day 1. Kind of strange, isn't it?

 

[gw7rib]

Hi!

I teach C++ in schools in India. I don't have a good answer when
students ask me why arrays in C++ are numbered from 0 to n-1 for an
array of n elements. I hope somebody can tell me.

I guess one answer is because C does.

Having started many years ago as an assembler programmer, I've always
thought of arrays as pointers to memory.  The offset of the first
element is zero, which is the array index zero.  Thus given

char n[4];

n+0 is equivalent to n[0];

To go back further - C is derived from BCPL. In BCPL, you can create
an array as follows:

LET V = VEC 5

which would actually reserve an array of six members, from V!0 to V!5.
(It uses "!" instead of "[]".) So you could start from 1, and ignore
the first one; or start at 0 and ignore the last one; or start at 0
and use a number in the VEC that was one less than the number you
actually wanted. Presumably C and C++'s arrangement was supposed to be
an improvement on this.

 

[Stefan Ram]

I teach C++ in schools in India. I don't have a good answer when
students ask me why arrays in C++ are numbered from 0 to n-1 for an
array of n elements. I hope somebody can tell me.

http://www.purl.org/stefan_ram/pub/zero

 

[James Kanze]

bintom wrote:

The reason why it's like that in C++: The array notion a is
equivalent to *(a+b), where usually, a is the address of the
array's first element, and b is the index. So if you want the
first element, b must be 0. Basically, that's how all
computers do it. So if you have a language that starts at 1,
like e.g. Matlab does, the interpreter has to subtract 1 from
every index or alternatively leave the first element blank.

That's basically it. If you really want to make it clear,
however, without going into the nitty-gritty of transforming []
into * and +, consider "flatting" multidimensional arrays.
Given an array with dimension [10][10], for example, map the
indexes into those of an array [100]. With arrays based at 0,
it's simple 10*i+j. With arrays based at 1, you have to
subtract 1 from each index, then do the calcule, then add 1,
e.g. 10*(i-1)+j (with more dimensions, the difference becomes
even more apparent).

Generally, I'd rather ask why we tend to start counting at 1
instead of 0, but my guess is that this has historical reasons
(for quite a long time, there was no number 0).

Counting makes sense: if you have one book, you have one, and
not zero. It's indexing that doesn't, or rather ordinal
numbers in general.

 

[Pascal J. Bourguignon]

Hi!

I teach C++ in schools in India. I don't have a good answer when
students ask me why arrays in C++ are numbered from 0 to n-1 for an
array of n elements. I hope somebody can tell me.

http://en.wikipedia.org/wiki/Array

Why numbering should start at zero:
http://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html

 

[Bill Davy]

It might make the pill easier to swallow if you mention that zero is one of
India's great contribution to mathematics, along with a slew of famous
mathematicians.

 

[.rhavin grobert]

I guess one answer is because C does.

Having started many years ago as an assembler programmer, I've always
thought of arrays as pointers to memory.  The offset of the first
element is zero, which is the array index zero.  Thus given

As computers generally start counting at zero and for consistency, i
allway to prefer to say that the first array element in array x is
x[1]. x[0] is the zeroth element.

char n[4];

n+0 is equivalent to n[0];