Почему в программировании счёт всегда начинается с нуля, а не с единицы

В проектах мы периодически говорим, что компьютер почти всё начинает считать с нуля, а не с единицы. Это значит, что первый элемент массива вызывается командой arr[0], второй — arr[1], а шестой — arr[5]. Объясняем, почему так.

Память, переменные и первый байт

Чтобы что-то посчитать, компьютеру нужно место, куда он будет записывать результаты подсчёта. Это место — какие-то ячейки памяти.

Физически ячейка памяти — это транзистор, у которого может быть два состояния: открытый или закрытый (как краны с водой). Эти состояния мы называем «логический ноль» и «логическая единица».

Минимальная ячейка, в которой может лежать единица или ноль, называется бит. Но в бите можно закодировать только 1 или 0 или «да/нет». Чтобы кодировать что-то более сложное, нужно взять не один бит, а группу. В компьютере принято объединять биты в группы по 8, такая группа называется «байт». 

Получается, что байт — это 8 транзисторов памяти, которые компьютер интерпретирует как единое целое (например, число). Внутри байта находятся логические нули или единицы, стоящие в любом порядке.

Кодирование происходит в двоичной системе: в зависимости от расположения логических единиц и нулей подразумеваются разные числа в привычной нам десятичной системе счисления. Например:

00000000 — ноль, минимальное значение байта

00000001 — один

00000010 — два

00000011 — три

00000100 — четыре

00000101 — пять

…

11111110 — двести пятьдесят четыре

11111111 — двести пятьдесят пять, максимальное значение байта

Обратите внимание, что минимальное значение, которое можно хранить в одном байте — не единица, а именно ноль.

Логика компьютера

Теперь представьте: компьютер исполняет программу, где ему нужно обойти какой-нибудь массив и что-то там подсчитать. Для обхода массива ему нужна область памяти для подсчёта. Что происходит дальше:

Благодаря тому что компьютер начинает считать с нуля, в 8 бит он может поместить 256 значений: от 0 до 255. Если бы компьютер считал от 1 до 255, в 8 бит поместилось бы 255 значений — то есть на одно меньше. 

Можно ли всё-таки считать с 1?

Можно, но это необычно. Чтобы компьютер начал считать всё с единицы, нам нужно объяснить ему, как это делать. Например, подход может быть таким:

При этом с точки зрения компьютера в массиве всё равно будет 101 элемент, которые он будет начинать считать с нуля. Но человеку так может быть удобнее, когда номера элементов совпадают с его порядковым номером.

Как ошибаются из-за счётчиков с нуля

Самая частая ошибка при начале счёта с нуля — путать между собой длину массива и индекс последнего элемента. Следите за руками:

Эта же ошибка встречается и в циклах, когда нам нужно перебрать все индексы с первого до последнего. Чаще всего начинают считать с единицы и пропускают нулевой элемент.

Как грамотно обойти массив с помощью счётчиков на разных языках (и не запутаться в единицах и нулях)

Представим, что у нас есть массив arr[], в котором хранится 100 чисел, и нам нужно вывести их на экран. 

Классический алгоритм такой:

Пример такого кода в JavaScript:

for (var i = 0; i++, i<arr.length) { console.log(arr[key]) }

В Python:

for i in range(len(arr)):
    print(arr[i])

В C++:

for(int i = 0; i < length; i++)
{
   std::cout << arr[i];
}

Обход массивов вообще без счётчиков (и связанных с ними нулей)

В некоторых языках есть более компактная версия этой конструкции, которая буквально означает «Обойди этот объект». Вот примеры в JavaScript:

for (var i in arr) { console.log(arr[i]) }

В Python: 

for i in arr:
    print(i)

Здесь нужно смотреть на слово in, что буквально означает «по всем составляющим этого объекта». В разных языках у него разное значение

То есть JavaScript использует for…in для простого управления счётчиками, а Python вообще избавляется от понятия счётчика и сразу отдаёт в переменную то значение, которое он сейчас перебирает. 

Если совсем просто: 

Но это если уже совсем угореть. Всё, хорош, и так понятно: компьютеры считают с нуля.