5.3. Применение циклов в алгоритмах обработки массивов
Массив – это ограниченный и упорядоченный определенным образом набор величин одного типа (например, 20 целых чисел, имеющих различные значения, упорядоченные по порядковому номеру их вхождения в массив: 1 – е число, 2 – е и т.д.).
Каждая величина, входящая в массив, называется элементом массива. Она снабжается индексом, при помощи которого из массива можно выбрать нужное значение. Индекс обычно является величиной целого типа с начальным значением равным 1.
Например, задан массив x из пяти целых чисел
x1
x2
x3
x4
x5
Рис.5.3. Схема алгоритма для табуляции функции на отрезке
Значения его элементов, например, x2=7, можно использовать в различных вычислениях так же, как и значения обычных величин. Массив, элементы которого имеют только один индекс, называется одномерным (другие названия: линейный, вектор). Он представляет собой таблицу, состоящую из одной строки (или одного столбца).
Если же одни и те же операции производятся над всеми элементами массива (например, по вводу или выводу), то для этой цели уместно использовать циклический алгоритм. Причем параметром цикла будет являться величина, определяющая значения индекса у элементов массива. Обычно ее принято обозначать буквами: i, j,k…, а принимает в цикле эта величина значения, начиная с 1 (начальное значение индекса) до значения, равного количеству элементов в массиве (называемого размерностью), с шагом равным 1 (хотя используется и индексация, начинающаяся с нуля или с шагом, отличным от 1).
Для организации такого цикла обычно используется типовая структура цикла с предусловием (рис.5.1.(а)).
Замечание. В ряде задач требуется использовать не все элементы массива, а только некоторую часть. Это потребует несколько иной организации цикла.
Пример 1. Вычислить сумму элементов массива, стоящих между пятым и двадцатым элементами.
начальное значение параметра цикла =6;
конечное значение параметра цикла =19;
шаг изменения =1.
Вычислить произведение тех элементов массива, которые стоят на четных местах.
В этом случае идет речь только о тех элементах, у которых значение индекса кратно 2. Нужно организовать цикл с параметром цикла, у которого:
— начальное значение =2;
— конечное значение = числу элементов в массиве;
— шаг изменения =2.
5.3.1. Ввод-вывод одномерных массивов
Пусть требуется осуществить ввод значений одномерного массива х, состоящего из N элементов (можно условно предположить, что при вводе значений элементов массива ими заполняются ячейки памяти компьютера, зарезервированные для этой цели).
Решение. Сначала определим из скольких элементов состоит массив, а затем в цикле по i=1,2,…, N организуем ввод i-ого элемента (рис.5.4(а)).
Рис.5.4. Схема ввода-вывода элементов массива
В дальнейшем, чтобы сократить запись схемы алгоритма мы будем использовать для ввода и вывода одномерных массивов обозначения следующего вида:
подразумевая однако, что под ними подразумеваются схемы, представленные на рис.5.4.
Зачем нужен цикл в массиве?
Обычно для чего используют перебор элементов в массиве?
Прошу не губить, так как я новичок.
Чтобы проходиться по массиву. Можно его изменять, например
Пример, как посчитать сумму элементов в массиве, для этого подойдёт цикл:
Пример, надо создать функцию, которая возвращает true, если в массиве есть число 5, иначе функция возвращает false:
Пример, вывести в консоль только нечетные элементы массива:
Дизайн сайта / логотип © 2023 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2023.3.11.43304
Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.
Name already in use
intensive-php-guide / guide / part2.md
- Go to file T
- Go to line L
- Copy path
- Copy permalink
- Open with Desktop
- View raw
- Copy raw contents Copy raw contents
Copy raw contents
Copy raw contents
Продолжаем изучать синтаксис языка
Массив — это еще один тип данных, вроде числа или строки. Главное отличие массива от остальных типов данных — это его способность хранить в переменной больше одного значения. В предыдущих примерах имя переменной всегда ассоциировалось только с одним значением:
- $name = «Иннокентий»
- $age = 42
Но что если мы хотим узнать у пользователя не только его пол, имя и возраст, но и, допустим, любимые сериалы. Очень непросто назвать один самый любимый сериал, а вот вспомнить несколько — намного легче. Так выглядит сохранение в переменную-массив нескольких значений: $fav_shows = [«game of thrones», «american horror storry», «walking dead»]
В этом примере мы сохранили в переменной $fav_shows сразу три значения. Но сохранить эти данные — это только половина дела. Как с ними потом работать? Уже знакомый способ вывода переменной на экран с массивами, к сожалению, работать не будет:
Так увидеть список любимых сериалов не получится. Дело в том, что массив — это не совсем обычная переменная. Массив хранит не простые типы, вроде текста или чисел (их еще называют «скалярными типами»), а более сложную структуру данных, поэтому здесь нужен особый подход.
Внутри массива у каждого значения есть свой адрес, по которому к нему можно обратиться. Такой адрес называется индексом. Индекс — это просто порядковый номер. Индексация начинается с нуля, так что первый элемент получает индекс — «0», второй — «1» и так далее.
Итак, чтобы получить определенный элемент массива, необходимо знать его индекс (ключ). Покажем названия всех сериалов из массива, разделив их запятыми:
Теперь можно дать определение массива:
Массив — это совокупность множества элементов вида «ключ : значение».
Массивы позволяют перезаписывать существующие значения, а также добавлять новые. Чтобы добавить в массив новое значение, существует такая инструкция: $fav_shows[] = «the big bang theory»
Новый элемент массива автоматически получит индекс равный максимальному индексу из существующих + 1. В нашем случае «теория большого взрыва» сохранится под индексом 4.
Теперь посмотрим как заменить любой элемент массива. Вдруг нам перестал нравиться один из сериалов, т.к. новый сезон оказался очень плох или появился новый фаворит. Чтобы вычеркнуть старое значение и заменить его новым, надо просто присвоить новое значение любому из существующих в массиве индексов: $fav_shows[4] = «fargo»
Для полного удаления (без замены на другое) значения по его индексу существует функция unset : unset($fav_shows[4])
В предыдущем разделе мы познакомились с так называемыми простыми массивами. Но в PHP существует еще и другой, чуть более сложный тип массивов — ассоциативные. Ассоциативные массивы отличаются от простых только тем, что вместо индексов у них ключи. И если индекс всегда является целым, порядковым числом, то ключ может быть любой произвольной строкой. Вот для чего это нужно: Мы уже знаем достаточно много о нашем пользователе: его имя, возраст, любимый цвет и сериалы. Есть только одно неудобство: все эти данные сейчас раскиданы по разным переменным. Как было бы удобно сохранить все эти данные внутри одного массива. Именно в таких ситуациях могут очень пригодиться ассоциативные массивы.
Запись всей информации о пользователе с помощью ассоциативного массива:
Обрати внимание: массив может содержать другой массив в качестве одного из значений. В нашем примере мы поместили простой массив внутри ассоциативного под ключом «fav_shows».
Вывод информации из ассоциативных массивов аналогичен простым массивам.
Показ всей информации о пользователе, сохраненном в переменной $user :
Цикл — это конструкция языка, которая позволяет выполнить блок кода больше одного раза.
Мы привыкли, что наши сценарии выполняются линейно: сверху вниз, строчка за строчкой, инструкция за интструкцией. Но что делать, если надо повторить какую нибудь инструкцию несколько раз?
Например, как вывести на экран все натуральные числа (1. 9)? Никто не мешает сделать это очевидным способом:
Но, во первых, такой способ заставляет писать много кода. Во-вторых: что если требуется вывести последовательность из миллиона чисел? И, наконец, бывают ситуации, когда заранее неизвестно сколько раз нужно выполнить определенную инструкцию.
Использование циклов значительно упрощает и укорачивает код. Также циклы незаменимы в ситуациях, когда заранее неизвестно сколько раз должен выполниться блок кода. Такое число может зависеть от множества условий и вычисляется в момент выполнения сценария.
Так в PHP выглядит цикл:
В прошлой главе учебника вы познакомились с понятием выражения и его истинностью. Выражения часто используются в циклах следующим образом: выражение помещается на место <условие цикла> и определяет, будет ли исполнен блок кода — <тело цикла>.
Если выражение из условия цикла возвращает истину, то выполнение сразу перейдет к блоку «тело цикла», если же оно вернет ложь — то тело цикла исполнено не будет и сценарий продолжит выполняться как обычно, со следующей строки после цикла.
Выходит, что циклы имеют такое название, потому что как бы «зацикливают» обычное, линейное исполнение на своем блоке кода и не дают сценарию выполняться дальше, пока условие цикла будет истинным.
Важно понимать последовательность, в которой исполняется код при использовании циклов.
- Обычное исполнение кода, строчка за строчкой, пока не встретился цикл
- Встретился цикл: выполняем условие цикла
- Если условие вернуло ложь: выходим из цикла, выполняем строчку после него и продолжаем линейное исполнение
- Если условие вернуло истину: выполняем всё тело цикла
- Повторяем пункт 2
Каждая последовательность из шагов 2-4, т.е. очередное выполнение блока кода в теле цикла — называется итерацией.
Количество итераций должно быть конечным, т.е., как правило, бесконечное выполнение одного блока кода не входит в наши планы.
А значит необходимо заранее предусмотреть ситуацию, когда истинное условие станет ложным.
Теперь вернемся к задаче по выводу на экран всех натуральных чисел:
Данные цикл в своем теле содержит две инструкции. Первая выводит на экран цифру из переменной. Вторая инструкция увеличивает значение переменной на единицу. Теперь вопрос: сколько раз будет исполнен такой цикл?
Циклы выполняются, пока их условие остается истинным, а в нашем условии значение переменной должно быть меньше десяти. Т.к. начальное значение переменной — единица, то не сложно посчитать, что цикл выполнится ровно девять раз. На десятый раз значение переменной $last_num станет равно десяти и условие $last_num < 10 перестанет быть истинным.
Циклы и массивы
Чаще всего циклы используются для работы с массивами. А конкретнее — для перечисления всех элементов массива и выполнения какого нибудь действия с каждым из этих элементов.
Умение использовать циклы и массивы совместно, сразу позволит тебе выполнять множество интересных и разнообразных задач!
Чуть раньше мы уже научились работать с массивами. Например, мы можем показать все значения массива, обратившись к каждому из элементов по его индексу. Но это чрезвычайно утомительно: обращаться к каждому из элементов массива по очереди, когда мы просто хотим показать всего его значения. Циклы избавят от этой рутины!
С помощью циклов можно показать содержимое любого массива и это потребует всего несколько строк кода!
Перепишем пример с выводом списка любимых сериалов, но теперь задействовав цикл:
В этом примере цикл выводит элемент по индексу. Индекс теперь находится в переменной $cur_index и начальное значение у него ноль. Значение переменной увеличивается на единицу с каждой итерацией цикла, пока не достигнет трех. В этот момент условие $cur_index < 3 перестанет быть истинным и цикл остановится, перебрав весь массив.
foreach — специальный цикл для массивов
Настало время узнать, что циклы в PHP могут быть разных типов. Выше мы познакомились с циклом типа while . Главная особенность этого типа в том, что необходимо указывать выражение в его условии. Но while — это не единственный вид циклов в PHP. Есть еще как минимум два других.
Массивы и циклы так часто используются вместе, что разработчики языка даже добавили вид цикла специально для перебора массивов. Он называется foreach . Но что не так с обычным while и зачем понадобилось придумывать этот foreach ?
Дело в том, что цикл while слишком универсален. А платой за эту универсальность всегда будет более сложный и обьемный код. Приходится придумывать условие, следить, чтобы оно не было бесконечным. А в теле цикла обязательно надо не забыть увеличивать переменную-счетчик. И все это нужно для простого перебора элементов массива. Неужели нельзя сделать проще?
К счастью, foreach решает все эти проблемы. Вот его возможности:
- не требуется писать условие
- позволяет получать ключи массива
- сам присваивает очередной элемент массива переменной
Цикл foreach становится совершенно незаменим, когда дело доходит до итерации по ассоциативным массивам. Возьмем такой пример: у нас есть данные пользователя, которые хранятся в ассоциативном массиве. На сайте понадобилось сделать страницу с информацией об этом юзере. Задача состоит в том, чтобы показать на странице все данные, которые известным об этом человеке. Выглядеть это должно так:
| Ключ | Значение |
|---|---|
| Имя | Евгений |
| Возраст | 27 |
| Род занятий | Программист |
Оригинальный массив, который надо показать в таком виде:
Код сценария, который обойдет массив и покажет все его содержимое займет всего 4 строчки:
На каждой итерации цикла, внутри его тела будут определяться переменные $key и $value . В первую будет попадать очередной ключ массива, а во вторую — очередное значение по этому ключу.
Если говорить простым языком, то функция — это блок кода, который может быть именован и вызван повторно. Иногда функцию еще называют подпрограммой. Мы привыкле, что обычной переменной можно присвоить число, строку или массив, а затем получить его обратно, обратившись к значению по имени переменной. Функция устроена очень похоже. Это тоже своего рода переменная, только вместо строки или числа, в ней хранится блок кода, который вызывается при использовании этой «переменной».
Функция — это очень мощный инструмент повторного использования кода. Ведь создав свою функцию и записав туда необходимый код, ты сможешь вызывать и использовать его столько раз, сколько необходимо. В противном случае бы пришлось копировать и вставлять фрагмент кода каждый раз, когда он понадобится.
Чтобы упростить себе работу, мы можем оформить в виде функцию некоторую часть кода, которая используется несколько раз в сценарии. Затем, вместо копирования и вставки этой части кода, будет достаточно только вызывать эту функцию, как если бы мы обращались к переменной.
Разделяют два типа функций — встроенные и пользовательские.
Встроенные функции — это функции, которые за нас уже написали создатели языка программирования и мы можем просто брать их и использовать. В PHP существуют тысячи готовых функций на все случаи жизни!
Одна из таких, уже очень хорошо знакомых нам функций — это функция, которая выводит переданный ей текст на экран — print()
Пользовательские функции программист создает самостоятельно. Эти функции, как правило, используются только внутри одного проекта или, даже, сценария.
Как и с обычными переменными, работа с функциями состоит из их объявления и использования.
Перед тем как использовать новую функцию, следует её объявить:
Пояснить все составные части функции проще всего на примере.
На своем сайте мы хотим показывать, является ли переданный пользователем год високосным. Для этого напишем функцию, в которую передается год. В результате работы функции мы хотим получить значение «истина», если год високосный, и «ложь» — если нет.
Определение такой функции:
Пример использования функции:
Аргументы функции и область видимости
Наша функция умеет вычислять, является переданный год високосным.
Важно понимать, что функция — это как бы программа в программе, вещь в себе. Это значит, что внутри такой функции не будут доступны переменные, которые определялись за её пределами. Чтобы передать внутрь функции информацию извне нужно использовать аргументы функции.
Аргументы функции — это переменные, которые функция может получить. При определении функции мы именуем переменные, которые функция может получить из внешнего кода. В примере с is_leap_year такая переменная была только одна — $year .
Аргументы необходимы, т.к. функция «не видит» переменные, определенные за её границами. Поэтому нужные переменные надо передавать ей явно.
Верно и обратное — переменные, определенные внутри функции, не будут доступны извне. Такие переменные называются локальными, потому что они локальны по отношению к функции.
В отличие от аргументов, которых может быть несколько, вернуть во внешний код функция может только одно значение — с помощью инструкции «return» (возврат). Возвращаемое значение называют результатом работы функции.
Одномерные массивы и циклы
Что такое “цикл” уже рассказывалось во введении.
Цикл с предусловием
Цикл с предусловием характеризуется тем, что перед выполнением каждой итерации проверяется заданное условие. Если это условие ложно, то цикл прекращается. Таким образом, в случае если условие ложно с самого начала, цикл не выполнится ни разу.
Вечный цикл на основе while:
Для выхода из цикла “посередине” предназначена инструкция break . Также часто удобно использовать return , что позволяет прекратить выполнение сразу всех вложенных циклов в данной функции.
Например, можно модифицировать пример так, чтобы в случае ввода признака конца файла происходил выход из программы, а ошибки ввода игнорировались как и прежде. Для этого добавим “посередине” комбинацию if-break:
Цикл с постусловием
Цикл с постусловием отличается от цикла с предусловием тем, что условие повторения проверяется после каждой итерации (т.е. является условием продолжения цикла). Соответственно, хотя бы один раз цикл выполнится.
На практике цикл do-while применяется намного реже цикла while.
Цикл for
Цикл for в C является “общим типом” цикла и используется значительно чаще while и do-while.
Например, вечный цикл на основе for записывается следующим образом:
Следующие два цикла эквивалентны:
Общий вид конструкции for следующий:
Определение переменных может содержать определение группы переменных (одного типа), либо просто произвольное выражение, которое вычисляется однажды перед входом в цикл. Определённые в этой локации переменные существуют только во время выполнения цикла и видны только из тела цикла.
Условие повторения проверяется перед каждой итерацией. Таким образом, цикл for может не выполнить ни одной итерации.
Инкремент — произвольное выражение, которое вычисляется после каждой итерации.
Пример простого вложенного цикла for (двойной цикл):
Нередко новички в языке C или C++ пытаются записать подобный двойной цикл одной инструкцией for:
Данный цикл будет перебирать пары значений переменных i, j вида 1, 1; 2, 2; … 10, 10 (всего 10 итераций) и выведет таблицу квадратов. Более того, конструкция i <= 10, j <= 10 равна j <= 10 . На данном цикле это не сказывается из-за того, что i всегда равно j.
Оператор запятая , вычисляет левую часть (до запятой), отбрасывает результат, затем вычисляет правую часть (после запятой). Этот оператор был введён в C как раз для того, чтобы было удобно записывать несколько действий внутри инкремента цикла for, и пригождается в некоторых других случаях, поэтому иногда будет встречаться в примерах. Оператор , отличается от запятой, разделяющей элементы в списках (например, параметры функции). Чтобы “включить” оператор , в контексте списка, надо взять выражение в скобки: sin( (++x, y) ) выполнит ++x и вернёт sin(y) .
Статические массивы
В случае, когда требуется группа однотипных значений определённого размера, удобно воспользоваться средством языка программирования, называемым массив array . Простейшей формой организации массивов в языке C++ являются одномерные статические массивы.
Слово одномерный означает, что для выбора конкретного значения из группы используется одно целое число — порядковый номер этого значения — его индекс (от лат. index — “указательный палец”). У такого массива единственное измерение, имеющее размер, равный количеству элементов в массиве. Индексы в C и C++ всегда отсчитываются от нуля (первый элемент) до размера измерения – 1 (последний элемент). Размер массива не может быть меньше единицы.
Слово статический означает, что память под массив распределяется компилятором (“статически”). При этом, однако, “статический” массив может размещаться в автоматической памяти и быть локальной переменной функции. Размер статического массива должен быть известен на момент компиляции (константа времени компиляции) и не может быть изменён во время работы программы.
Далее представлен простой пример, демонстрирующий определение статического массива и обращение к его элементам (с помощью оператора [] ).
В примере выше размер задан конкретным числом, но использование в таких целях непосредственно чисел чревато ошибками: если изменить размер массива в его определении, то можно забыть изменить его в других местах. Если выполнять автоматическую замену числа в тексте, то каждый случай замены надо проверять, а для больших программ это неудобно. Поэтому лучше определять размер в виде именованной константы и затем везде использовать не конкретное число, а его название.
Указатели и массивы
Указатели являются адресами в явной форме и широко применяются при работе с массивами. Массив автоматически приводится к указателю на свой первый элемент. Для указателей допускается “арифметика указателей”. Эта арифметика напоминает аффинную структуру поверх векторного пространства: вектора можно и складывать, и вычитать, и умножать на число, а точки можно только вычитать, получая вектор. Также можно добавлять к точке или вычитать из точки вектор, получая другую точку. Аналогично с указателями: роль “векторов” играют целые числа, роль “точек” — указатели.
Указатели можно вычитать, получая целое число со знаком — смещение offset от одного указателя к другому в элементах массива, на которые указывают эти указатели. Если указатели не указывают на элементы одного массива, то попытка вычислить их разность приводит к неопределённому поведению. И наоборот, к указателю на некоторый элемент массива можно добавить (или вычесть из него) целое число (смещение), чтобы получить указатель на другой элемент массива, отстоящий от первого на заданное смещением число элементов. Полученный указатель может “выходить” на верхнюю границу массива, указывая на несуществующий элемент, который шёл бы сразу за последним элементом массива. Разность между таким указателем и указателем на первый элемент массива (на начало массива) равна размеру массива. Наконец, указатели позволяют обращаться к ним как к массивам, что эквивалентно обращению к смещённому на индекс указателю.
Указатели можно сравнивать не только на “равно” и “не равно”, но и “меньше”, “больше” и т.д. При этом p < q эквивалентно p — q < 0 .
Часто с указателями используются операции инкремента ++ и декремента — . Они передвигают указатель на, соответственно, следующий и предыдущий элементы. Рассмотрим пример — копирование массива символов до первого нулевого символа (включая его):
Здесь *dest++ и *src++ передвигают соответствующие указатели на одну позицию вперёд, но так как постинкремент возвращает старое значение переменной, то именно это старое значение указателя подвергается разыменованию, поэтому мы получаем ссылки на символы, стоящие на тех позициях, на которые указывали dest и src до инкремента.
Определение размера массива и передача массива в функцию
Размер статического массива в контексте видимости его объявления или определения можно запросить у компилятора (ведь размер известен на момент компиляции). Оператор sizeof , применённый к имени массива, возвращает его размер в байтах. Чтобы получить количество элементов, можно разделить размер массива в байтах на размер одного элемента.
Данный способ применяется в примерах ниже, но следует помнить, что он тоже несёт в себе опасность ошибки. Дело в том, что массивы часто передают по указателю и затем используют этот указатель как массив (для указателя также определён оператор [] , и действует он аналогично). Нередко программисты забывают о том, что некое имя — это уже не имя массива, а имя указателя на него. Оператор sizeof в таком случае возвращает размер указателя в байтах, а не размер массива, на который он указывает. Это очень неприятная ошибка, встречающаяся в реальном ПО, написанном на языке C.
Функция fill_with_squares на самом деле не видит определения массива, который может быть передан ей в качестве параметра. Это легко понять хотя бы исходя из того соображения, что исходный код, который будет использовать данную функцию, может быть написан уже после того, как тело этой функции было откомпилировано (раздельная компиляция).
Синтаксис объявления параметра функции в виде массива на самом деле объявляет передачу адреса массива (указателя на него) и только адреса. Поэтому не важно, какой размер указать там между квадратными скобками — можно не указывать никакого (как в примере). Если этот размер указать, то он может послужить для удобства чтения или в качестве намёка компилятору (с точки зрения оптимизации или предупреждений), но на семантику программы влияния не окажет.
Впрочем, C++ позволяет форсировать определённый размер массива, если принимать массив по ссылке. Например, в следующей функции мы требуем массивы из трёх элементов, представляющие трёхмерные вектора, над которыми выполняется операция “векторное произведение”. Однако такая функция будет работать только со статическими массивами. На практике это может оказаться слишком ограничивающим.
В C++17 введена стандартная функция size (определённая в <iterator> ), которая при применении к статическому массиву возвращает его размер в элементах. Применить её ненароком к указателю не получится — будет ошибка компиляции.
Впрочем, при отсутствии такой стандартной функции, её можно написать самостоятельно. Для этого даже не требуется поддержка компилятором новых стандартов C++. Но требуется использовать такой элемент языка как “шаблон функции” — это материал 2-го семестра.
Итак, правильный способ передачи в функцию массива, размер которого не задан некоторой глобальной константой, состоит в передачи как его адреса, так и его размера. Побочным эффектом такого подхода является возможность передавать части массива (например, все элементы со второго до предпоследнего) — такие части массивов ещё называют срезы slices . Сам массив является наибольшим своим срезом.
Другой способ передачи среза — передать два указателя: один (“begin”) — на первый элемент среза, второй (“end”) — на (возможно, фиктивный) элемент, следующий за последним элементом среза. Таким образом, последовательность элементов задаётся своего рода полуинтервалом [begin, to), называемым также диапазоном range . Проходящий по ней указатель вначале устанавливается на begin, а при достижении им значения end работа прекращается. Например, функцию fill_with_squares для работы с диапазоном можно переписать следующим образом:
Иногда в такой ситуации можно обойтись и без индекса. Например, если мы заполняем массив копиями заранее заданного значения:
Или просто выводим массив в консоль:
Данный подход был обобщён в Стандартной библиотеке C++ в виде принципов работы с абстрактными диапазонами итераторов. Например, вариант fill_with_squares на основе диапазона позволяет переписать пример с заполнением статического массива без использования громоздкого выражения с sizeof. Вместо этого, границы диапазона, соответствующего массиву можно получить с помощью стандартных функций begin и end , определённых в заголовочном файле <iterator> (C++11). Дополнительный плюс этого подхода в том, что попытка вызвать begin или end от указателя приведёт к ошибке компиляции, т.е. ошибка, аналогичная ошибке с sizeof, здесь невозможна.
Если функция принимает размер массива, а не диапазон, то вместо sizeof всё равно можно использовать комбинацию begin/end: end(squares) — begin(squares) .
Цикл for для диапазона
Данная форма цикла for была введена в язык C++ в стандарте 2011 года и представляет собой вариант цикла “выполнить для каждого элемента”. Итерация выполняется для каждого элемента обобщённого диапазона. Для этого запись вида
трактуется компилятором приблизительно как следующий код (переменные с префиксом __ не видны из пользовательского кода):
Поэтому, например, вместо
можно было написать
При изменении элементов массива в цикле следует указывать ссылочный тип:
Инициализация массива
Статические массивы можно инициализировать непосредственно на месте определения, указывая значения элементов. Если этого не сделать, то глобальные массивы инициализируются нулями, а локальные не инициализируются и могут содержать произвольные значения.
При инициализации не обязательно указывать все элементы — конечные можно опустить. Если указанных элементов меньше, чем размер массива, то оставшиеся в его конце элементы будут инициализированы нулями. И наоборот, при наличии в определении массива непустого инициализирующего выражения не обязательно указывать его размер. Если размер не будет указан явно, то в качестве размера будет взято количество элементов в инициализирующем выражении.
Несколько примеров инициализации (попробуйте запустить этот код).
Начиная с C++11, писать = в инициализаторе массива не обязательно:
есть то же самое, что
Многомерные массивы
Статические массивы
Поддержка многомерных массивов языками C и C++ весьма ограничена. Можно создать статический многомерный массив, который интерпретируется как массив массивов. Например, массив из двух массивов по три элемента типа int:
В памяти такие массивы укладываются последовательно одним блоком, эквивалентным одномерному массиву размера, равного произведению размеров по каждому из измерений. Т.е. в случае приведённого выше примера имеем блок из шести int (24 байта, если int занимает 4 байта), заполненный значениями 1, 2, …, 6 подряд — порядок заполнения в памяти соответствует порядку записи в инициализаторе: первая строка-подмассив из трёх элементов, затем вторая строка-подмассив из трёх элементов.
При обходе такого массива самый правый индекс соответствует элементам, стоящим друг за другом непосредственно, шаг же по прочим индексам равен произведению размеров измерений, стоящих правее. Т.е. arr[i][j] и arr[i][j+1] — соседствуют в памяти, а вот расстояние между адресами arr[i][j] и arr[i+1][j] равно размеру всей строки arr[i] , т.е. 3*sizeof(int) в этом примере.
Статический массив можно передать в функцию по указателю, но при этом необходимо явно указывать размеры всех измерений кроме самого левого, потому что иначе у компилятора не будет информации о том, на каком расстоянии в памяти элементы отстоят друг от друга (неизвестен шаг между ними). Например, можно передать в функцию указатель на массив произвольного размера, состоящий из массивов по три int:
Более того, так как размеры подмассивов известны компилятору (зашиты в тип параметра a ), то можно оперировать ими как обычными статическими массивами. Например, пробегать по ним, используя форму цикла for для диапазонов:
Естественный обход многомерного массива осуществляется с помощью вложенных циклов for, каждый из которых перебирает диапазон значений индекса одного из измерений. Статический массив можно обойти целиком с помощью for:
Значок & после auto обозначает ссылку на объект, которая представляет собой неявный указатель и ведёт себя как объект, на который она ссылается (не требует явного разыменования). Во втором цикле for использование ссылки не обязательно (там можно опять поставить просто int как в предыдущем примере), а вот в первом — обязательно. Это связано с тем, что хотя в C++ и возможен тип int[3] (тип элементов массива arr , понимаемого как массив массивов), но невозможны временные значения такого типа. Поэтому оперировать статическими массивами можно только по указателю или завуалированному указателю — ссылке.
При инициализации статических многомерных массивов можно опускать внутренние фигурные скобки. При этом следует помнить, что логика заполнения массива элементами заключается в последовательном копировании заданных значений в массив (от младших адресов в памяти к старшим) и заполнении остатка нулями. Так же как и в случае одномерных массивов, начиная с C++11, можно опускать = в инициализаторе.
Может быть опасно изменять код, удаляя “лишние” скобки в инициализаторе:
Удалив внутренние скобки, получим запись последовательности < 1, 0, 1, 0, 0, 1, 0, 0, 0 >в m[3][3] (интерпретируемом как m[9])
Впрочем, статические массивы не очень популярны, а многомерные статические массивы используются только в особых случаях: обычно для матриц заранее фиксированных размеров (например, представляющих линейные отображения в трёхмерном пространстве). Чаще используются динамические массивы.
Многомерные динамические массивы в C и C++ можно реализовать различными способами. Далее представлено три способа.
Динамические массивы
Динамические массивы — массивы, располагающиеся в динамической памяти. В отличие от статических массивов, размер динамических массивов может определяться по ходу выполнения программы.
В C++ предусмотрены операторы new[] для создания динамических массивов (оператор возвращает ненулевой указатель на массив, в случае ошибки бросается исключение) и delete[] для их удаления.
Способ 1
Создать массив указателей на массивы (матрица — вектор векторов). Создать каждый подмассив в виде отдельного динамического массива. Способ позволяет оформлять обращение к элементам динамического многомерного массива так же, как к элементам статического: заключая каждый индекс в квадратные скобки.
Недостатком данного способа является множество выделений-освобождений динамической памяти и возможная “разбросанность” подмассивов в памяти. (Если бы все элементы массива шли в памяти подряд, то из этого можно было бы извлечь пользу в плане производительности и удобства кодирования некоторых операций.)
Преимуществом данного способа является относительная гибкость: можно, например, заменять или переставлять подмассивы, не затрагивая весь массив (достаточно изменить соответствующие указатели головного массива). Можно даже создавать подмассивы разной длины — “рваный” массив jagged array, ragged array .
Способ 2
Данный способ предполагает другую крайность — явно хранить всё содержимое многомерного массива в виде одномерного массива, переводя многомерные индексы в одномерные. Т.е. явно делать то, что делает компилятор при работе со статическими многомерными массивами.
Массив с размерностями (d0, d1, …, dr–1) содержит d0·d1⋯dr–1 элементов. Количество размерностей r называют рангом rank массива. При укладке их подряд в памяти в духе статического многомерного массива получаем следующую формулу приведения r-мерного (векторного) индекса (i0, i1, …, ir–1) к одномерному индексу I в блоке:
В общем случае его удобно вычислять методом Горнера (только вместо домножения на x домножаем на следующий индекс).
В примерах ниже именно этот способ используется для представления матриц с произвольными размерами. В двумерном случае приведённая выше формула приобретает простой вид: I = i1 + i0 d1 (массив строк, в каждой строке по d1 столбцов). Т.е. индекс по первому измерению надо умножить на размер второго измерения и добавить индекс по второму измерению.
Преимуществами способа 2 являются: удобство кодирования и в среднем большее быстродействие операций, выполняемых над массивом целиком, а также минимизация операций выделения и освобождения памяти, минимизация затрат памяти (нет вспомогательного массива).
Недостатки: выделение сразу большого куска памяти может производиться медленно или быть вовсе невозможным из-за фрагментации кучи; простые операции, вроде перестановки строк, невозможно выполнить простой манипуляцией указателями: необходимо либо явно обменивать все элементы строк, либо применять промежуточное преобразование индексов, либо создавать новый изменённый массив.
Способ 3
Данный способ является гибридом двух предыдущих и удобен в случае двумерных массивов. Память выделяется сразу на все элементы массива (первый блок) и отдельно на головной массив с указателями, которые инициализируются вычислением смещений подмассивов (второй блок). В примере ниже указатель на массив-хранилище записывается “перед” первым элементом головного массива, чтобы можно было корректно удалить хранилище, не опираясь на, возможно, изменённые адреса подмассивов.