Хотя приведенные ниже принципы применимы и к десятичной, и к любой другой базе, отсчет от 0 в компьютерах можно легко понять из двоичной системы с фиксированными цифрами представления чисел, используемых в компьютерах. Если у вас есть 8 битов, то есть 256 возможных комбинаций 1 и 0, которые могут быть выражены. Вы можете использовать эти 8-битные числа для выражения чисел 1-256, но при этом не будет 0, что полезно в математике как само по себе число, поэтому они используются для выражения чисел 0-255.

Это уже устанавливает прецедент естественного порядка, начиная с 0 (все 0 в двоичном представлении) до 255 (все 1 в 8-битном числе). Рассматривая систему представления чисел, начинать с 0 имеет смысл, поскольку 0 - это "первое" число в системе, поэтому 1 - это "второе" число и так далее.

Дополнительная причина, по которой начинать с 0 в компьютерах так удобно, связана с концепцией смещений. Смещение - это число, представляющее расстояние от места в памяти или на жестком диске или любом другом "адресуемом" носителе. В компьютерах практически все данные хранятся линейно, что означает, что существует порядок данных: первый байт, второй байт и т. Д. Удобно выражать местоположение "областей" данных через смещение. Какой первый байт в блоке данных? Он находится со смещением "0", что означает, что он находится в 0 байтах после первого байта в блоке данных. Несмотря на то, что "1" может обозначать первый байт, это создает сложности при представлении данных по нескольким причинам:

• Исключая использование 0 для адресации данных, вы сокращаете число вещей, к которым вы можете обращаться с помощью 8-битного числа, на единицу.
• Чтобы вычислить смещение, которое необходимо на аппаратном уровне доступа к данным, в какой-то момент вы должны вычесть одно из нумерации, что представляет сложность.
• Указатели на блок данных всегда указывают на первый блок, поэтому арифметика проста, когда вы начинаете с 0. (т.е. 1-й байт в первом блоке первого кластера данных равен 0 + 0 + 0, когда вы начинаете с 0, это 1 + 1 + 1 - 1 -1, когда вы начинаете с 1.) Арифметика для этого, когда вы начинаете с 1 с вложенными структурами данных, как этот пример, может сбивать с толку.

Никогда не думал, что такая возможность для такого философа, как я, появится на Суперпользователе. В основе лежит фундаментальное заблуждение, потому что нефилософы склонны пропускать мелкие детали. Вкратце: компьютеры не отсчитывают от нуля, но наименование позиций начинается с нуля.

В этом кажущемся несоответствии между компьютерной и человеческой (любой) техникой подсчета нет ничего странного. Давайте разложим вопрос.

Почему компьютеры считают с нуля?

• Они не считаются с нуля

Компьютеры подсчитывают значения, начиная с нуля. Например, массивы в C.

• Индекс (индикатор положения, счетчик) начинается с нуля. Количество элементов в массиве, где есть один элемент с нулевым индексом, равно единице.

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

В том же смысле, что и средняя точка шкалы, ноль можно использовать для представления самого края (абсолютного начала) коллекции. Вопрос не имеет смысла, потому что он не согласуется между "значениями подсчета" и "отсчетом с нуля".

Так что да, компьютеры подсчитывают с нуля, но они считаются с одного. Два слова имеют разное значение.

tal·ly [tal-ee]

имя существительное

1. счет или расплата; запись дебета и кредита, счета в игре или тому подобное.
2. все, на чем ведется счет или счет..
3. количество или группа записанных предметов.

считать [ количество ]

глагол (используется с объектом)

1. проверять (отдельные единицы или группы коллекции) одну за другой, чтобы определить общее количество; сложить; перечислите: он пересчитал свои билеты и обнаружил, что у него было десять.
2. считаться; вычислить; вычислить.
3. перечислить или назвать цифры до: Закройте глаза и сосчитайте до десяти.

(Dictionary.com)

Практические причины адекватно описаны Дугви, мне нечего там добавить. Если бы только у нас был профессор CS (из 60-х), чтобы дать исторический отчет...

Я думаю, что это уже упоминалось " проф. Д-р Эдсгер В. Дейкстра" - научный сотрудник Берроуза в письме от 11 августа 1982 г.: cf EWD831

Под названием: Почему нумерация должна начинаться с нуля. "Есть ли причины отдавать предпочтение одному соглашению другому? Да, есть...."

Также обратите внимание, что Дейкстра был в команде разработчиков ALGOL 68 до 1968 года. Algol68 допускает массивы либо от 0, 1, либо от любого числа, которое программист сочтет подходящим для алгоритма. cf ( "Создание Алгола 68" рассказывает: "Можете ли вы определить треугольные массивы?" кто-то (Тони Хоар?) прервал. "Не только треугольный, но даже эллиптический", ответил Аад и показал, как ".)

В частности, в Algol68, когда массивы (и матрицы) срезаются, они получают индекс @1, поэтому наблюдается смещение к массивам [1:...]. Но "1-^ую" нижнюю границу можно переместить, чтобы начать с "0-^й" позиции, указав "@0", например, вектор x[4:99@2], матрицу y[4:99@1,4:99@0]. Аналогично, по умолчанию / смещение от 1 в циклах do ~ od (если явно не указано "from 0") и от 1 для целочисленного случая i в ~, ~, ~ esac и $c(~,~,~)$ выбор статей.

Похоже, что комментарии Дейкстры о мартовском проекте отчета 1968 года ( MR93) и его настойчивость спровоцировали то, что, возможно, является пламенной войной до использования: "есть сочинения, которые привлекательны, хотя и не грамматичны, и есть другие сочинения, которые являются чрезвычайно грамматическими, но отвратительно. Это то, что я не могу объяснить поверхностным людям ". EWD230

Заключительный отчет Алгола 68 (FR) был опубликован 20 декабря 1968 года, когда он был представлен на Мюнхенской встрече, а затем принят Рабочей группой. Впоследствии отчет был утвержден Генеральной Ассамблеей ИФИП ЮНЕСКО для публикации.

Около 23 декабря (?) 1968 года Дейкстра, Дункан, Гарвик, Хоар, Рэнделл, Зигмюллер, Турски, Вуджер и Гарвик подписали "Отчет меньшинства" AB31.1.1.1, стр. 7 (опубликован в 1970 году).

Дистанционная аналогия, приведенная кем-то другим, дает очень практическую иллюстрацию:

"Как далеко ваш дом от ближайшей заправки?"

"1 миля"

"Вы живете на заправке?"

"Нет, если бы я жил на заправке, это было бы 0 миль"

"Почему ты считаешь с нуля, а не с одного?"

Другим хорошим примером могут быть дни рождения - мы не говорим, что кому-то исполнился год, а мы - год спустя.

Мы говорим о високосных годах или президентских выборах в США каждые четыре года, даже если считать одно: 2000, 2001, 2002, 2003, 2004 годы - это пять лет. (Между прочим, римляне на некоторое время облажались, и високосные годы были слишком близко друг к другу)

Моя точка зрения заключается в том, что в реальном мире мы "отсчитываем" от нуля все время - "Сколько позиций после [начала массива] - это элемент, который вы хотите" просто оказывается вопросом, на который вы отвечаете с отсчетом от нуля во многих компьютерных программах. Вы бы не сказали, что первый элемент - одна позиция после старта, не так ли? Это начало.

Как уже говорили другие компьютеры, не считайте с нуля.

Индекс некоторых языков от 0. Индексирование от 0 имеет два основных преимущества:

1. Он преобразуется в сборку естественным образом, поскольку его можно интерпретировать как смещение от указателя на первую позицию.

2. Вы не получаете странности, когда вы хотите негативы. Сколько лет между 1BC и 1AD? Никто. Потому что, хотя до н.э. фактически отрицательные даты, нулевого года нет. Если бы был 0AD, не было бы здесь никаких проблем. Вы видите ту же проблему повсюду в науке, где люди наивно определили первый элемент в наборе как +1.

Подсчет естественно начинается с нуля

Вот алгоритм подсчета яблок в корзине:

count := 0

for each apple in basket
   count := count + 1

После выполнения вышесказанного, count держит количество яблок. Это может быть ноль, потому что корзины могут быть пустыми.

Если вы не пользуетесь своей кредитной картой целый месяц, получаете ли вы счет в 1 доллар? Или 1 цент?

Когда вы сбрасываете счетчик пробега на одометре вашего автомобиля, он переходит на 0001 или 0000?

Массивы могут предоставлять несколько представлений одних и тех же данных.

Рассмотрим массив 32-битных структур d каждое из которых состоит из 16-битных слов w, Каждое слово состоит из двух 8-битных байтов b, При нулевой индексации наложение выглядит очень удобно:

d: |   0   |   1   |
w: | 0 | 1 | 2 | 3 |
b: |0|1|2|3|4|5|6|7|

32-битный объект d[1] как при слове адрес w[2] который легко вычисляется путем умножения индекса на 2, который является отношением размеров 32- и 16-битного объекта. Кроме того, в байтовой адресации это b[4],

Это работает, потому что ноль равен нулю в каждой единице измерения: байт, слово, двойное слово и так далее.

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

С одним основанным индексированием это ломает:

d: |   1   |   2   |
w: | 1 | 2 | 3 | 4 |
b: |1|2|3|4|5|6|7|8|

Теперь мы не можем просто умножить d индекс на 2, чтобы получить w индекс, или на 4, чтобы получить b индекс. Преобразование между единицами становится неуклюжим. Например, чтобы перейти от d[2] в b[4]мы должны рассчитать ((2 - 1) * 4) + 1 = 5,

Мы должны вычесть это противное 1 смещение в d единиц, затем выполните масштабирование в естественной системе координат, основанной на нуле, а затем добавьте обратно 1 b единицы. Обратите внимание, что это не то же самое 1! Мы вычитаем ширину одного двойного слова, но затем добавляем ширину в один байт.

Преобразование между различными представлениями данных становится чем-то вроде преобразования Цельсия-Фаренгейта.

Те, кто говорят, что с одноосновными массивами легко иметь дело на уровне реализации, потому что есть только простое вычитание 1, обманывают себя и вас. Это верно только в том случае, если мы не делаем никаких вычислений масштабирования для различных типов данных. Такие вычисления выполняются в любой программе, которая имеет гибкий взгляд на данные (например, многомерный массив, также доступный как одномерный) или который управляет хранением: например, распределитель памяти, файловая система или библиотека буфера видеокадров.

Минимизация цифр

В любой базе, если мы хотим использовать наименьшее количество цифр для реализации диапазона значений, который является степенью основания, мы должны начинать с нуля. Например, в базовой десятке трех цифр достаточно, чтобы дать нам тысячу различных значений от 0 до 999. Если мы начнем с 1, мы переполняемся только одним значением, и нам нужны четыре цифры.

Это важно в компьютерах, потому что количество цифр в двоичном коде переводится в аппаратные адресные строки. Например, чип ПЗУ с 256 словами в нем может быть адресован от 0 до 255, что требует 8 битов: от 00000000 до 11111111. Если он адресован от 1 до 256, то необходимы девять битов. Мы должны расточительно добавить еще одну трассировку адресов к плате или интегральной схеме. Таким образом, на практике возможно, что 0 будет просто называться 1 на уровне программного API для доступа к этому чипу. Запрос слова 1 фактически поместил бы 00000000 на 8-битную адресную шину. В противном случае запрос на 1 будет преобразован в адрес 00000001, как и ожидалось, но запрос на 256 будет сопоставлен с неиспользуемым 8-битным адресом 00000000, а не 9-битным адресом 100000000. поиск проблемы и полностью исключаются путем последовательного использования от 0 до 255 на оборудовании, в программном обеспечении и во всех пользовательских интерфейсах и документации.

Единичные смещения в корне глупы

Рассмотрим, например, западную теорию музыки. У нас есть диатонические весы с семью нотами, но мы называем пространство, которое они покрывают октавой! Inversion of intervals then follows the rule of nine: for instance the inversion of a third is a sixth (subtract three from nine). So three different numbers are at play for something so simple: seven (notes in a scale), eight (octave) and nine (subtract from to invert).

If seven notes made a septave or heptave, and intervals were zero based, then we would subtract from seven to invert. Everything based on seven.

Furthermore, intervals could be easily stacked. In the current system, if we leap by a fifth and then by a fourth again, and then by a third, we cannot just add these. The resulting interval is two less. It is not a twelvth, but actually a tenth! At each stage, we have to subtract a one. Going up by a fifth and then a fourth isn't a ninth, but only an octave.

In a sanely designed music system, we could just add intervals to determine the resulting leaps. A sequence of notes which begins and ends on the same note would then have a property similar to the voltage law around a circuit: all the intervals would add to zero.

Music theory and writing is badly outdated. Most of it has not changed since the days composing was done with quill pens by the light of a candle.

One-based systems confuse the same people who can't handle zero-based arrays

When the year 2000 rolled around, many people were confused why the new millennium hasn't begun. Those pointing out that it won't begin until 2001 were regarded as party poopers and dweebs. After all, you're in your 20's when you turn 20, right? Not when you turn 21. If you thought that the millennium started on January 1, 2000, then you have no right to complain about zero based arrays in any programming language. They work how exactly how you like. (But, yes, proponents of one-based displacements and arrays are dweebs and party-poopers. Centuries should start on the XX00 years, and millennia on X000 years.)

Calendars are dumb, but at least time of day is zero based

Each new minute on your watch starts with:00 seconds. Each new hour starts with 00:00 minutes and seconds. And, at least on a 24 hour clock, the day rolls around when midnight strikes and 11:59:59 increments to 00:00:00.

Thus if you want to calculate seconds from midnight for a time like 13:53:04, you just have to evaluate 13 * 3600 + 53 * 60 + 4, No insipid 1 additions or subtractions.

Closing rant about MIDI

Okay, what is it with musicians, even supposedly technical ones?

MIDI! It uses zero-based numbering for programs and channels in the actual wire representation of messages, but gear displays it as 1 based! For instance programs 0 to 127 are called 1 to 128 on most gear, but some calls them 0 to 127 or even gives the user a choice.

Programs 71 through 80 are a considered a "bank" of ten. It says so right on my MIDI pedal, for example. The footswitches are labeled from 1 to 10 and if I'm in the seventh bank, they pick programs 71 through 80. However, some devices or computer software displays the 1-128 program numbers as 0 to 127, or even gives the user a choice! What is worse: one-based systems, or chaos created by using both one and zero based at the same time?

MIDI channel numbers are called 1 to 16, but are represented by 0 to 15 binary. As if out of spite for the one-based presentation, some gear uses a dispswitch for configuring a channel number and, often, thes switches just use the zero based binary code. So if you want channel 3, you must toggle it to 0010 (binary 2).

Помните, как числа представлены в компьютере. Давайте возьмем byte переменная. 0 представляется как 00000000 ¹ в двоичном виде. 1 - 00000001. 2 - 00000010. И так далее.

Обратите внимание, что наименьшее число, которое byte можно сохранить равным 0. Если бы мы начали индексы массивов с 1, то система была бы неэффективной, поскольку теперь у нас есть массив длиной 255 вместо 256. Поскольку числа в программе на C компилируются в двоичные числа (int обычно, unsigned int s в индексах массива), естественно использовать 0 в качестве начального индекса, поскольку он более эффективен.

Кроме того, в C++, a[p] разворачивается в *(a+p*n), где n это размер типа данных. Другими словами, a[p] означает "Дай мне элемент по индексу a+n*p ". Если p началось с 1, тогда у нас будет пустая / неиспользованная часть в индексе a,

^{1. Конечно, возникает очевидный вопрос "почему". Почему бы не установить 00000000 на 1? Просто: двоичное сложение (выполняется каскадами полных сумматоров) легко в аппаратном обеспечении, когда 00000000 равно 0. Двоичное сложение является неотъемлемой частью всех арифметических операций. Если вы зададите значение 1, вам нужно будет либо указать компилятору вычесть 1 из всех чисел, либо вам нужно жестко связать схемы сумматоров, чтобы сначала вычесть одно из сумматоров и вернуть его обратно к сумме. (обратите внимание, что вы не можете просто вычесть один позже, так как может быть задействован бит переноса)}

Модульное

Одна вещь, о которой не говорится в существующих хороших ответах: индексирование с нуля хорошо работает вместе с операциями по модулю, которые поэтому могут быть объединены в циклический список. Подумайте, например, о чем-то вроде

color = colors[i % colors.length]

который может дать каждому объекту (индексируется i) другой цвет из списка colorsДо тех пор, пока не будут использованы все цвета, с этого момента он начнется снова с самого начала. Выражать то же самое в индексации по одному довольно неуклюже:

color = colors[(i - 1) % colors.length + 1]

Автоматические операции по модулю, налагаемые двоичной арифметикой без знака фиксированного размера с переносом, являются еще одним примером того, почему это имеет смысл.

Обслуживает как

Еще одна вещь, которую следует учитывать, это тот факт, что довольно просто не использовать первый элемент массива с нулями. (Это не относится к foreachитерации в стиле и подобные языковые конструкции, которые обрабатывают массив в целом.) Многие программисты, включая меня, могут чувствовать себя немного неловко по поводу потраченного впустую пространства, но в большинстве ситуаций их количество настолько мало, что эти опасения беспочвенны. С другой стороны, если языки используют индексирование на основе одного, то нет способа имитировать элемент с нулевым индексом без большого количества кода. Таким образом, учитывая, что в некоторых ситуациях индексирование на основе нуля лучше, чем основанное на одном, выбор нуля в качестве основы везде является более гибким подходом, в отличие от основанного на одном, повсеместного, и он также более последовательный, чем конфигурируемые начальные позиции.

Начинать с нуля целесообразно при описании расстояния от чего-либо. Итак, в этом массиве:

[4,9,25,49]

расстояние от начала массива до 25 равно 2 - вам нужно пропустить два шага, чтобы добраться туда. Расстояние до 4 равно нулю - вам вообще не нужно двигаться с самого начала.

При сложении расстояний (или индексов) целесообразно так думать - я продвигаюсь на один шаг, затем на ноль, затем на два шага, где я? Я с индексом 1 + 0 + 2 = 3. Пропустив три шага, я получаю 49 в массиве выше.

Цифра 0 может обозначать различные значения: числовое значение, порядковый номер, адрес памяти и т. Д.

"Индекс ноль" не означает, что программисты считают с нуля. Он обозначает первое место выделенного блока памяти, а "0" - его адрес.

В C цикл через массив можно записать так:

int arr[N];
for (i=0; arr[N]; ++i) {
...
}

Такую же работу можно проделать в C#:

Object[] arr;

for (Object o in arr) {
...
}

Я думаю, что нет подсчета в обоих примерах.

Если я правильно помню из своего класса "Концепции языка программирования"... языки с 0 индексами и другие с 1 индексом были связаны с историческими причинами. Алгол-68, прародитель языков программирования был фактически индексируемым, равно как и Фортран и некоторые другие "деловые" языки, такие как COBOL. Однако в некоторых из этих языков вы могли бы явно указать, каким будет ваш начальный индекс. Здесь есть интересная таблица.

В основном в " Ye Olde Days " математики, ученые и другие "академики" обычно использовали 0-индексированные языки, в то время как пользователи таких языков, как COBOL, не нашли смысла начинать считать с 0, поэтому в этих языках было больше смысла начать с 1 (это казалось менее запутанным).

Теперь, если ваш вопрос касается того, почему компьютер (а не язык) естественным образом начинает считать с нуля... ну, я полагаю, это действительно присуще двоичному файлу: ex: 0000 = ноль 0001 = один... так далее и так далее...

Помимо вычислительной эффективности, есть еще один аспект подсчета. Есть два способа присвоить каждому элементу последовательности порядковый номер:

1. Количество предшествующих (целых) элементов (кардинальных чисел)
2. Положение элемента (порядковые номера)

Возраст людей - это кардинальные числа: в первый год после рождения ребенка ему 0 лет, потому что он был жив нулём целых лет.

Годы в датах являются порядковыми номерами: в первом году Anno Domini (AD), год - 1 нашей эры. Нет нулевого года, как нет ничего нулевого.

Языки программирования (такие как Matlab и Mathematica), где индекс элемента представляет его позицию в массиве, начинают считать с 1: первый элемент. В других языках (таких как все языки на основе C) индекс элемента - это число предшествующих элементов, и, следовательно, первый элемент равен 0.

Конечно, Matteo только частично прав, утверждая, что индексация на основе нуля более эффективна.

element(n) = address + n * element_size

Индексирование на основе одного может быть столь же эффективным, если у всех адресов массива уже есть один element_size вычесть из них. Это может быть сделано, когда массив выделен, и в этом случае это так же быстро:

array_address = address - element_size
element(n) = array_address + n * element_size

Индекс массива - это смещение от базовой ячейки памяти до ячейки памяти элемента. Элемент i является тогда Base + i. Первый элемент расположен в базовом местоположении, поэтому он находится в местоположении 0 (Base + 0).

Ответ прост: первая цифра не 1, а 0.

Пояснение: Формула для расчета многозначного числа в любой базе:

n = sum(i=0 to n, Di^i)

WHERE 
n = numeric result
i = index (starting with 0)
Di = is the digit at index i

Давайте возьмем десятичную систему, к которой мы больше всего привыкли.

Глядя на число 1234, мы можем записать его как:

4 x 10^0 = 4
3 x 10^1 = 30
2 x 10^2 = 200
1 x 10^3 = 1000

in other words, sum of digits raised to the power if their index.

Так что это не только компьютеры, мы, люди, тоже считаем от 0.

Компьютерные системы используют как натуральные числа (считая от 0), так и целые числа (считая от 1). Люди считают вещи целыми числами, что делает их интуитивно понятными для нумерации списков, и многие языки программирования используют это в своих интересах: BASIC, COBOL, Fortran, Lua и Pascal считают из 1. Эти языки ориентированы на такие ниши, как обработка данных, численный анализ, и обучение, где простые, интуитивно понятные списки являются преимуществом.

Целые числа становятся неудобными, когда вы начинаете анализировать и манипулировать структурой данных, а не просто обрабатывать все по порядку. Когда вам нужно обратиться к последовательностям в формуле или алгоритме, проще и менее подвержено ошибкам нумеровать их от 0, как это делают математики: a₀, a₁, a_n и т. Д. В противном случае вам часто приходится настраивать на +1 и –1, чтобы получить правильные данные, и легко ошибиться, создавая ошибки. Поэтому языки, разработанные для компьютерных ученых, обычно используют натуральные числа: C, Java и Lisp, все считаются от 0.

Помимо языков программирования, многие компьютерные системы нумеруют числа от 0, потому что к этому привыкли компьютерные ученые. Кроме того, так как нумерация от 1 приводит к большому количеству коварных ошибок, многие из нас избегают ее за пределами элементов интерфейса, предназначенных исключительно для нетехнических конечных пользователей.

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

0… Вы путаете разные понятия: языки программирования, компьютеры и счет.

1. Использование 2 состояний (большинство из них схематически делают именно это) означает, что вы можете выбрать 2 цифры, чтобы сопоставить их (скажем, для ссылки). "3" и "5" (или "F" и ",") будут в порядке, но тогда вы спросите, почему компьютеры считают "3" (или "F"). Естественный выбор 0 и 1, очевидно.
2. Массивы в Паскале начинаются с 1. Этот язык более абстрактный, чем низкоуровневый Си.