Как ввести количество элементов массива c

Как показала практика, у начинающих кодеров возникает множество вопросов при решении задач по теме «Массивы». В данной статье затронуты вопросы, относящиеся только к массивам в классическом понимании. Работа с контейнерами STL — это отдельная тема.

Как правило, задачи сводятся к следующему: заполнить массив, произвести некие операции с элементами массива, распечатать результат. Уже в постановке задачи угадываются логические блоки её решения. Далее я постараюсь показать типовые «кирпичики», из которых можно сложить решение задачи — т. е. программу.

Организация массива

Память под массив может выделяться автоматически или динамически.

Автоматическое выделение памяти используют, когда размер массива известен на этапе компиляции (т. е. при написании кода).

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

Оба типа массивов могут быть как глобальными (определёнными вне функций), так и локальными (определёнными внутри функции или блока). Здесь для автоматических массивов существует одна тонкость. Память для локального автоматического массива выделяется в стеке. Поэтому размер такого массива должен быть небольшим. В противном случае можно получить переполнение стека и, как следствие, аварийное завершение программы. Переполнение стека также можно получить и при небольших размерах локального автоматического массива, при многократных рекурсивных вызовах функции. Поэтому, когда вы определяете в функции автоматический массив, вы должны точно знать, что делаете.

Глобальные автоматические массивы в плане переполнения стека безопасны. Но они будут видны во всём коде, лексикографически расположенному после объявления массивов, что может спровоцировать их использование напрямую, минуя их передачу в функции через параметры. Это приведёт к возникновению побочных эффектов работы функций, что затрудняет отладку и делает программы менее надёжными. Такого использования глобальных массивов следует избегать.

Для массивов, использующих динамическое выделение памяти, память распределяется из «кучи» (heap). Куча — это память, выделяемая программе операционной системой, для использования этой программой. Размер кучи, как правило, значительно больше размера стека, а для ОС, поддерживающих парадигму виртуальной памяти, размер кучи теоретически может ограничиваться только разрядностью приложения.

Использование автоматических массивов

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

Размер массива в коде настоятельно рекомендуется указывать с помощью именованной константы. Это полезно по нескольким соображениям:

  1. имя константы должно указывать на область её применения — самодокументирование кода;
  2. при необходимости изменить в коде размер массива потребуется внести правку только в одном месте;
  3. размер массива, как правило, используется в циклах прохода по массиву, проверки границы и пр., поэтому использование символического имени избавит от необходимости тщательной проверки и правки всего кода при изменении размера массива.
Читайте также:  Как включить автоматический перевод страницы в яндексе

Тип константного выражения для определения размера (количество элементов) автоматического массива должен быть целочисленный: char , int , unsigned int , long , etc.

Память, отведённая под автоматические массивы, освобождается при выходе из области видимости переменной-массива. Для локальных массивов это функция или блок. Глобальные массивы уничтожаются при выходе из программы.

Пример определения глобального автоматического массива длиной 10 элементов типа int :

Пример определения локального автоматического массива длиной 10 элементов типа int :

Использование массивов с динамическим выделением памяти

Массивы с динамическим выделением памяти используют, когда размер массива не известен на этапе компиляции. Реальный размер массива может вычисляться в программе или вводиться пользователем — неважно.

Память для массива выделяется оператором new в форме new тип[количество_элементов] .

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

Когда работа с массивом закончена, память, выделенную под массив необходимо освободить. Это делается с помощью оператора delete в форме delete [] имя_переменной . После того, как память освобождена, работать с массивом нельзя.

Пример использования массива с динамическим выделением памяти:

Заполнение массива значениями

При решении учебных задач, обычно предлагается заполнить массив значениями либо введёнными с клавиатуры, либо случайными значениями из определённого диапазона. Начнём со второго случая, как более простого (Парадокс? Нет, правда жизни).

Заполнение массива случайными числами

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

Однако без дополнительных телодвижений стандартная функция rand() будет при каждом запуске программы генерировать одинаковую последовательность случайных чисел (кстати, это очень удобно при отладке!). Для того, что бы при каждом запуске программы получать уникальную последовательность случайных чисел, функцию rand() надо «разогнать» начальным случайным значением. Это делается с помощью функций srand() и time() .

Заполнение массива значениями, естественно, делаем в цикле. Помним, что элементы массива в C/C++ нумеруются с 0. Следовательно последний элемент массива имеет индекс на единицу меньший, чем размер массива.

В примере показано заполнение глобального автоматического массива из 10 элементов типа int случайными значения из диапазона от −100 до 100 включительно:

Обратите внимание на включение заголовочных файлов!

Заполнение массива числами, введёнными пользователем

Как ни странно, это более сложный случай. Дело в том, что во-первых, наличие человека всегда может приводить к некорректному вводу данных (ошибкам), во-вторых, для человека необходимо обеспечить какой-никакой интерфейс, а в-третьих, система потокового ввода-вывода STL имеет свои неприятные особенности.

Итак, пользуясь предыдущим примером, попробуем написать фрагмент, отвечающий за ввод значений массива с клавиатуры. Добавим в начало кода заголовочный файл #include , а вместо инициализации массива случайными значениями напишем что-то типа:

Читайте также:  Запись биос на флешку

Оно как бы работает, но если вы попытаетесь в качестве числа (конечно случайно!) ввести 1111111111111111111111111111111111 или 11q, то, в зависимости от компилятора, сможете наблюдать некоторые интересные эффекты работы вашей программы.

Поэтому приходится писать более сложный код:

Подробный разбор данного фрагмента выходит за рамки данной статьи. Но интересующиеся могут его разобрать, вооружившись, например, известной книгой Г. Шилдта.

Вывод на консоль значений из массива

Вывод значений массива на консоль реализуется элементарно. В свете уже вышесказанного даже нечего добавить:

Работа со значениями из массива

Всё, о чём было написано выше, это были как бы вспомогательные элементы программы. Далее разберём несколько примеров обработки массивов.

Поиск максимального/максимального значения в массиве

Ниже приведён полный код программы поиска минимального значения в массиве и его индекса. В программе используется глобальный автоматический массив. Значения массива получаются посредством генератора случайных чисел.

Данный код может быть оптимизирован, но я не стал этого делать, дабы были лучше видны те самые «кирпичики», из которых он собран.

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

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

Понятно, что поиск максимального значения производится полностью аналогично, с точностью до знаков «больше»/«меньше», вывода строки пользователю и наименования переменных.

Поиск определённого значения в массиве

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

Задачи на поиск в массиве могут быть в двух формах:

  1. найти первое (последнее) вхождение искомого значения
  2. найти все вхождения

Поиск первого вхождения:

Поиск последнего вхождения:

Обратите внимание на следующие моменты.

Переменная цикла i описана перед циклом. Таким образом, эта переменная продолжает существовать после окончания цикла, и её значение может быть использовано.

Если искомый элемент найден, то цикл завершается досрочно оператором break : просматривать остальную часть массива не имеет смысла — задача уже выполнена.

Во втором случае переменная i имеет знаковый тип int . Отрицательное значение используется в качестве флага, что весь массив просмотрен, и значение не найдено.

Поиск всех вхождений:

Здесь цикл не прерывается. Массив просматривается полностью.

Сумма/произведение отрицательных элементов массива

Сумма элементов массива с чётными/нечётными индексами

Работа с массивами с применением функций

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

Читайте также:  Интернет на компьютере через телефон android

Массив передаётся в функцию как указатель. Причём неважно, какой это массив: автоматический или массив с динамическим выделением памяти. Также обычно в функцию необходимо передать размер массива (количество элементов), поскольку в общем случае, имея только указатель, невозможно определить размер массива. (Есть частные случаи, когда размер определить можно, используя значение-маркер. Например, строки в C‑стиле должны заканчиваться нулевым символом).

Обратите внимание, что выделение памяти под массив и её освобождение происходит в одной функции (в данном случае, в main() ). Выделять память в одной функции, а освобождать в другой — плохая идея, чреватая ошибками.

Заключение

В этой статье рассмотрены только самые элементарные приёмы работы с массивами, которые помогут (надеюсь!) начинающему кодеру понять принципы работы с массивами.

Да пребудет с вами святой Бьярн и апостолы его! 😉

При решении задач с большим количеством данных одинакового типа использование переменных с различными именами, не упорядоченных по адресам памяти, затрудняет программирование. В подобных случаях в языке Си используют объекты, называемые массивами.

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

Массив характеризуется следующими основными понятиями:

Элемент массива (значение элемента массива) – значение, хранящееся в определенной ячейке памяти, расположенной в пределах массива, а также адрес этой ячейки памяти.
Каждый элемент массива характеризуется тремя величинами:

  • адресом элемента — адресом начальной ячейки памяти, в которой расположен этот элемент;
  • индексом элемента (порядковым номером элемента в массиве);
  • значением элемента.

Адрес массива – адрес начального элемента массива.

Имя массива – идентификатор, используемый для обращения к элементам массива.

Размер массива – количество элементов массива

Размер элемента – количество байт, занимаемых одним элементом массива.

Графически расположение массива в памяти компьютера можно представить в виде непрерывной ленты адресов.

Представленный на рисунке массив содержит q элементов с индексами от 0 до q-1 . Каждый элемент занимает в памяти компьютера k байт, причем расположение элементов в памяти последовательное.

Адреса i -го элемента массива имеет значение

n+k·i

Адрес массива представляет собой адрес начального (нулевого) элемента массива. Для обращения к элементам массива используется порядковый номер (индекс) элемента, начальное значение которого равно 0 . Так, если массив содержит q элементов, то индексы элементов массива меняются в пределах от 0 до q-1 .

Длина массива – количество байт, отводимое в памяти для хранения всех элементов массива.

ДлинаМассива = РазмерЭлемента * КоличествоЭлементов

Для определения размера элемента массива может использоваться функция

int a[ N ] для компилятора означает статическое резервирование памяти размером N * sizeof(int)
Это возможно только если N заранее определено и известно компилятору. Если же N – переменная, то любой компилятор обругается. Нужно использовать динамическое (во время выполнения) резервирование памяти.

int *a = new int [ N ];
if (a != NULL) // не забываем проверить успех предыдущей операции
<
// TODO:

Ссылка на основную публикацию
Adblock detector