Массивы
Часто возникает необходимость хранить не одну переменную, а набор однотипных переменных. Например, список учащихся класса – это набор данных строкового типа, координаты вершин многоугольника или коэффициенты многочлена – это набор числовых данных. Для хранения наборов данных используются структуры данных. Основная структура данных – это массив.
— это структура однотипных данных, занимающих непрерывную область памяти. Массив имеет размер — количество элементов в нем. Каждый элемент массива имеет свой номер (также называемый ), обращение к элементу массива осуществляется путем указания его индекса. В языке C++ элементы нумеруются начиная с 0, поэтому последний элемент массива имеет номер на 1 меньше размера массива.
Массив в языке C задается следующим образом:
тип_элементов идентификатор[размер];
где тип_элементов — произвольный тип данных языка C++, который будут иметь элементы массива, например, int , double и т.д.; идентификатор — имя массива, размер — число элементов в нем.
По стандарту языков C и C++, размер массива должен быть константой, определенной на момент компиляции программы, то есть можно определить массив в виде int A[10 + 5] , но нельзя это сделать в виде int A[n] . Однако, компилятор gcc, которым мы пользуемся, допускает объявления второго вида, но при этом нет никаких гарантий, что ваша программа будет откомпилирована каким-либо другим компилятором.
К элементу массива можно обращаться, как идентификатор [ индекс ] . Например, если было сделано объявление
double A[5];
то таким образом создается 5 элементов массива типа double : A[0] , A[1] , A[2] , A[3] , A[4] .
Пример программы, которая создает массив типа int[] , заданного пользователем размера, считывает с клавиатуры его элементы, затем прибавляет к каждому элементу массива число 1 , затем выводит результат на экран:
#include using namespace std; int main() < int n; // Размер массива int i; // Счетчик в циклах cin >> n; // Считываем размер массива int A[n]; // Объявление массива // Считываем массив for (i = 0; i < n; ++i) < cin >> A[i]; > // Прибавляем по 1 к каждому элементу for (i = 0; i < n; ++i) < A[i] += 1; >// Выводим массив на экран for (i = 0; i < n; ++i) < cout // Переведем курсор на новую строку cout
В этом примере при помощи // обозначается начало комментария, весь текст после начала комментария и до конца строки компилятором игнорируется. Второй способ объявления комментария: в начале комментария поставить знаки /* , а в конце – */ . Это позволяет делать комментарии, занимающие несколько строк. В языке C допустимы только такие комментарии.
Контейнер vector в языке C++
В языке C++ появился более удобный, по сравнению с классическим массивом в языке C, контейнер vector. Он является аналогом обычных массивов, но поддерживает дополнительные возможности, например, его размер можно изменять по ходу программы.
Для использования контейнера vector необходимо в начале программы подключить заголовочный файл vector :
#include
Вектор A данных типа int объявляется так:
vector A;
В данном случае будет создан вектор нулевого размера. При необходимости создать вектор нужного размера можно задать размер вектора в качестве параметра конструктора:
vector A(n);
В любой момент можно изменить размер вектора при помощи вызова метода resize . Текущий размер вектора можно узнать про помощи метода size .
Обращение к элементам вектора осуществляется так же, как к элементам массива, при помощи квадратных скобок.
Как обращаться к отдельному элементу массива
До сих пор мы рассматривали примеры работы с небольшим количеством данных, для работы с которыми достаточно использовать только простые переменные. Если данных много, то использование одних простых переменных становится явно недостаточным. Гораздо удобнее объединять их в более сложную организацию данных, например, в массивы.
Массив — это совокупность данных одного типа, имеющая одно общее имя. Доступ к отдельному элементу массива осуществляется путем указания имени массива и номера (индекса) этого элемента. До использования массива его необходимо определить, т.е. дать ему имя и указать количество и тип элементов. Индексы в любом массиве на языке C/C++ всегда начинается с 0 .
Пусть имеется массив из 5 действительных чисел. Графически этот массив можно изобразить так, как показано на рисунке ниже:
Для того, чтобы начать работать с массивом, необходимо дать его описание. Формальная запись описания массива такова:
Тип_элементов_массива Имя_массива [ Количество_элементов ];
Тип_элементов_массива — любой стандартный или ранее определённый пользователем тип данных;
Имя_массива — обычный идентификатор;
Количество_элементов — целое число, большее 0 , возможно, именованная константа.
Для нашего массива x описание будет выглядеть так:
После этого можно начинать работать с элементами массива, например, присвоить второму элементу новое значение:
или напечатать сумму значений первых двух элементов массива:
Как нетрудно убедиться, элементы массива могут использоваться точно так же, как и простые переменные. Единственное отличие — требуется указывать индексы элементов.
Индекс (номер) элемента массива — это константа, переменная или более сложное выражение целого типа. Можно было бы написать:
x[i*3-2] = x[i+1] + x[i%5] — x[3];
главное, чтобы индексы (или в более сложном случае — индексные выражения) находились в допустимых пределах. Индексы элементов нашего массива x должны лежать в пределах от 0 до 4 , т.е. максимально допустимый индекс на единицу меньше количества элементов массива .
А что произойдёт, если обратиться к элементу с индексом, значение которого выходит за допустимый диапазон? Для нашего примера, запишем так:
Внешних проявлений (например, сообщений об ошибке), как правило, не будет, просто программа обратится к «чужому» участку памяти и «испортит» значение какой-либо переменной.
Выход за допустимые пределы индексов массива — это характерная ошибка в программах на языках С/С++ . К сожалению, компилятор тут не помощник — он ни как не контролирует выход за допустимые пределы. Поэтому программисту самому необходимо проявлять повышенную внимательность и аккуратность в работе с массивами. При работе с программой, в которой используются массивы, всегда задавайте себе вопрос: «Не выходит ли где-то индекс массива за допустимые пределы?».
Вернёмся снова к описанию массива. Хороша ли запись
Ответ один — нет, плоха. Почему? Да потому, что при работе с массивами мы постоянно используем просмотр массива, т.е. нам для нашего массива из 5 чисел придётся использовать циклы вида
А что делать, если количество чисел изменится? Просматривать текст всей программы и «править» все циклы? Глупо как-то, да и ошибиться легко. Нужен какой-то выход, и он есть: количество элементов массива нужно задавать не константой (числом), а именованной константой. Тогда количество элементов массива потребуется изменить только в одном месте, а остальной текст программы останется прежним.
На языке С был только один способ создания константы с именем: с помощью директивы define . Схема программы будет выглядеть так:
double x[n]; // описание массива
int i; // переменная цикла
Одна проблема решена, но есть и другая, также весьма неприятная. Что произойдёт, если в директиве define пользователь задаст неверное по смыслу значение для константы, например, другого типа:
или наберёт просто какой-то абсурд:
В этом случае препроцессор «честно» выполнит подстановки, и после компиляции (а в ряде случаев — в ходе выполнения исполняемого модуля) в программе появится сообщение об ошибке, но ссылка будет не на строку, где допущена ошибка (директива define ), а гораздо дальше — там где она используется, — возможно через десятки или сотни строк. Если для приведённой выше схемы написать
то ошибка будет указана в строке
которая совсем не причём.
Для радикального решения проблемы на языке С++ появился более надёжный способ создания константы с именем: с помощью константной переменной . Схема программы будет выглядеть так:
double x[n]; // описание массива
int i; // переменная цикла
Достоинство такого подхода в том, что теперь компилятор проверяет правильность оператора, в котором мы задаём размер массива:
Если в этом операторе переменной n будет задано что-то неприемлемое:
const int n = ЮЮЮ
то сообщение об ошибке будет дано именно для этого оператора, а не где-то ниже по тексту.
Для закрепления материала рассмотрим задачу.
Пример . Дан массив действительных чисел из n элементов. Найти максимальный по модулю элемент и разделить все элементы массива на полученное значение. Вывести на экран монитора массив после обработки.
Возможный текст программы:
using namespace std;
// Задаём массив из n действительных чисел
// Поиск максимального по модулю элемента массива
// Предположим, что x[0] — это и есть максимальный
// по модулю элемент массива:
// А теперь пробуем себя опровергнуть:
// Делим все элементы на max
Инициализация массивов
Элементы массива можно проинициализировать, т.е. задать им начальные значения на этапе выделения памяти под массив. Делается это почти так же, как для простых переменных. Зададим начальные значения элементов массива в нашем примере (смотри рисунок в начале этой темы):
Если при инициализации задано меньше данных, чем выделяется памяти (у нас — для пяти чисел), то значение элементов массива, которые не получили значение в момент выделения памяти, будет неопределённым.
Можно пойти и дальше: не задавать при инициализации массива его размер. Пусть компилятор сам определяет, сколько байт необходимо выделить под рассматриваемый массив:
Но как обрабатывать теперь массив? Нам же надо знать количество элементов! Поделим размер массива на размер одного элемента — это и будет искомым значением:
int n = sizeof(x) / sizeof(double);
Здесь sizeof() — это стандартная операция по вычислению размера какого-либо объекта.
Теперь можно применять привычный подход при обработке массива:
Как обратиться к символу элемента массива?
Если тип данных может быть не только строкой, а числом:
let arr = ['424121321', '24121321','2321','524121321','624121321','724121321','5332']; for(let i=0; i
Отслеживать
ответ дан 10 июн 2020 в 12:29
8,049 5 5 золотых знаков 33 33 серебряных знака 52 52 бронзовых знака
- javascript
- массивы
-
Важное на Мете
Похожие
Подписаться на ленту
Лента вопроса
Для подписки на ленту скопируйте и вставьте эту ссылку в вашу программу для чтения RSS.
Дизайн сайта / логотип © 2024 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2024.1.8.3130
Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.
Методы доступа к элементам массивов
В языке СИ между указателями и массивами существует тесная связь. Например, когда объявляется массив в виде int array[25], то этим определяется не только выделение памяти для двадцати пяти элементов массива, но и для указателя с именем array, значение которого равно адресу первого по счету (нулевого) элемента массива, т.е. сам массив остается безымянным, а доступ к элементам массива осуществляется через указатель с именем array. С точки зрения синтаксиса языка указатель arrey является константой, значение которой можно использовать в выражениях, но изменить это значение нельзя.
Поскольку имя массива является указателем допустимо, например, такое присваивание:
int arrey[25]; int *ptr; ptr=array;
Здесь указатель ptr устанавливается на адрес первого элемента масcива, причем присваивание ptr=arrey можно записать в эквивалентной форме ptr=&arrey[0].
Для доступа к элементам массива существует два различных способа. Первый способ связан с использованием обычных индексных выражений в квадратных скобках, например, array[16]=3 или array[i+2]=7. При таком способе доступа записываются два выражения, причем второе выражение заключается в квадратные скобки. Одно из этих выражений должно быть указателем, а второе — выражением целого типа. Последовательность записи этих выражений может быть любой, но в квадратных скобках записывается выражение следующее вторым. Поэтому записи array[16] и 16[array] будут эквивалентными и обозначают элемент массива с номером шестнадцать. Указатель используемый в индексном выражении не обязательно должен быть константой, указывающей на какой-либо массив, это может быть и переменная. В частности после выполнения присваивания ptr=array доступ к шестнадцатому элементу массива можно получить с помощью указателя ptr в форме ptr[16] или 16[ptr].
Второй способ доступа к элементам массива связан с использованием адресных выражений и операции разадресации в форме *(array+16)=3 или *(array+i+2)=7. При таком способе доступа адресное выражение равное адресу шестнадцатого элемента массива тоже может быть записано разными способами *(array+16) или *(16+array).
При реализации на компьютере первый способ приводится ко второму, т.е. индексное выражение преобразуется к адресному. Для приведенных примеров array[16] и 16[array] преобразуются в *(array+16).
Для доступа к начальному элементу массива (т.е. к элементу с нулевым индексом) можно использовать просто значение указателя array или ptr. Любое из присваиваний
*array = 2; array[0] = 2; *(array+0) = 2; *ptr = 2; ptr[0] = 2; *(ptr+0) = 2;
присваивает начальному элементу массива значение 2, но быстрее всего выполнятся присваивания *array=2 и *ptr=2, так как в них не требуется выполнять операции сложения.
1.7.2. Указатели на многомерные массивы
Указатели на многомерные массивы в языке СИ — это массивы массивов, т.е. такие массивы, элементами которых являются массивы. При объявлении таких массивов в памяти компьютера создается несколько различных объектов. Например при выполнении объявления двумерного массива int arr2[4][3] в памяти выделяется участок для хранения значения переменной arr, которая является указателем на массив из четырех указателей. Для этого массива из четырех указателей тоже выделяется память. Каждый из этих четырех указателей содержит адрес массива из трех элементов типа int, и, следовательно, в памяти компьютера выделяется четыре участка для хранения четырех массивов чисел типа int, каждый из которых состоит из трех элементов. Такое выделение памяти показано на схеме на рис.3.