Как ввести двумерный массив с клавиатуры в c
Обновлено: 07.07.2024
Элементы массива могут быть любого типа данных, даже массива!
Многомерные массивы
Массив массивов называется многомерным массивом:
int array [ 2 ] [ 4 ] ; // 2-элементный массив из 4-элементных массивовПоскольку у нас есть 2 индекса, то это двумерный массив.
В двумерном массиве первый (левый) индекс принято читать как количество строк, а второй (правый) как количество столбцов. Массив выше можно представить следующим образом:
[0][0] [0][1] [0][2] [0][3] // строка №0
[1][0] [1][1] [1][2] [1][3] // строка №1
Чтобы получить доступ к элементам двумерного массива, просто используйте два индекса:
Инициализация двумерных массивов
Для инициализации двумерного массива проще всего использовать вложенные фигурные скобки, где каждый набор значений соответствует определенной строке:
Хотя некоторые компиляторы могут позволить вам упустить внутренние фигурные скобки, все же рекомендуется указывать их в любом случае: улучшается читабельность и уменьшается вероятность получения незапланированных нулевых элементов массива из-за того, что C++ заменяет отсутствующие инициализаторы значением 0 :
В двумерном массиве со списком инициализаторов можно не указывать только левый индекс (длину массива):
Компилятор может сам вычислить количество строк в массиве. Однако не указывать два индекса — это уже ошибка:
Подобно обычным массивам, многомерные массивы можно инициализировать значением 0 следующим образом:
Обратите внимание, это работает только в том случае, если вы явно объявляете длину массива (указываете левый индекс)! В противном случае, вы получите двумерный массив с 1 строкой.
Доступ к элементам в двумерном массиве
Для доступа ко всем элементам двумерного массива требуется два цикла: один для строк и один для столбцов. Поскольку доступ к двумерным массивам обычно выполняется по строкам, то левый индекс используется в качестве внешнего цикла:
for ( int row = 0 ; row < numRows ; ++ row ) // доступ по строкам for ( int col = 0 ; col < numCols ; ++ col ) // доступ к каждому элементу в строкеМногомерные массивы более двух измерений
Многомерные массивы могут быть более двух измерений. Например, объявление трехмерного массива:
Трехмерные массивы трудно инициализировать любым интуитивным способом с использованием списка инициализаторов, поэтому лучше инициализировать весь массив значением 0 и явно присваивать элементам значения с помощью вложенных циклов.
Доступ к элементам трехмерного массива осуществляется так же, как и к элементам двумерного массива:
Пример двумерного массива
Рассмотрим пример использования двумерного массива:
Эта программа вычисляет и выводит таблицу умножения от 1 до 9 (включительно). Обратите внимание, при выводе таблицы в цикле for мы начинаем с 1 вместо 0. Это делается с целью предотвращения вывода нулевой строки и нулевого столбца, содержащих одни нули!
Результат выполнения программы:
1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81
Двумерные массивы обычно используются в играх типа tile-based, где каждый элемент массива представляет собой один фрагмент/плитку. Они также используются в компьютерной 3D-графике (в виде матриц) для вращения, масштабирования и отражения фигур.
В первой статье были описаны приёмы работы с простейшим видом массивов — одномерным (линейным) массивом. В этой, второй статье будут рассмотрены многомерные массивы. В основном, речь пойдёт о двумерных массивах. Но приведённые примеры легко экстраполируются на массивы любой размерности. Также как и в первой статье, будут рассматриваться только массивы в стиле C/C++, без использования возможностей STL.
Эта статья предполагает у читателя базовые знания об одномерных и многомерных массивах, указателях и адресной арифметике. Почерпнуть эти знания можно в любом учебнике по C/C++.
Классика жанра
Если мы откроем классический труд «Язык программирования C» Брайана Кернигана и Денниса Ритчи, то прочитаем, что «В языке C есть возможность работать с многомерными прямоугольными массивами, хотя на практике они используются гораздо реже, чем массивы указателей». C++ практически полностью унаследовал работу с многомерными массивами своего предтечи.
Определение автоматических многомерных массивов
В этом разделе я буду иногда употреблять термин «матрица» как синоним термина «двумерный массив». В C/C++ прямоугольный двумерный массив чисел действительно реализует математическое понятие «матрица». Однако, в общем случае, двумерный массив — понятие гораздо более широкое, чем матрица, поскольку он может быть и не прямоугольным, и не числовым.
Определение автоматических многомерных массивов почти полностью совпадает с определением одномерных массивов (о чём было рассказано в первой статье), за исключением того, что вместо одного размера может быть указано несколько:
В этом примере определяется двумерный массив из 3 строк по 5 значений типа int в каждой строке. Итого 15 значений типа int .
Во втором примере определяется трёхмерный массив, содержащий 3 матрицы, каждая из которых состоит из 5 строк по 2 значения типа int в каждой строке.
Понятно, что тип данных, содержащихся в многомерном массиве, может быть любым.
При дальнейшем изложении для таких многомерных массивов будет употребляться термин «C-массив», что бы отличать их от массивов других видов.
Инициализация
При статической (определяемой на этапе компиляции) инициализации значения C-массива перечисляются в порядке указания размеров (индексов) в определении массива. Каждый уровень (индекс), кроме самого младшего, многомерного массива заключается в свою пару фигурных скобок. Значения самого младшего индекса указываются через запятую:
В примере показана статическая инициализация прямоугольного массива. Весь список инициализирующих значений заключён в фигурные скобки. Значения для каждой из 3 строк заключены в свою пару из фигурных скобок, значения для каждого из 5 столбцов для каждой строки перечислены через запятую.
При наличии инициализатора, самый левый размер массива может быть опущен. В этом случае компилятор сам определит этот размер, исходя из списка инициализации.
Заполнение массива значениями
Многомерный массив заполняется значениями с помощью вложенных циклов. Причём, как правило, количество циклов совпадает с размерностью массива:
В этом примере каждому элементу массива присваивается значение, первая цифра которого указывает номер строки, а вторая цифра — номер столбца для этого значения (нумерация с 1).
Вывод значений массива на консоль
В продолжение предыдущего примера можно написать:
В результате получим следующий вывод на консоль:
Для трёхмерного массива можно написать код, использующий те же приёмы:
Здесь присваивание значения элементу массива и вывод на консоль происходят в одной группе циклов.
Расположение в памяти
Для многомерного C-массива выделяется единый блок памяти необходимого размера: размер_массива1 * размер_массива2 * . * размер_массиваN * sizeof(тип_элемента_массива) .
Значения располагаются последовательно. Самый левый индекс изменяется медленнее всего. Т.е. для трёхмерного массива сначала располагаются значения для первой (индекс 0) матрицы, затем для второй и т.д. Значения для матриц располагаются построчно (ср. со статической инициализацией массива выше).
Имя (идентификатор) многомерного C-массива является указателем на первый элемент массива (так же как и для одномерных массивов)
Если код из последнего примера немного изменить:
поставить точку останова на return и посмотреть под отладчиком память, отведённую под переменную ary , то будет видно, что значения, расположенные в памяти, последовательно возрастают:
Поскольку все значения многомерного C-массива располагаются последовательно, то, пользуясь адресной арифметикой, можно сделать следующий хак:
В последнем фрагменте осуществляется доступ к значениям двумерного массива как к одномерному массиву. Цивилизованное решение реализуется через union .
Из двух примеров, приведённых выше, следует, что работу с двумерным или многомерным массивом (в понимании на более высоком уровне абстракции) технически можно организовать посредством одномерного массива соответствующего размера:
Этот приём достаточно распространён. Его выгода в том, что массив ary[DIM1 * DIM2] не обязательно должен быть выделен автоматически. Его можно выделять и динамически. Но при этом логически рассматривать как C-массив.
Вышеприведённый код написан в духе чистого C. В C++ обычно такие вещи прячут в класс, оставляя снаружи лаконичный интерфейс без всяких следов адресной арифметики.
Неродные близнецы
Теперь рассмотрим работу с «динамическими» многомерными массивами, т.е. с массивами, память для которых выделяется динамически.
Создание и уничтожение динамических многомерных массивов
Как правило, работа с такими массивами осуществляется следующим образом:
(1) Для доступа к двумерному массиву объявляется переменная ary типа указатель на указатель на тип (в данном случае это указатель на указатель на int ).
(2) Переменная инициализируется оператором new , который выделяет память для массива указателей на int .
(3) В цикле каждый элемент массива указателей инициализируется оператором new , который выделяет память для массива типа int .
Освобождение памяти происходит строго в обратном порядке: сначала уничтожаются массивы значений типа int , а затем уничтожается массив указателей.
Работа с динамическим многомерным массивом синтаксически полностью совпадает с работой с многомерным C-массивом.
Пример кода для трёхмерного массива:
Где собака порылась
Работа с динамическим многомерным массивом синтаксически полностью совпадает с работой с многомерным C-массивом. (Цитирую предыдущий раздел.) Синтаксически — да, но между этими массивами есть глубокое различие, о котором начинающие программисты часто забывают.
Во-первых, для динамического массива выделяется другой объём памяти.
Если посчитать, сколько памяти будет выделяться для двумерного массива из примера выше, то получится: первый оператор new выделил память для 3 указателей, второй оператор new в цикле трижды выделил память для 5 элементов типа int . Т.е. получилось, что выделили памяти для 15 значений типа int и для 3 значений типа указатель на int . Для C-массива компилятором была выделена память только для 15 значений типа int . (Всяческие выравнивания и прочие оптимизации не учитываем!)
Во-вторых, память, выделенная для динамического массива, не непрерывна. Следовательно, хак №1 (обращение с двумерным массивом как с одномерным) работать не будет.
В-третьих, передача многомерных массивов в функции и работа с ними будет отличаться для динамических массивов и C-массивов.
Динамический многомерный массив реализуется как массив указателей на массивы, значения в которых, в свою очередь, тоже могут быть указателями на массивы. Последним звеном в этой цепочке всегда будут массивы со значениями целевого типа.
Динамический многомерный массив НЕ является C-массивом.
Парадоксально, но факт, что наиболее близким родственничком для этих неродных близнецов, является хак №2, реализующий работу с многомерным массивом посредством одномерного массива (см. раздел Хаки). Все три вышеперечисленных различия для него неактуальны.
Стоит отметить, что массив указателей на массивы — структура более гибкая, чем двумерный C-массив. Например, для массива указателей на массивы размеры массивов могут быть разными, или какой-то массив может вообще отсутствовать. Наиболее распространённым примером является «массив строк», т.е. массив указателей на массивы типа char (пример — см. в следующем разделе).
Ещё раз о предосторожности
Из вышеизложенного следует, что нужно чётко отличать многомерные C-массивы вида
от массивов указателей на массивы.
Иногда внешние отличия весьма незначительны. К примеру С-строка — это одномерный массив элементов типа char , заканчивающийся нулевым байтом. Как реализовать массив строк?
Это — пример определения и инициализации двумерного C-массива
Каждая С-строка занимает ровно 10 байт, включая завершающий ноль (считаем, тип char имеет размер 1 байт). Неиспользуемые байты у коротких строк, вроде «May», содержат «мусор» (или нули, если об этом позаботился компилятор). Весь массив занимает один непрерывный блок памяти размером 120 байт (12 строк по 10 символов).
А здесь определён и инициализирован одномерный (!) массив указателей на массивы элементов типа char .
Вся информация, доступная через переменную month , занимает 13 блоков памяти: массив из 12 указателей и 12 блоков памяти, адреса которых хранятся в указателях, содержащих С-строки с названиями месяцев. И нет никакой гарантии, что 12 блоков памяти с С-строками будут расположены в памяти последовательно и в порядке, соответствующем перечислению в инициализаторе.
Но в обоих случаях доступ к символу b в строке «February» будет осуществляться выражением month[1][2] .
И, в заключение, ещё одно предостережение.
Поскольку многомерные C-массивы, как правило, занимают большой объём памяти, их надо с особой осторожностью объявлять внутри функций, в том числе в main() . И с осторожностью в n-ной степени в рекурсивных функциях. Можно легко получить переполнение стека и, как следствие, аварийное завершение программы.
Многомерные массивы при работе с функциями
Поскольку многомерные C-массивы и многомерные динамические массивы — совершенно разные типы данных, то и при работе с функциями подходы будут разные.
Передача в функцию многомерного C-массива
Функция, получающая C-массив в качестве параметра, может выглядеть следующим образом:
Форма (1) — наиболее распространённая.
Форма (2). При передаче многомерного C-массива в функцию можно не указывать длину самого левого измерения. Компилятору для расчёта доступа к элементам массива эта информация не нужна.
Как всегда в C/C++, параметр передаётся в функцию по значению. Т.е. в функции доступна копия фактического параметра. Поскольку имя C-массива является указателем на его первый элемент (т.е. адресом первого элемента), то в функцию передаётся копия адреса начала массива. Следовательно, внутри функции можно изменять значения элементов массива, т.к. доступ к ним осуществляется через переданный адрес, но нельзя изменить адрес начала массива, переданный в качестве параметра, т.к. это — копия фактического параметра.
Возвратить многомерный C-массив из функции в качестве результата стандартными средствами невозможно.
Передача в функцию многомерного динамического массива
Поскольку многомерный динамический массив реализуется как одномерный массив указателей, то, соответственно, и при работе с функциями применяются те же подходы, что и для одномерного массива, описанные в первой статье, с точностью до типов данных.
Для примера — полный код программы, демонстрирующей работу с двумерным динамическим массивом с использованием функций.
В первой статье я уже писал, что «Выделять память в одной функции, а освобождать в другой — плохая идея, чреватая ошибками». Поэтому рассматривайте этот пример только как демонстрацию работы с функциями и массивами указателей.
Хотя с другой стороны. С другой стороны, очень похожий подход повсеместно используется в классах, когда некий ресурс (в данном случае память) захватывается в одной функции (конструкторе), а освобождается в другой (деструкторе). Но в случае классов, безопасность обеспечивается инкапсуляцией критических данных и поддержанием непротиворечивого состояния экземпляра класса методами класса.
Массив указателей используется в каждой программе, которая может получать входную информацию из командной строки (или при её вызове от операционной системы). Одна из классических форм функции main() имеет вид:
Аргументами функции являются количество строк argc (размер массива указателей) и массив указателей на строки — argv . Т.е. argv — это массив указателей на массивы значений типа char .
Пожалуй это всё, что я хотел рассказать в этой статье. Надеюсь, что кто-то сочтёт её полезной для себя.
В этом руководстве мы узнаем о многомерных массивах в C++. В частности, как их объявить, получить к ним доступ и эффективно использовать в нашей программе. В С++ мы можем создать массив из массива, известный как многомерный массив. Например:
Здесь x – двумерный массив. Он может содержать максимум 12 элементов.
Мы можем представить этот массив, как таблицу с 3 строками, каждая из которых имеет 4 столбца, как показано ниже.
Аналогичным образом работают и трехмерные массивы. Например:
Этот массив x может содержать максимум 24 элемента.
Мы можем узнать общее количество элементов в массиве, просто умножив его размеры:
Инициализация многомерного массива
Как и обычный массив C++, мы можем инициализировать многомерный массив более чем одним способом.
1. Инициализация двумерного массива
Вышеуказанный метод не является предпочтительным. Ниже приведен лучший способ инициализировать этот массив теми же элементами массива:
В этом массиве 2 строки и 3 столбца, поэтому у нас есть две строки элементов по 3 элемента в каждой.
2. Инициализация трехмерного
Это не лучший способ инициализации трехмерного массива. Лучший выбрать этот массив:
Обратите внимание на размеры этого трехмерного массива.
Первое измерение имеет значение 2. Итак, два элемента, составляющие первое измерение:
Второе измерение имеет значение 3. Обратите внимание, что каждый из элементов первого измерения имеет по три элемента:
Наконец, внутри каждого элемента второго измерения есть четыре числа int:
Пример 1: двумерный
В приведенном выше примере мы инициализировали двумерный массив int с именем test, который имеет 3 «строки» и 2 «столбца».
Здесь мы использовали вложенный цикл for для отображения элементов массива:
- внешний цикл от i == 0 до i == 2 обращается к строкам массива;
- внутренний цикл от j == 0 до j == 1 обращается к столбцам массива.
Наконец, мы печатаем элементы массива на каждой итерации.
Пример 2: ввод данных для двумерного массива
Здесь мы использовали вложенный цикл for для получения входных данных из 2-го массива. После того, как все данные введены, мы использовали другой вложенный цикл for для печати элементов массива.
Пример 3: трехмерный
Основная концепция печати элементов трехмерного массива аналогична концепции двухмерного массива.
Однако, поскольку мы манипулируем 3-мя измерениями, мы используем вложенный цикл for с 3 полными циклами вместо двух:
- внешний цикл от i == 0 до i == 1 обращается к первому измерению массива;
- средний цикл от j == 0 до j == 2 обращается ко второму измерению массива;
- самый внутренний цикл от k == 0 до k == 1 обращается к третьему измерению массива.
Как видим, сложность массива экспоненциально возрастает с увеличением размеров.
Ярким примером ссылочного типа данных являются массивы (как объекты!).
Объявление массивов
Для того чтобы воспользоваться массивом в программе, требуется двухэтапная процедура. Во-первых, необходимо объявить переменную, которая может обращаться к массиву. И во-вторых, нужно создать экземпляр массива (объект), используя оператор new.
Важно! Если массив только объявляется, но явно не инициализируется, каждый его элемент будет установлен в значение, принятое по умолчанию для соответствующего типа данных (например, элементы массива типа bool будут устанавливаться в false, а элементы массива типа int — в 0). В примере, если мы удалим строки с инициализацией, будет напечатано пять нулей.
Примечание. Такие же действия с полями экземпляра структуры выполняет конструктор по умолчанию (без параметров).
Доступ к элементам массива
Для обращения к элементам массива используются индексы . Индекс представляет номер элемента в массиве, при этом нумерация начинается с нуля, поэтому индекс первого элемента будет равен 0. А чтобы обратиться к пятому элементу в массиве, нам надо использовать индекс 4, к примеру: myArr[4] .
Инициализация массива
Помимо заполнения массива элемент за элементом (как показано в предыдущем примере), можно также заполнять его с использованием специального синтаксиса инициализации массивов.
Для этого необходимо перечислить включаемые в массив элементы в фигурных скобках < >. Такой синтаксис удобен при создании массива известного размера, когда нужно быстро задать его начальные значения:
1) инициализация массива с использованием ключевого слова new:
int[] m1 = new int[] ;
Обратите внимание, что в случае применения синтаксиса с фигурными скобками размер массива указывать не требуется (как видно на примере создания переменной m1), поскольку этот размер автоматически вычисляется на основе количества элементов внутри фигурных скобок.
Кроме того, применять ключевое слово new не обязательно (как при создании массива m2).
Неявно типизированные массивы
Ключевое слово var позволяет определить переменную так, чтобы лежащий в ее основе тип выводился компилятором. Аналогичным образом можно также определять неявно типизированные локальные массивы. С использованием такого подхода можно определить новую переменную массива без указания типа элементов, содержащихся в массиве.
Определение массива объектов
В большинстве случаев при определении массива тип элемента, содержащегося в массиве, указывается явно.
В результате получается, что в случае определения массива объектов находящиеся внутри него элементы могут представлять собой что угодно.
Если обратимся к определению массива, данному выше: «Массив представляет собой совокупность переменных одного типа с общим для обращения к ним именем», то это выглядит несколько противоречиво. Но тем не менее, все это возможно потому, что каждый элемент является объектом. Приведем пример:
Обратите внимание на четвертый тип цикла foreach (object me in arrByObject). Легко запомнить: Для каждого (for each) объекта с именем me, входящего в (in) массив arrByObject (учите английский!). На печать выводится как сам объект (элемент массива объектов), так и тип этого объекта (метод GetType(), присущий всем объектам класса Object, от которого наследуются все типы).
Свойство Length
Когда запрашивается длина многомерного массива, то возвращается общее число элементов, из которых может состоять массив. Благодаря наличию у массивов свойства Length операции с массивами во многих алгоритмах становятся более простыми, а значит, и более надежными.
Вставим в предыдущем примере перед Console.ReadKey() оператор
Console.WriteLine(arrByObject.Length);
Будет напечатано значение, равное 4 (число объектов в массиве). Чаще всего оно используется для задания числа элементов массива в цикле for<>.
Многомерные массивы
Многомерным называется такой массив, который отличается двумя или более измерениями, причем доступ к каждому элементу такого массива осуществляется с помощью определенной комбинации двух или более индексов. Многомерный массив индексируется двумя и более целыми числами.
Двумерные массивы. Простейшей формой многомерного массива является двумерный массив. Местоположение любого элемента в двумерном массиве обозначается двумя индексами. Такой массив можно представить в виде таблицы, на строки которой указывает первый индекс, а на столбцы — второй. Пример объявления и инициализации двумерного массива показан ниже:
Обратите особое внимание на способ объявления двумерного массива. Схематическое представление массива myArr[,] показано ниже:
Заметим, что в программе используется еще один объект – ran, принадлежащий к классу Random, метод которого (функция Next() ) возвращает целое число в заданном диапазоне (1,15).
Инициализация многомерных массивов
Первое значение в каждом ряду сохраняется на первой позиции в массиве, второе значение — на второй позиции и т.д.
Обратите внимание на то, что блоки инициализаторов разделяются запятыми, а после завершающей эти блоки закрывающей фигурной скобки ставится точка с запятой.
Ниже в качестве примера приведена общая форма инициализации двумерного массива (4 строки, 2 столбца):
Перейдем к рассмотрению примеров решения задач, где применяются массивы и циклы.
Требуется найти сумму и произведение N элементов массива, используя три варианта циклов (for, while, do-while).
Решение. В классе Program объявим статический массив действительных чисел a[1000] и 7 методов (кроме Main()), ввод исходных данных и вычисление сумм и произведений с использованием трех типов циклов.
Тогда наша программа может быть написана так:
Читайте также: