55

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

Какие исторические причины существуют для этого и какие практические преимущества имеет счет от нуля по сравнению с счетом от одного?

Примечание. Этот вопрос требует хорошо объясненных технических ответов, а не просто мнений, и предназначен для охвата компьютеров в целом, а не только программирования. Этот вопрос расширяет вопрос программистов «Почему структуры / массивы начинаются с нуля?"

17 ответов17

87

Подсчет массивов от 0 упрощает вычисление адреса памяти каждого элемента.

Если массив хранится в данной позиции в памяти (это называется адресом), позиция каждого элемента может быть вычислена как

element(n) = address + n * size_of_the_element

Если вы считаете первый элемент первым, вычисление становится

element(n) = address + (n-1) * size_of_the_element

Не сильно отличается, но добавляет ненужное вычитание для каждого доступа.

редактировать

  • Использование индекса массива в качестве смещения - это не требование, а просто привычка. Смещение первого элемента может быть скрыто системой и учтено при выделении и обращении к элементу.

  • Дейкстра опубликовал статью "Почему нумерация должна начинаться с нуля" (pdf), где он объясняет, почему начинать с 0 - лучший выбор. Начиная с нуля, можно лучше представить диапазоны.

37

Хотя приведенные ниже принципы применимы и к десятичной, и к любой другой базе, отсчет от 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 с вложенными структурами данных, как этот пример, может сбивать с толку.
26

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

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

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

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

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

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

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

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

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

tal·ly [tal-ee]

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

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

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

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

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

(Dictionary.com)


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

12

Я думаю, что это уже было рассмотрено " проф.др.Эдсгер В. Дейкстра "- научный сотрудник Берроуза в письме от 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 году).

10

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

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

"1 миля"

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

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

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

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

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

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

6

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

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

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

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

3

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

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

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 на оборудовании, в программном обеспечении и во всех пользовательских интерфейсах и документации.

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

Рассмотрим, например, западную теорию музыки. У нас есть диатонические весы с семью нотами, но мы называем пространство, которое они покрывают октавой ! Затем инверсия интервалов следует правилу девяти: например, инверсия третьего является шестым (вычтите три из девяти). Таким образом, три разных числа используются для чего-то такого простого: семь (ноты в масштабе), восемь (октава) и девять (от вычитания до инвертирования).

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

Кроме того, интервалы могут быть легко сложены. В нынешней системе, если мы прыгнем на пятую, а затем еще на четверть, а затем на треть, мы не можем просто добавить их. Результирующий интервал на два меньше. Это не двенадцатый, а фактически десятый! На каждом этапе мы должны вычесть один. Повышение на пятую, а затем на четвертую - не девятый, а только октава.

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

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

Системы на основе одного путают одних и тех же людей, которые не могут обрабатывать массивы с нулями

Когда наступил 2000 год, многие были озадачены тем, что новое тысячелетие не началось. Те, кто указывал на то, что это не начнется до 2001 года, были расценены как партийные пижоны и паутины. В конце концов, вам 20, когда вам исполняется 20, верно? Не когда тебе исполнится 21. Если вы думали, что тысячелетие началось 1 января 2000 года, то вы не имеете права жаловаться на массивы, основанные на нуле, на любом языке программирования. Они работают так, как вам нравится. (Но, да, сторонниками смещений и массивов по принципу «один на один» являются dweebs и party-poopers. Столетия должны начинаться с XX00 лет, а тысячелетия с X000 лет.)

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

Каждая новая минута на ваших часах начинается с:00 секунд. Каждый новый час начинается с 00:00 минут и секунд. И, по крайней мере на 24-часовых часах, день наступает, когда наступает полночь, и 11:59:59 увеличивается до 00:00:00.

Таким образом, если вы хотите вычислить секунды с полуночи для времени, подобного 13:53:04, вам просто нужно оценить 13 * 3600 + 53 * 60 + 4 . Нет безвкусно 1 сложения или вычитания.

Закрывающая напыщенная речь о MIDI

Хорошо, что это с музыкантами, даже предположительно техническими?

MIDI! Он использует нумерацию с нуля для программ и каналов при фактическом представлении сообщений в проводном режиме, но устройство Gear отображает его как 1 на основе! Например, программы от 0 до 127 на большинстве передач называются от 1 до 128, но некоторые вызывают их от 0 до 127 или даже предоставляют пользователю выбор.

Программы с 71 по 80 считаются "банком" из десяти. Так сказано прямо на моей педали MIDI, например. Футсвитчи помечены от 1 до 10, и если я в седьмом банке, они выбирают программы с 71 по 80. Однако некоторые устройства или компьютерные программы отображают номера программ от 1 до 128 от 0 до 127 или даже предоставляют пользователю выбор! Что хуже: системы на основе одного или хаос, созданный с использованием как одного, так и нулевого уровня, основанного одновременно?

Номера каналов MIDI называются от 1 до 16, но представлены двоичными числами от 0 до 15. Как будто вне зависимости от представления на основе одного, некоторые устройства используют дисковый переключатель для настройки номера канала, и часто эти переключатели просто используют двоичный код на основе нуля. Таким образом, если вы хотите канал 3, вы должны переключить его на 0010 (двоичный 2).

1

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

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

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

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

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

Object[] arr;

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

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

1

Модульное

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

color = colors[i % colors.length]

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

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

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

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

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

1

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

[4,9,25,49]

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

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

1

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

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

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

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

1

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

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

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

0

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

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

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

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

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

0

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

  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
-1

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

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

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

Всё ещё ищете ответ? Посмотрите другие вопросы с метками .