Что такое индекс массива

Что такое индекс массива

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

Массив — это совокупность данных одного типа, имеющая одно общее имя. Доступ к отдельному элементу массива осуществляется путем указания имени массива и номера (индекса) этого элемента. До использования массива его необходимо определить, т.е. дать ему имя и указать количество и тип элементов. Индексы в любом массиве на языке C/C++ всегда начинается с 0 .

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

Для того, чтобы начать работать с массивом, необходимо дать его описание. Формальная запись описания массива такова:

Тип_элементов_массива Имя_массива [ Количество_элементов ];

Тип_элементов_массива — любой стандартный или ранее определённый пользователем тип данных;

Имя_массива — обычный идентификатор;

Количество_элементов — целое число, большее 0 , возможно, именованная константа.

Для нашего массива x описание будет выглядеть так:

После этого можно начинать работать с элементами массива, например, присвоить второму элементу новое значение:

или напечатать сумму значений первых двух элементов массива:

Как нетрудно убедиться, элементы массива могут использоваться точно так же, как и простые переменные. Единственное отличие — требуется указывать индексы элементов.

Индекс (номер) элемента массива — это константа, переменная или более сложное выражение целого типа. Можно было бы написать:

x[i*3-2] = x[i+1] + x[i%5] — x[3];

главное, чтобы индексы (или в более сложном случае — индексные выражения) находились в допустимых пределах. Индексы элементов нашего массива x должны лежать в пределах от 0 до 4 , т.е. максимально допустимый индекс на единицу меньше количества элементов массива .

А что произойдёт, если обратиться к элементу с индексом, значение которого выходит за допустимый диапазон? Для нашего примера, запишем так:

Внешних проявлений (например, сообщений об ошибке), как правило, не будет, просто программа обратится к «чужому» участку памяти и «испортит» значение какой-либо переменной.

Выход за допустимые пределы индексов массива — это характерная ошибка в программах на языках С/С++ . К сожалению, компилятор тут не помощник — он ни как не контролирует выход за допустимые пределы. Поэтому программисту самому необходимо проявлять повышенную внимательность и аккуратность в работе с массивами. При работе с программой, в которой используются массивы, всегда задавайте себе вопрос: «Не выходит ли где-то индекс массива за допустимые пределы?».

Вернёмся снова к описанию массива. Хороша ли запись

Ответ один — нет, плоха. Почему? Да потому, что при работе с массивами мы постоянно используем просмотр массива, т.е. нам для нашего массива из 5 чисел придётся использовать циклы вида

А что делать, если количество чисел изменится? Просматривать текст всей программы и «править» все циклы? Глупо как-то, да и ошибиться легко. Нужен какой-то выход, и он есть: количество элементов массива нужно задавать не константой (числом), а именованной константой. Тогда количество элементов массива потребуется изменить только в одном месте, а остальной текст программы останется прежним.

На языке С был только один способ создания константы с именем: с помощью директивы define . Схема программы будет выглядеть так:

double x[n]; // описание массива

int i; // переменная цикла

Одна проблема решена, но есть и другая, также весьма неприятная. Что произойдёт, если в директиве define пользователь задаст неверное по смыслу значение для константы, например, другого типа:

или наберёт просто какой-то абсурд:

В этом случае препроцессор «честно» выполнит подстановки, и после компиляции (а в ряде случаев — в ходе выполнения исполняемого модуля) в программе появится сообщение об ошибке, но ссылка будет не на строку, где допущена ошибка (директива define ), а гораздо дальше — там где она используется, — возможно через десятки или сотни строк. Если для приведённой выше схемы написать

то ошибка будет указана в строке

которая совсем не причём.

Для радикального решения проблемы на языке С++ появился более надёжный способ создания константы с именем: с помощью константной переменной . Схема программы будет выглядеть так:

double x[n]; // описание массива

int i; // переменная цикла

Достоинство такого подхода в том, что теперь компилятор проверяет правильность оператора, в котором мы задаём размер массива:

Если в этом операторе переменной n будет задано что-то неприемлемое:

const int n = ЮЮЮ

то сообщение об ошибке будет дано именно для этого оператора, а не где-то ниже по тексту.

Для закрепления материала рассмотрим задачу.

Пример . Дан массив действительных чисел из n элементов. Найти максимальный по модулю элемент и разделить все элементы массива на полученное значение. Вывести на экран монитора массив после обработки.

Возможный текст программы:

using namespace std;

// Задаём массив из n действительных чисел

// Поиск максимального по модулю элемента массива

// Предположим, что x[0] — это и есть максимальный

// по модулю элемент массива:

// А теперь пробуем себя опровергнуть:

// Делим все элементы на max

Инициализация массивов

Элементы массива можно проинициализировать, т.е. задать им начальные значения на этапе выделения памяти под массив. Делается это почти так же, как для простых переменных. Зададим начальные значения элементов массива в нашем примере (смотри рисунок в начале этой темы):

Если при инициализации задано меньше данных, чем выделяется памяти (у нас — для пяти чисел), то значение элементов массива, которые не получили значение в момент выделения памяти, будет неопределённым.

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

Но как обрабатывать теперь массив? Нам же надо знать количество элементов! Поделим размер массива на размер одного элемента — это и будет искомым значением:

int n = sizeof(x) / sizeof(double);

Здесь sizeof() — это стандартная операция по вычислению размера какого-либо объекта.

Теперь можно применять привычный подход при обработке массива:

Что такое индекс массива

Каталог курсов

Направления обучения

Бесплатный курс

начало карьеры

IT-профессии

Как выбрать направление и реализовать себя

Индекс массива

Индекс массива — целое число, которое указывает на конкретный элемент массива. Индекс массива — это не номер элемента, а смещение. Индекс начинается с 0. Нумеровать мы привыкли с 1. Чтобы получить индекс по номеру, нужно из номера вычесть единицу. Чтобы получить номер по индексу, нужно прибавить единицу.

JavaScript | Что такое индекс массива?

Под словосочетанием «индекс массива» подразумевают «номер целочисленного индекса элемента массива«. Прикол в том, что когда в коде (в редакторе кода) пишут массив через квадратные скобки, то по факту пишут ЗНАЧЕНИЯ элементов массива, а JavaScript уже сам у себя в «невидимом» режиме «проставляет» нужные целочисленные ИНДЕКСЫ от нуля до какого-то положительного целого числа (зависит от количества элементов в массиве). То есть кодер (программист) не видит эти индексы, но они есть.

Считайте это небольшим визуальным улучшением. Представьте себе, что у вас массив из 1 миллиона строк. У вас и так много значений, а вы ещё будете приписывать номера для каждого элемента в самом коде. Очевидно, что в этом нет никакого смысла т. к. номер индекса на следующем элементе увеличивается на один. И так у всех. Эту писанину можно «опустить» (убрать с глаз) и сконцентрироваться на самих данных (значениях).

Как это понять?

Любой элемент массива состоит из пары «ИНДЕКС / ЗНАЧЕНИЕ».

Индексы — порядковые номера элементов. Сначала идёт первый элемент, потом второй, потом третий и т.д..

Значения — это данные, которые мы храним в элементах массивов. Именно эти данные представляют наибольшую ценность в массивах.

Если мы хотим дотянуться до «данных» в массиве, то мы должны знать «порядковый номер» элемента в этом массиве. Если мы хотим дотянуться до «ЗНАЧЕНИЯ элемента» в массиве, то мы должны знать «ИНДЕКС элемента» в этом массиве. По индексу мы находим значение.

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

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

Информация из стандарта ECMAScript

ArrayLiteral — это выражение, описывающее инициализацию объекта Array с использованием списка из нуля или более выражений, каждое из которых представляет элемент массива, заключенного в квадратные скобки. Элементы не обязательно должны быть литералами; они оцениваются каждый раз, когда оценивается инициализатор массива.

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

Представьте, что у нас есть пустой массив:

var klass5a = []

Мы проинициализирвали массив при помощи квадратных скобок. Этот массив пустой — в нём нет элементов. Теперь задайте себе вопрос — как добавить новый элемент в этот массив?

Что проинициализировать элемент массива, нам нужно будет воспользоваться «другими» квадратными скобками. Например добавим первый элемент массива:

klass5a[0] = "Иванов Пётр Владимирович"

Обратите внимание. Мы в квадратные скобки написали тот самый «невидимый» номер, который является индексом первого элемента массива. Да, да. Вам не показалось. Индекс 0, элемент 1.

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

Вот это и называется индексом массива!

Как заменить значение элемента под определённым индексом?

Индекс нужно знать для того, чтобы иметь возможность «переназначать» значение. Представьте, что у вас есть кошелёк в сумке. Сегодня вы положили в кошелёк 2 тысячи рублей, а завтра положили 5 тысяч. Кошелёк один, а значения разные. Так же и с элементами массива — индекс один а значения можно менять сколько угодно.

Переназначим в нашем массиве значение «Иванов Пётр Владимирович» на «Светка-Конфетка»

klass5a[0] = "Светка-Конфетка"

Информационные ссылки

Стандарт ECMAScript — Раздел «13.2.5 Array Initializer» — https://tc39.es/ecma262/#sec-array-initializer

Вам также может понравиться

Опубликовано 22.03.2021

JavaScript | Оператор break

Зачем нужен оператор break в JavaScript? Оператор break нужен для прерывания работы цикла и выхода из него. Представьте, что у вас есть […]

Опубликовано 18.11.2021

Ночные Работники Службы | Расширяемость

Спецификация Service Workers расширяется за счет других спецификаций. 7.1. Определите API, привязанный к регистрации Service Worker Спецификации могут определять API, привязанный […]

Опубликовано 12.11.2020

JavaScript | Как склеить два массива с булевыми значениями?

У нас есть два массива с булевыми значениями JavaScript (элементами обоих массивов являются булевы значения): var massiv1 = [true,true,true,true] var massiv2 = […]

Опубликовано 07.11.2020

document.getElementsByTagName(«th»)

Команда document.getElementsByTagName(«th») возвращает HTML-коллекцию HTML-элементов со страницы (документа). Элементы коллекции тянут за собой всех потомков. Забор данных осуществляется в древовидном порядке, […]

Почему массивы начинаются с нуля

Самое очевидное объяснение: индекс — это смещение относительно начала массива. Так элементы массива легче адресовать в памяти.

Проверим это на C.

#include int main() < int data[3] = ; int i = 0; printf("Array address: %p\n", data); do < printf("Array[%u] = %p\n", i, (void *)(&data[i])); i++; >while(i

Array address: 0x7ffd7c514a6c
Array[0] = 0x7ffd7c514a6c
Array[1] = 0x7ffd7c514a70
Array[2] = 0x7ffd7c514a74

Как первый (нулевой) элемент, так и сам массив находятся по одному и тому же адресу, поскольку 0-й элемент удалён на 0 элементов от начала. Эта связь между указателями и массивами в C настолько тесная, что их даже можно рассматривать вместе.

Однако это ответ на вопрос «зачем», а не «почему». Нумеровать массивы с нуля стали не сразу. Удивительно, но развитие такого простого вопроса не умещается в предложении или абзаце.

Потому что так удобнее

К началу 1960-х годов сформировалось три подхода к организации структуры, которую сегодня мы называем статическим массивом:

Исчисление с 0. Нижняя граница массива начинается с нуля.

Непривычно для обывателя, если это не житель Германии, свыкшийся с нумерацией этажей в зданиях. Последний элемент массива из, скажем, 8 элементов имеет номер 7.

Не всё так однозначно. Единообразия даже у самых первых языков программирования не существовало:

1. Нумерация с нуля: LISP 1.5, APL (допускает выбор при запуске программы).
2. Нумерация с единицы: APL, Бейсик, ранний Фортран.
3. Произвольные границы: Алгол-60, затем Фортран, CPL, SIMULA, CLU, PL/1, Кобол, Паскаль, Алгол-68, JOVIAL.

Конечно, это не самый сильный аргумент. Часто языки снабжались синтаксическим сахаром для нумерации с 1. К примеру, в Алголе массив V[0:3] начинается с 0, а массив V[3] — с 1.

Создатель языка APL Кеннет Айверсон в книге «A Programming Language» объясняет, почему далее по тексту он будет пользоваться нумерацией элементов массива с нуля. При этом язык допускает отсчёт как с единицы, так и с нуля. Айверсон приводит уже описанный выше аргумент о сдвигах в позиционной нумерации.

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

Потому что парусные регаты мешали вычислениям

В 1967 году Мартин Ричардс впервые реализует компилятор своего детища — BCPL (Basic Combined Programming Language). Этот язык программирования был призван исправить проблемы созданного в начале шестидесятых языка CPL путём отказа от технологий, затрудняющих компиляцию.

Первый компилятор BCPL был написан для операционной системы CTSS машины IBM 7094 Массачусетского технологического института. На тот момент компьютеры — это уже не целые комнаты и электронные лампы, но всё ещё огромные шкафы с транзисторами и консоли управления без экранов. Ресурсов серии 7090 хватило, чтобы запустить американца в космос. Но мощность измерялась в тысячах машинных слов, микросекундах тактов и килофлопсах, а цена — в миллионах долларов.

В пятидесятых и шестидесятых IBM выдавала институту щедрые скидки на свои научные компьютеры или даже предоставляла их бесплатно. В 1963 году в МТИ поставили IBM 7094. На компьютер уговор был такой: 8 часов в сутки получают специалисты института, 8 часов — другие колледжи и университеты Новой Англии, а третью смену отдавали самой IBM для личных нужд.

На этом особенности не кончались. Несколько раз в год IBM обсчитывала регаты: президент IBM соревновался в заплыве на больших яхтах в проливе Лонг-Айленд, и каждое из судов получало очки гандикапа по специальной сложной формуле. Когда в вычислительный центр приходило задание, операторам полагалось всё бросить и запустить вычисления этих очков.

Машинный зал с установленным компьютером IBM 7094 в Колумбийском университете США. Фотоархив

Вообще, и без этого был шанс не получить результат вычислений. Изначально 7094 работал в режиме пакетной обработки. Вспомогательная система на IBM 1401 загружала пакет задач с перфокарт на ленту, а затем запускала задачи одну за другой и записывала результаты для последующей печати. Для каждой задачи приводилась оценка времени. Если задача выходила за пределы отпущенного, её принудительно прерывали.

В итоге компиляция в BCPL была оптимизирована по максимуму. То есть и указатели на элементы массива должны максимально близко походить на машинный код, без необходимости вычитать единицу при указании на элемент массива. Хотя во время выполнения программы не играет роли схема организации массивов, нумерация с нуля могла появиться для оптимизации времени компиляции.

Впрочем, конкретно эта версия — лишь гипотеза Майка Хойе. Ей нет никаких подтверждений от собствено Ричардса или хотя бы упоминаний в литературе. Мартин Ричардс в переписке с Хойе лишь приводит общие соображения о том, что он хотел достичь близости к машинному коду, поэтому указатель p и p + 0 — это одна и та же переменная. Ни на какие яхты Ричардс не жалуется.

К тому же на момент появления первого компилятора BCPL уже была готова операционка Compatible Time-Sharing System. В ней на одной машине с разделением времени компьютер выполняет одну задачу за один раз, но с оптимизацией ввода и вывода, чтобы паузы одного пользователя заполнялись работой других. Это уже не былая пакетная обработка задач.

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

В 1969 году Кен Томпсон урезал функциональность BCPL до языка B. В дальнейшем, для развития операционной системы Unix, Деннис Ритчи улучшил B добавлением функций PDP-11, в результате чего и получился C. Полвека спустя список языков, на которые оказал влияние C, занимает в «Википедии» целую страницу.

В языке BCPL v!5 и 5!v совпадают, поскольку являются указателем на !(v+5) или !(5+v) . Аналогично в C v[5] эквивалентно 5[v] .

Потому что так предложил Дейкстра

В 1982 году Эдсгер Дейкстра опубликовал статью «Почему нумерация должна начинаться с нуля». В ней он низверг как нумерацию с единицы, так и произвольные границы индексов. Очевидно, что Дейкстра — не человек, который легко поддаётся влиянию C, но также он раскритиковал Алгол-60, своё собственное детище, и Паскаль.

Известно, что Дейкстра ближе к концу жизни всё больше писал от руки, а не набирал тексты на машинке. Архив рукописей Эдсгера Вибе Дейкстры

Если необходимо записать интервал натуральных чисел 2, 3, …, 12 без опухоли из точек, возможны четыре варианта:

Затем автор замечает, что для нижней границы предпочтителен знак «⩽», поскольку наименьшее натуральное число существует. В противном случае, если последовательность начинается с наименьшего натурального числа, нижняя граница не будет натуральным числом.

Затем статья делает вывод, что из соображений простоты для последовательности из N членов предпочтительнее диапазон 0 ⩽ i < N , а не 1 ⩽ i < N+1 .

Куда менее известный документ — это полушуточная техническая заметка от 1 апреля 1980 года IEN 137 под названием «О священных войнах и призыв к миру» [On Holy Wars and a Plea for Peace].

В заметке Дэнни Коэн приводит интересный аргумент: в системе счисления с основанием b при отсчёте с нуля первые b ^ N неотрицательных чисел представляются ровно N цифрами. Например, если речь про двоичную запись, то 2 ^ 3 = 8 , и восьмой элемент массива будет иметь номер 111₂, а не 1000₂. Понятно, что с такими преобразованиями легко бы мог справиться компилятор.

Потому что так более элегантно

Это объяснение может раздражать субъективностью. Соображения о красоте у каждого свои и совпадать не обязаны. Но авторы языков программирования — тоже люди со своими предпочтениями.

В конце восьмидесятых Гвидо ван Россум при создании Python как учёл свой предыдущий опыт с языком ABC, так и задумал привлечь аудиторию хакеров от мира Unix и C.

С 1983 года Гвидо работал в Центре математики и информатики в Амстердаме над реализацией языка ABC. Проект ставил целью создать язык программирования, пригодный для обычных людей, но не настолько ужасно реализованный, как Бейсик. Нумерация массивов в ABC начиналась с единицы. Такой же схемы придерживались другие знакомые Россуму языки — Алгол, Фортран и Паскаль.

Однако в вышедшем в 1991 году Python нумерация начинается с нуля, а не единицы. Получилось так в результате долгих размышлений.

Одна из причин — слайсы. Чаще всего при создании слайса используются операции «получить первые n элементов» и «начиная с i, получить следующие n элементов». При этом первый случай эквивалентен i == первый индекс . Гвидо посчитал, что лучше, если обе операции возможны без лишней головной боли в виде коррекции +1 и −1.

Если первый элемент имеет номер 1, то возможно указывать первый элемент и число элементов, которые нужно получить. Россум уже был знаком с подобным по ABC и вполне мог бы положиться на этот опыт.

Тем не менее автора Python очаровал синтаксис слайсов полуоткрытого интервала, если нумерация начинается с нуля: a[:n] (или a[0:n] ) и a[i:i+n] . К примеру, строку a легко разбить на три части a[:i] , a[i:j] и a[j:] .

Заметим, что в воспоминаниях Гвидо не приводит ни призывы гениев информатики, ни практики других языков, ни принципы, заложенные мастодонтами компьютерных вычислений шестидесятых. Зато слово «элегантность» в пяти абзацах его объяснения встречается 3 раза.

Почему же массивы начинаются с нуля?

Так исторически сложилось.