array
Description
An array is a collection of variables that are accessed with an index number. Arrays in the C++ programming language Arduino sketches are written in can be complicated, but using simple arrays is relatively straightforward.
Creating (Declaring) an Array
All of the methods below are valid ways to create (declare) an array.
You can declare an array without initializing it as in myInts.
In myPins we declare an array without explicitly choosing a size. The compiler counts the elements and creates an array of the appropriate size.
Finally you can both initialize and size your array, as in mySensVals. Note that when declaring an array of type char, one more element than your initialization is required, to hold the required null character.
Accessing an Array
Arrays are zero indexed, that is, referring to the array initialization above, the first element of the array is at index 0, hence
mySensVals[0] == 2, mySensVals[1] == 4, and so forth.
It also means that in an array with ten elements, index nine is the last element. Hence:
For this reason you should be careful in accessing arrays. Accessing past the end of an array (using an index number greater than your declared array size — 1) is reading from memory that is in use for other purposes. Reading from these locations is probably not going to do much except yield invalid data. Writing to random memory locations is definitely a bad idea and can often lead to unhappy results such as crashes or program malfunction. This can also be a difficult bug to track down.
Unlike BASIC or JAVA, the C++ compiler does no checking to see if array access is within legal bounds of the array size that you have declared.
Массивы
Массив — это набор переменных, доступ к которым осуществляется по индексу. Массивы в языке программирования C, использующемся при программировании Ардуино, могут представлять собой сложные структуры, но для понимания использование обычных одномерных массивов проще.
Создание (объявление) массива
Ниже представлены правильные способы создания (объявления) массивов.
Можно объявить массив без его инициализации, как myInts.
В myPins мы объявили массив без прямого указания его размера. Компилятор сам посчитает элементы и создаст массив соответствующего размера.
В конце концов, можно и проинициализировать массив, и указать его размер, как mySensVals. Следует помнить, что при объявлении массива типа char, в нем необходимо место для хранения обязательного нулевого символа, поэтому размер массива должен быть на один символ больше, чем требует инициализируемое значение.
Обращение к элементам массива
Нумерация элементов массива начинается с нуля, т.е. первый элемент массива имеет индекс 0. Следовательно, применительно к проинициализированным выше массивам,
Это также означает, что в массиве из 10 элементов, последний элемент имеет индекс 9. Следовательно:
Поэтому, необходимо быть внимательным при обращении к массивам. Обращение к элементу за пределами массива (когда указанный индекс больше, чем объявленный размер массива — 1) приведет к чтению данных из ячейки памяти, использующейся для других целей. Считывание из этой области, вероятно, не приведет ни к чему, кроме получения неверных данных. Запись же в случайные области памяти — определенно плохая идея, и часто может приводить к не желаемым результатам, таким, как зависания или сбои в работе программы. Кроме того, такие ошибки трудно отыскать.
В отличие от BASIC или JAVA, компилятор C не проверяет правильность индексов при обращении к элементам массива.
Как записать значение в массив:
Как считать значение из массива:
Массивы и циклы FOR
Работа с массивами часто осуществляется внутри циклов FOR, в которых счетчик цикла используется в качестве индекса каждого элемента массива. Например, программа вывода элементов массива через последовательный порт может выглядеть так:
Пример
Полную версию программы, демонстрирующую работу с массивами, смотрите в примере Knight Rider из раздела «Примеры».
Arduino – Массивы
Массив – это последовательная группа ячеек памяти одного типа. Чтобы сослаться на конкретное местоположение или элемент в массиве, мы указываем имя массива и номер позиции конкретного элемента в массиве.
На приведенной ниже иллюстрации показан целочисленный массив с именем C, который содержит 11 элементов. Вы ссылаетесь на любой из этих элементов, давая имя массива, за которым следует номер позиции конкретного элемента в квадратных скобках ([]). Номер позиции более формально называется индексом или индексом (этот номер указывает количество элементов в начале массива). Первый элемент имеет индекс 0 (ноль) и иногда называется элементом нулей.
Таким образом, элементами массива C являются C [0] (произносится как «C sub zero»), C [1], C [2] и так далее. Максимальный индекс в массиве C равен 10, что на 1 меньше, чем количество элементов в массиве (11). Имена массивов соответствуют тем же соглашениям, что и имена других переменных.
Индекс должен быть целочисленным или целочисленным выражением (используя любой целочисленный тип). Если программа использует выражение в качестве нижнего индекса, тогда программа оценивает выражение для определения нижнего индекса. Например, если мы предположим, что переменная a равна 5, а переменная b равна 6, то оператор добавляет 2 к элементу массива C [11].
Именованное имя массива является lvalue, его можно использовать в левой части присваивания, так же как и имена переменных, не являющихся массивами.
Рассмотрим подробнее массив C на данном рисунке. Имя всего массива – C. Его 11 элементов называются от C [0] до C [10]. Значение C [0] равно -45, значение C [1] равно 6, значение C [2] равно 0, значение C [7] равно 62, а значение C [10] равно 78.
Чтобы вывести сумму значений, содержащихся в первых трех элементах массива C, мы бы написали:
Чтобы разделить значение C [6] на 2 и присвоить результат переменной x, мы бы написали:
Объявление массивов
Массивы занимают место в памяти. Чтобы указать тип элементов и количество элементов, требуемых массивом, используйте объявление в форме –
Компилятор резервирует соответствующий объем памяти. (Напомним, что объявление, которое резервирует память, более правильно известно как определение). ArraySize должен быть целочисленной константой, большей нуля. Например, чтобы сообщить компилятору зарезервировать 11 элементов для целочисленного массива C, используйте объявление –
Массивы могут быть объявлены как содержащие значения любого не ссылочного типа данных. Например, массив строк типа можно использовать для хранения строк символов.
Примеры использования массивов
В этом разделе приводится много примеров, демонстрирующих, как объявлять, инициализировать и манипулировать массивами.
Пример 1. Объявление массива и использование цикла для инициализации элементов массива.
Программа объявляет 10-элементный целочисленный массив n . Строки a – b используют оператор For для инициализации элементов массива нулями. Как и другие автоматические переменные, автоматические массивы неявно инициализируются нулем. Первый оператор вывода (строка c) отображает заголовки столбцов для столбцов, напечатанных в последующем операторе for (строки d – e), который печатает массив в табличном формате.
Результат – это даст следующий результат –
Результат — это даст следующий результат —
Результат — это даст следующий результат —
Массивы важны для Arduino и должны уделять гораздо больше внимания. Следующие важные понятия, связанные с массивом, должны быть понятны Arduino —
Чтобы передать аргумент массива в функцию, укажите имя массива без скобок.
Массивы с двумя измерениями (т.е. индексы) часто представляют таблицы значений, состоящие из информации, расположенной в строках и столбцах.
Массивы
Объявление массива
Массив (array) – это совокупность переменных одного типа, к которым можно обратиться с помощью общего имени и индекса, т.е. номера элемента в массиве. По сути это набор переменных, которые называются одним именем и имеют личные номера. Для объявления массива достаточно указать квадратные скобки после имени переменной с любым типом данных.
Указать компилятору размер массива можно двумя способами: явным числом в квадратных скобках, либо при объявлении записать в каждую ячейку значение, тогда компилятор сам посчитает их количество. Рассмотрим пример объявления массива разными способами:
- Размер массива, объявленного глобально, должен быть задан однозначно: конкретным числом , константой const или константой #define , так как массив будет существовать на всём протяжении работы программы и не может менять свой размер.
- Размер массива, объявленного локально, может быть задан переменной, так как такой массив создаётся во время выполнения программы и удаляется из памяти после закрывающей фигурной скобки.
- После указания последнего элемента массива можно ставить запятую, компилятор её проигнорирует (см. пример выше, массив myPins ).
- Массив символов является строкой, о них мы поговорим в отдельном уроке.
Обращение к элементам
Обращение к элементу массива осуществляется точно так же, в квадратных скобках. Важно помнить, что отсчёт в программировании начинается с нуля, и первый элемент массива имеет номер 0 (ноль):
Размер массива
Для определения размера массива можно воспользоваться функцией sizeof() , которая вернёт размер массива в количестве байтов. Зачем? Допустим в программе массив задаётся без указания размера, но элементы задаются явно (в фигурных скобках) и в процессе разработки программы размер массива может меняться. Чтобы не пересчитывать размер вручную и не менять его везде в программе, можно использовать эту функцию.
Примечание: если размер массива неизвестен на момент компиляции программы – sizeof() не сможет его посчитать и выдаст размер указателя (2 байта на AVR).
Ещё один момент: sizeof(имя_массива) даёт вес массива, а не количество элементов в нём! Если массив состоит из элементов типа byte – его вес совпадёт с размером. В остальных случаях нужно разделить вес массива на вес одного элемента, например так: sizeof(arr) / sizeof(arr[0]) – делим на вес элемента, чтобы не привязываться к типам данных. Результат вычисляется на этапе компиляции и в процессе работы программы время на вычисление не тратится.
Многомерные массивы
Выше мы рассмотрели одномерные массивы, в которых элементы определяются просто порядковым номером (индексом). Можно задавать и многомерные массивы, в которых адрес элемента будет определяться несколькими индексами. Например двумерный массив, он же матрица, он же таблица, каждый элемент имеет номер строки и столбца. Задаётся такой массив следующим образом: тип имя[строки][столбцы]
Очень важно помнить, что при объявлении массива с вручную вписанными данными нужно обязательно указать размер количества ячеек в измерении на 1 меньше размерности массива (для двумерного – обязательно указать размер одного из измерений, для трёхмерного – два, и т.д.).
В рассмотренном выше двумерном массиве myMatrix элемент с адресом 0, 2 (строка 0 столбец 2) имеет значение 12. Обращение к этому элементу например с целью перезаписи будет выглядеть так:
С элементами массивов можно производить такие же действия, как с обычными переменными, т.е. всю математику, которую мы рассматривали в предыдущем уроке. Также не стоит забывать, что массивом может быть почти любой тип данных: численные переменные, структуры, классы, строки… Область видимости точно так же применяется к массивам, ведь массив – это по сути обычная переменная.
Видео
Массивы Arduino
Массивы Arduino – это элемент языка, активно используемый программистами для работы с наборами однотипных данных. Массивы есть практически во всех языках программирования, не исключением является и Arduino, синтаксис которого сильно похож на С++. Есть много примеров, когда без использования массивов практически невозможно написать работоспособную программу, поэтому обойти эту тему без внимания нельзя. К сожалению, незнание нюансов и особенностей работы с массивами в Ардуино часто приводит к скрытым или явным ошибкам работы скетча. В этой статье мы попробуем разобраться с самыми основами: узнаем, что такое одномерные и многомерные массивы, научимся создавать их и работать с данными, хранящимися в массивах.
Что такое массивы
Если вы уже не новичок в программировании и прекрасно знаете, что такое массивы и как они работают, то можете смело перейти к следующему разделу статьи. А для начинающих мы все-таки попробуем кратко и доступно пояснить концепцию массивов.
Так и в массивах Ардуино – вы создаете структуру данных, поделенных на равные ячейки. Чтобы найти выбрать нужную ячейку, достаточно знать только ее номер по порядку. Это очень удобно – не нужно придумывать адрес или название для каждой из них. По сути своей, массивы – это такой большой набор переменных, у которых есть общее имя, а для поиска каждой отдельной переменной используется просто ее порядковый номер.
Для чего все-таки нужны массивы? Почему нельзя обойтись обычными переменными? Ответ становится очевидным на следующем примере. Представьте, что вам нужно хранить вместе большое количество (например, 1000) символов текста. Без массива вам пришлось бы создать переменную для каждого символа – и так 1000 переменных. И при этом у вас не было бы возможности пробежать в цикле по всем символам и, скажем, изменить их регистр – пришлось бы вставлять 1000 строк кода для каждой такой операции. А если мы заранее не знаем, какой будет текст? Или нам нужно скопировать часть символов из одной строки в другую? В такой постановке задача без использования массивов становится невыполнимой.
Массивы Arduino
В Ардуино мы можем использовать те же инструменты для работы с массивами, что и в С++. Все основные операции с массивами можно разделить на следующие группы:
- Создание и инициализация массива.
- Операции с элементами массива (поиск, добавление, удаление).
- Изменение длины массива.
- Удаление массива.
В статье мы рассмотрим все эти операции более подробно.
Создание массива
При создании мы обязательно указываем тип массива, название массива и специальные символы “[“ и “]”. Также мы обязательно задаем размер массива явным или неявным образом. Вот пример создания массива из 5 элементов типа int.
- int – тип данных, которые будут содержаться в массиве (в данном случае int).
- sensorValues – название массива (одновременно является указателем на него).
- [5] – размер массива, компилятор заложит инструкции, которые выделят память под этот массив в рамзмере 5*2 = 10 байтов. 5 элементов по 2 байта.
При создании массива можно сразу инициализировать его содержимое, это делается с помощью символов <>:
- int arrPins[] = <3, 6, 4, 3, 7>— в данном случае объявляются элементы, а размерность не декларируется. Размерность массива происходит компилятором автоматически (в приведеном примере определены 5 элементов, значит размер массива равняется 5).
Можно одновременно задать размер массива и проинициализировать элементы:
- int arrValues[6] = <5, 654, 120, 982, 15>; – выделяется размер и выполняется инициализация некоторых элементов.
Пример массива, состоящего из символов (тип char), который мы сразу инициализируем символами из строки:
Разновидности массивов Ардуино
Массивы, размерность которых представлена одним символом являются одномерными. Массивы, в которых каждый элемент может сам являться массивом, называются многомерными. В многомерных массивах имеется несколько индексов, для каждого из «подмассивов». Вот примеры создания массивов разных размерностей:
- int array1[10]; // одномерный массив из 10 элементов
- int array2[10][2]; // двумерный массив из 10 элементов, каждый из которых является массивом из 2 элементов.
- int array3[10][2][5]; // многомерный массив из 10 элементов, каждый из которых является массивом из 2 элементов, каждый из которых состоит из 5 элементов… в доме, которой построил Джек.
Обращение к элементам массива
Получить нужный элемент массива можно, указав его порядковый номер.
Внимание! Индексация массивов в Arduino, так же как в C++, начинается с 0. Первым элементом массива будет элемент с индексом 0
Работа с массивами всегда требует особой внимательности от программиста. Вы можете обратиться к несуществующему элементу массива, если неверно зададите индекс. Иллюстрация в следующем примере
Компилятор Arduino здесь не является надежным помощником, потому что не сообщит вам об ошибке на этапе компиляции. Но во время исполнения ошибка приведет к краху программы с сообщением о том, что индекс вышел за пределы массива: Index Out Of Bound Exception.
Еще одной часто возникающей ошибкой является путаница с индексом и номером по порядку:
Длина массива в Ардуино
Для определения количества элементов в массиве нужно узнать весь объем памяти, выделенный под массив и поделить его на объем памяти каждого элемента. В Ардуино, как и в C++, размер памяти определяется с помощью оператора sizeof. Пример для массива из значений типа int выглядит следующим образом:
sizeof (myInts)/ sizeof ( int )
Для вычисления объема массива в памяти нужно перемножить количество элементов на размер в байтах одного элемента. Это же касается и двумерных массивов:
размер массива = число байт второго измерения * число байт первого измерения * sizeof (базовый тип)
Массивы и циклы Arduino
Циклы – удобный метод для работы с массивами, они применяются для повторения одинаковых действий, делая код программы компактным. Индексация каждого элемента в таком случае осуществляется при помощи переменной-счетчика цикла.
Например, для отображения на мониторе элементов массива можно использовать такой цикл for:
Массив строк
Лучшим примером двумерного массива является массив строк. Первое измерение (строки) этого массива состоят из списка элементов символов типа char. Статичная инициализация такого массива выглядит так:
Для перебора элементов массива можно использовать тот же цикл for. В данном примере мы перебираем все элементы массива и выводим их в монитор порта. После завершения вывода строки мы просим ардуино перевести строку на экране.
Использование массивов в функциях
Мы можем передавать массивы функции, помещая название массива в качестве аргумента.
Название массива является одновременно и указателем. В С++ указатель – это переменная, которая содержит адрес адреса данных. Таким образом, в имени массива уже содержится информация для того, чтобы найти начало массива.
Краткие выводы
С помощью массивов в Arduino можно оперировать с большими наборами данных, например, собирать информацию со многих подключенных данных или формировать сигналы для нескольких подключенных светодиодов. Массивы используют для хранения строк и достаточно сложно организованных структур данных. Использование массивов в Ардуино во многом похоже на C++ и требует понимания принципов адресной арифметики, постоянного контроля со стороны программиста за размерностью и типами. Но взамен массивы предоставляют гибкие возможности по хранению и динамическому изменению наборов данных. Без них написание достаточно сложных программ практически невозможно.