Массивы в c кратко
Обновлено: 05.07.2024
Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.
Объявление массивов и инициализация массивов
Объявление массивов
Массив – это структура данных для хранения элементом определенного типа, имеющая фиксированный размер. Доступ к элементам массива производится по числовому индексу.
Для объявления массива, после указания типа его элементов, ставятся квадратные скобки:
Перед использованием, массив обязательно нужно проинициализировать, это можно сделать сразу, при его объявлении:
Либо после объявления:
Для доступа к элементам массива используются числовые индексы. Значения элементов массива будут равны значению по умолчанию для типа, массив которого был создан.
Например, для указанного выше a3 – это будут нули, так как для типа int значение по умолчанию: 0;
Если попытаться вывести элементы массива na1 :
то приложение не будет собрано, т.к. массив предварительно нужно проинициализировать.
Инициализация массивов
Рассмотрим различные варианты инициализации массива. Как уже было сказано, можно просто указать количество элементов в массиве, при этом его элементам будут присвоены значения по умолчанию:
После объявления массива значения элементам присваиваются через индекс:
Есть возможность задать конкретные значения в момент объявления с использованием ключевого слова new и указанием типа:
Либо без ключевого слова new:
Неявная типизация
При объявлении массива можно воспользоваться ключевым словом var . При этом тип элементов массива следует задать явно в правой части объявления:
Либо предоставить возможность “поработать” системе вывода типов:
Доступ к элементам массива. Обход элементов массива.
Как уже было сказано выше, за доступ к элементам массива отвечают числовые индексы:
При этом, если вы укажете индекс больше, чем максимально возможный, то будет выброшено исключение:
Приведенная выше строка приведет к выбросу следующего исключения:
Unhandled exception. System.IndexOutOfRangeException: Index was outside the bounds of the array .
Обход элементов массива можно производить с помощью циклов for , foreach и while , последний самый неудобный для работы с массивами, его мы рассматривать не будем. Если вы работаете с циклом for , то для указания верхней границы инкрементируемой переменной можно воспользоваться свойством Length у массива:
Более удобным для обхода элементов будет foreach :
Преимущество цикла for состоит в том, что в нем вы можете модифицировать элементы массива:
Передача массива в метод
Массивы являются ссылочным типом данных, это означает, что их значения хранятся в куче, а имя переменной массива является ссылкой на соответствующую область памяти. При передаче массива в качестве аргумента в метод, происходит присваивание значения переменной массива переменной определяющей аргумент, а так как имя массива – это ссылка, то фактически происходит передача ссылки на значение в куче. Поэтому, если вы передали массив в функцию и внутри этой функции произошла модификация этого массива, то исходный массив тоже изменится.
Создадим метода WorkWithArray , который изменяет содержимое массива:
Вызовем его в методе Main :
Ниже приведена иллюстрация того, как массив и ссылки на него располагаются в памяти.
Переменные na5 в методе Main и arr в методе WorkWithArray ссылаются на одну и ту же область памяти в куче, поэтому изменение массива через переменную arr отражается на переменной na5 .
Многомерные массивы
Прямоугольные массивы
Прямоугольные массивы могут содержать несколько измерений (два и более), при этом количество элементов в каждом подизмерении (в каждой строке) одинаково.
Рассмотрим на примерах работу с такими массивами:
Зубчатые массивы
В зубчатых массивах элементами верхнего уровня являются другие массивы, это позволяет создавать многомерные структуры, у которых строки имеют разную длину:
Класс System.Array
Свойства класса System.Array
Имя свойства
Назначение
Число элементов в массиве. Учитываются все измерения.
Ранг массива – число измерений.
Методы класса System.Array
Символ * после названия метода означает, что он имеет более одной сигнатуры, за дополнительной информацией обращайтесь к официальной документации.
Имя метода
Назначение
BinarySearch(Array, Object)*
Выполняет поиск элемента в массиве.
Clear(Array, Int32, Int32)
Присваивает значение по умолчанию определенному количеству элементов массива начиная с заданного индекса.
Создает копию массива (неполную).
Copy(Array, Array, Int32)*
Копирует данные из одного массива в другой в заданном количестве.
CopyTo(Array, Int32)*
Копирует элементы из текущего массива в заданный, начиная с указанного индекса.
Exists (T[], Predicate )
Определяет наличие элемента удовлетворяющему предикату.
GetValue(Int32)*
Возвращает значение по указанному индексу.
IndexOf(Array, Object)*
Возвращает индекс первого вхождения элемента в массиве.
Reverse(Array)*
Задает обратный порядок для элементов в массиве.
Сортирует элементы массива.
Для вывода содержимого массива в консоль создадим метод PrintArray :
Ниже приведены примеры использования представленных выше методов и свойств класса System.Array :
Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.
Массив — это последовательность объектов того же типа, которые занимают смежную область памяти. Традиционные массивы в стиле C являются источником многих ошибок, но по-прежнему являются общими, особенно в старых базах кода. В современных C++ мы настоятельно рекомендуем использовать std:: Vector или std:: Array вместо массивов в стиле C, описанных в этом разделе. Оба этих типа стандартных библиотек хранят свои элементы в виде непрерывного блока памяти. Однако они обеспечивают гораздо большую безопасность типов и итераторы поддержки, которые гарантированно указывают на допустимое расположение в последовательности. Дополнительные сведения см. в разделе контейнеры.
Объявления стека
В объявлении массива C++ размер массива указывается после имени переменной, а не после имени типа, как в некоторых других языках. В следующем примере объявляется массив значений типа Double 1000, которые будут выделяться в стеке. Число элементов должно быть указано как целочисленный литерал или else в качестве константного выражения. Это обусловлено тем, что компилятору необходимо выяснить, сколько пространства стека следует выделить; оно не может использовать значение, вычисленное во время выполнения. Каждому элементу массива присваивается значение по умолчанию 0. Если не назначить значение по умолчанию, каждый элемент изначально будет содержать случайные значения, находящимся в этой области памяти.
Первый элемент в массиве является элементом начальном. Последним элементом является элемент (n-1), где n — число элементов, которые может содержать массив. Число элементов в объявлении должно иметь целочисленный тип и должно быть больше 0. Вы обязаны убедиться, что программа никогда не передает значение оператору индекса, который больше (size - 1) .
Массив нулевого размера допустим только в том случае, если массив является последним полем в struct или union и если расширения Microsoft включены ( /Za или /permissive- не заданы).
Массивы на основе стека быстрее выделяются и получают доступ, чем массивы на основе кучи. Однако пространство стека ограничено. Число элементов массива не может быть настолько большим, что в нем используется слишком много памяти стека. Насколько сильно зависит от программы. Для определения того, является ли массив слишком большим, можно использовать средства профилирования.
Объявления кучи
Может потребоваться, чтобы массив был слишком большим для выделения в стеке или его размер не известен во время компиляции. Можно выделить этот массив в куче с помощью new[] выражения. Оператор возвращает указатель на первый элемент. Оператор индекса работает с переменной-указателем так же, как и с массивом на основе стека. Также можно использовать арифметические операции с указателями для перемещения указателя на произвольные элементы в массиве. Вы обязаны убедиться в том, что:
- всегда сохраняется копия адреса исходного указателя, чтобы можно было удалить память, когда массив больше не нужен.
- Вы не увеличиваете или уменьшаете адрес указателя после границ массива.
В следующем примере показано, как определить массив в куче во время выполнения. В нем показано, как получить доступ к элементам массива с помощью оператора индекса и с помощью арифметики указателей:
Инициализация массивов
Можно инициализировать массив в цикле, по одному элементу за раз или в одной инструкции. Содержимое следующих двух массивов идентично:
Передача массивов в функции
Когда массив передается в функцию, он передается в качестве указателя на первый элемент, независимо от того, является ли он массивом на основе стека или кучи. Указатель не содержит дополнительных сведений о размере или типе. Такое поведение называется указателем Decay. При передаче массива в функцию необходимо всегда указывать количество элементов в отдельном параметре. Такое поведение также подразумевает, что элементы массива не копируются, когда массив передается в функцию. Чтобы запретить функции изменять элементы, укажите параметр в качестве указателя на const элементы.
В следующем примере показана функция, которая принимает массив и длину. Указатель указывает на исходный массив, а не на копию. Поскольку параметр не const имеет значение, функция может изменять элементы массива.
Объявите и определите параметр массива p так, const чтобы он был доступен только для чтения в блоке функции:
Одна и та же функция может также быть объявлена в таких случаях без изменения поведения. Массив по-прежнему передается в качестве указателя на первый элемент:
Многомерные массивы
Массивы, созданные из других массивов, являются многомерными. Такие многомерные массивы определяются путем последовательного размещения нескольких константных выражений, заключенных в квадратные скобки. Рассмотрим, например, следующее объявление:
Он задает массив типа, по int сути упорядоченный в двумерной матрице из пяти строк и семи столбцов, как показано на следующем рисунке.
Концептуальная структура многомерного массива
Можно объявить многомерные массивы, имеющие список инициализаторов (как описано в разделе инициализаторы). В этих объявлениях константное выражение, указывающее границы для первого измерения, может быть опущено. Пример:
В показанном выше объявлении определяется массив, состоящий из трех строк и четырех столбцов. Строки представляют фабрики, а столбцы — рынки, на которые фабрики поставляют свою продукцию. Значения — это стоимости транспортировки с фабрик на рынки. Первое измерение массива опущено, но компилятор заполняет его, проверяя инициализатор.
Использование оператора косвенного обращения (*) в n-мерном массиве приводит к получению n-1 многомерного массива. Если n равно 1, создается скаляр (или элемент массива).
Массивы C++ размещаются в памяти по срокам. Построчный порядок означает, что быстрее всего изменяется последний индекс.
Пример
Можно также опустить спецификацию границ для первого измерения многомерного массива в объявлениях функций, как показано ниже:
Эта функция FindMinToMkt написана таким, что добавление новых фабрик не требует каких-либо изменений кода, а только перекомпиляции.
Инициализация массивов
Массивы объектов, имеющих конструктор класса, инициализируются конструктором. Если в списке инициализаторов меньше элементов, чем элементов массива, то для остальных элементов используется конструктор по умолчанию. Если для класса не определен конструктор по умолчанию, список инициализаторов должен быть завершен, то есть должен быть один инициализатор для каждого элемента в массиве.
Рассмотрим класс Point , определяющий два конструктора:
Первый элемент aPoint создается с помощью конструктора Point( int, int ) , а оставшиеся два элемента — с помощью конструктора по умолчанию.
Статические массивы членов ( const вне зависимости от объявления класса) могут быть инициализированы в своих определениях. Пример:
Доступ к элементам массива
К отдельным элементам массива можно обращаться при помощи оператора индекса массива ( [ ] ). При использовании имени одномерного массива без индекса он вычисляется как указатель на первый элемент массива.
Если используются многомерные массивы, в выражениях можно использовать различные сочетания.
В приведенном выше коде multi является трехмерным массивом типа double . p2multi Указатель указывает на массив типа, размер которого равен double трем. В этом примере массив используется с одним, двумя и тремя индексами. Хотя чаще всего указывается все индексы, как в cout инструкции, иногда бывает полезно выбрать конкретное подмножество элементов массива, как показано в следующих инструкциях cout .
Перегрузка оператора индекса
Как и другие операторы, оператор индекса ( [] ) может быть переопределен пользователем. Поведение оператора индекса по умолчанию, если он не перегружен, — совмещать имя массива и индекс с помощью следующего метода.
Как и во всех дополнениех, включающих типы указателей, масштабирование выполняется автоматически для корректировки размера типа. Результирующее значение не n байт из источника ; вместо этого это n-й элемент массива. Дополнительные сведения об этом преобразовании см. в разделе аддитивные операторы.
Аналогично, для многомерных массивов адрес извлекается с использованием следующего метода.
((array_name) + (subscript1 * max2 * max3 * . * maxn) + (subscript2 * max3 * . * maxn) + . + subscriptn))
Массивы в выражениях
Если идентификатор типа массива встречается в выражении, отличном от sizeof , адрес ( & ) или инициализации ссылки, он преобразуется в указатель на первый элемент массива. Пример:
Указатель psz указывает на первый элемент массива szError1 . Массивы, в отличие от указателей, не являются изменяемыми l-значениями. Вот почему следующее назначение недопустимо:
В этой статье вы научитесь работать с массивами: объявлять, инициализировать и получать доступ к элементам
Содержание
Объявление массива в C/C++
В программировании часто встречается задача обработки множества экземпляров однотипных данных. Представьте себе ситуацию: мы провели опрос 100 человек и узнали их возраст. Чтобы сохранить собранные данные, вы можете создать целочисленный массив, содержащий 100 элементов:
В C++ массивы статичны: вы не сможете изменить размер или тип элементов после объявления.
Доступ к элементам массива
Вы можете получать доступ к элементам массива, используя индексы и оператор [] . Допустим, вы объявили массив marks , как показано ниже. К первому элементу можно обратиться выражением marks[0] , ко второму - выражением marks[1] , и так далее. Доступ всегда начинается с единицы, а индекс последнего элемента на единицу меньше размера массива.
Инициализация массива при объявлении
Можно инициализировать массив при объявлении. Для этого надо указать в списке столько значений, сколько вмещает массив, либо одно значение 0, чтобы заполнить массив нулями:
Обход элементов массива в цикле
Узнать число элементов в массиве можно функцией std::size. Обойти можно, используя цикл по индексам либо range-based for:
Неопределённое поведение: выход за границы (out of bounds)
Выход за пределы массива является неопределённым поведением (англ. undefined behavior). Нет гарантий, как поведёт себя программа в этом случае. Высока вероятность, что вы испортите память других переменных, но эффект может различаться в разных режимах компиляции:
Передача массива как параметра функции
Массив в стиле языка C хранит только указатель на начало и не хранит свой размер, что и создаёт сложность в передаче в функцию. Размер массива известен во время компиляции, но не известен во время выполнения. Поэтому передать размер можно несколькими не очень очевидными путями:
Динамически изменяемый массив
Обычные массивы имеют неизменный размер. Вы можете ввести вспомогательную переменную, которая бы хранила число реально используемых ячеек массива. Но и в этом случае вы не сможете использовать элементов больше, чем задано при компиляции в виде размера массива.
Так мог бы выглядеть имитация динамического массива:
Класс std::vector
Стандартная библиотека C++ содержит шаблонный класс vector, который работает как динамический массив произвольного размера. Размер может расти до тех пор, пока у операционной системы есть область памяти подходящего размера (вплоть до нескольких гигабайт).
Класс является шаблонным, то есть при объявлении переменной потребуется параметризовать шаблон класса vector типом элемента:
Использование вектора похоже на использование массива:
- работает запрос элемента ages[index] , причём индексация так же начинается с нуля
- при выходе за границы динамического массива так же возникает неопределённое поведение (англ. undefined behavior)
- работает перебор элементов с помощью индексов, range-based for или итераторов
- есть метод size для получения размера: ages.size()
Добавление элементов в конец массива
Для добавления существует два метода: push_back и emplace_back
- push_back получает значение элемента и добавляет в конец
- emplace_back работает сложнее: он получает параметры, необходимые конструктору элемента, и конструирует его прямо в конце массива
Вы можете практически всегда использовать push_back. Метод pop_back можно использовать для удаления элемента:
В документации std::vector можно прочитать о других методах.
Перемещение элементов в памяти при изменении массива
Динамический массив использует для хранения элементов динамическую память (так же известную как “куча”, англ. heap). При добавлении большого числа элементов динамический массив несколько раз перераспределяет память, поскольку выделенной ранее линейной области памяти уже не хватает для хранения всех элементов. Обычно при нехватке памяти под очередной элемент vector запрашивает новую область памяти в 1,5-2 раза больше предыдущей, перемещает в неё уже существующие элементы и добавляет в конец новый, а затем освобождает старую область памяти.
Если не сообразили, как это происходит, взгляните на картинку:
Новая область находится уже другом месте, потому что менеджер динамической памяти не мог просто взять и расширить старую область (ведь сразу за ней находилась чужая память). Поэтому все итераторы, ссылки и указатели на элементы могут стать некорректными после любого изменения массива!
Метод erase для удаления элементов из середины
Метод erase класса vector получает итератор и уничтожает элемент, на который итератор указывает:
Последствия перемещения элементов: ошибка в простом цикле с erase
Использование итератора, ссылки или указателя на элемент после перераспределения памяти в массиве является неопределённым поведением: скорее всего произойдёт падение программы либо будет пропущено несколько элементов коллекции. Это показано в примере ниже:
Если вы запустите этот код, вы можете увидеть что угодно. Скорее всего программа выведет 10 38 99 , хотя должна вывести 10 23 7 38 99 по замыслу автора.
П усть нам необходимо работать с большим количеством однотипных данных. Например, у нас есть тысяча измерений координаты маятника с каким-то шагом по времени. Создавать 1000 переменных для хранения всех значений очень. обременительно. Вместо этого множество однотипных данных можно объединить под одним именем и обращаться к каждому конкретному элементу по его порядковому номеру.
Массив в си определяется следующим образом
[ ];
Например,
int a[100];
Мы получим массив с именем a, который содержит сто элементов типа int. Как и в случае с переменными, массив содержит мусор.
Для получения доступа до первого элемента, в квадратных скобках пишем его номер (индекс). Например
Первый элемент имеет порядковый номер 0. Важно понимать, почему. В дальнейшем будем представлять память компьютера в виде ленты. Имя массива - это указатель на адрес памяти, где располагаются элементы массива.
Рис. 1 Массив хранит адрес первого элемента. Индекс i элемента - это сдвиг на i*sizeof(тип) байт от начала
Индекс массива указывает, на сколько байт необходимо сместиться относительно начала массива, чтобы получить доступ до нужно элемента. Например, если массив A имеет тип int, то A[10] означает, что мы сместились на 10*sizeof(int) байт относительно начала. Первый элемент находится в самом начале и у него смещение 0*sizeof(int) .
В си массив не хранит своего размера и не проверяет индекс массива на корректность. Это значит, что можно выйти за пределы массива и обратиться к памяти, находящейся дальше последнего элемента массива (или ближе).
Начальная инициализация массива.
Н апишем простую программу. Создадим массив, после чего найдём его максимальный элемент.
Разберём пример. Сначала мы создаём массив и инициализируем его при создании. После этого присваиваем максимальному найденному элементу значение первого элемента массива.
После чего проходим по массиву. Так как мы уже просмотрели первый элемент (у него индекс 1), то нет смысла снова его просматривать.
Тот же пример, только теперь пользователь вводит значения
В том случае, если при инициализации указано меньше значений, чем размер массива, остальные элементы заполняются нулями.
Если необходимо заполнить весь массив нулями, тогда пишем
Можно не задавать размер массива явно, например
массив будет иметь размер 3
Размер массива
М ассив в си должен иметь константный размер. Это значит, что невозможно, например, запросить у пользователя размер, а потом задать этот размер массиву.
Создание динамических массивов будет рассмотрено дальше, при работе с указателями и памятью
В некоторых случаях можно узнать размер массива с помощью функции sizeof.
Но это вряд ли будет полезным. При передаче массива в качестве аргумента функции будет передаваться указатель, поэтому размер массива будет невозможно узнать.
Статические массивы удобны, когда заранее известно число элементов. Они предоставляют быстрый, но небезопасный доступ до элементов.
Переполнение массива
П ускай у вас есть такой код
- 1. Используйте тип size_t для индексирования. Он обезопасит вас от отрицательных значений и его всегда хватит для массива любого размера.
- 2. Помните, что массив начинается с нуля.
- 3. Последний элемент массива имеет индекс (размер массива - 1)
Примеры
Т еперь несколько типичных примеров работы с массивами
1. Переворачиваем массив.
Здесь незнакомая для вас конструкция
макрос. Во всём коде препроцессор автоматически заменит все вхождения SIZE на 10u.
2. Удаление элемента, выбранного пользователем.
Удаление элемента в данном случае, конечно, не происходит. Массив остаётся того же размера, что и раньше. Мы просто затираем удаляемый элемент следующим за ним и выводим SIZE-1 элементов.
3. Пользователь вводит значения в массив. После этого вывести все разные значения, которые он ввёл.
Пусть пользователь вводит конечное число элементов, допустим 10. Тогда заранее известно, что всего различных значений будет не более 10. Каждый раз, когда пользователь вводит число будем проходить по массиву и проверять, было ли такое число введено.
4. Пользователь вводит число - количество измерений (от 2 до 10). После этого вводит все измерения. Программа выдаёт среднее значение, дисперсию, погрешность.
5. Сортировка массива пузырьком
6. Перемешаем массив. Воспользуемся для этого алгоритмом Fisher-Yates:
Для i от N-1 до 1 выбираем случайное число j в пределах от 0 до i и меняем местами i-й и j-й элементы.
Всё ещё не понятно? – пиши вопросы на ящик
Читайте также: