33. Массивы: элементы, индексы и память
Массив хранит много однотипных значений под одним именем и даёт каждому номер. Раньше на каждое значение заводилась своя переменная. Для десяти оценок это десять имён и десять одинаковых строк кода. Массив заменяет их одной записью и позволяет обработать все значения циклом for.
Что пригодится из прошлого: цикл for, типы и sizeof, область видимости. Если эти темы знакомы, читайте дальше. Если нет — загляните по ссылке, потом возвращайтесь.
Что такое массив
Массив (array) — последовательность элементов одного типа, которые лежат в памяти подряд. Каждый элемент имеет номер — индекс. Нумерация всегда начинается с нуля.
Возьмём семь целых чисел:
| Индекс | 0 |
1 |
2 |
3 |
4 |
5 |
6 |
|---|---|---|---|---|---|---|---|
| Элемент | 20 |
24 |
26 |
31 |
45 |
65 |
34 |
Для такого массива из семи элементов:
a[0]— первый элемент, он равен20;a[1]— второй, он равен24;a[6]— седьмой и последний, он равен34.
Обычная переменная — одна коробочка с именем. Массив — ряд коробочек под одним именем, у каждой свой номер:
обычная переменная: массив из пяти элементов:
┌─────┐ ┌─────┬─────┬─────┬─────┬─────┐
x │ 7 │ a │ 20 │ 24 │ 26 │ 31 │ 45 │
└─────┘ └─────┴─────┴─────┴─────┴─────┘
индекс: 0 1 2 3 4
одно имя, одно значение одно имя, пять коробочек: a[0] … a[4]
Главное правило: у массива из n элементов индексы идут от 0 до n - 1. Индекса n не существует. Числа в квадратных скобках — это номер места, а не значение. Путаница «пятый элемент — это a[5]» — самая частая ошибка новичков: пятый элемент имеет индекс 4.
Как объявить массив
Запись состоит из типа элементов, имени и числа элементов в квадратных скобках:
int a[10]; /* 10 элементов типа int */
short s[5]; /* 5 элементов типа short */
long long_array[51]; /* 51 элемент типа long */
float float_array[6]; /* 6 элементов типа float */
double double_array[9]; /* 9 элементов типа double */
Здесь a — имя переменной, которая представляет весь массив из десяти int. Число элементов пишем целым положительным числом. Все примеры курса задают его обычной константой, например 10, а не переменной из scanf: компилятор должен знать размер заранее. (Формально C позволяет и размер из переменной, но это особая возможность, которая есть не во всех компиляторах. Мы ею не пользуемся.)
После такого объявления элементы ещё не заполнены. Память выделена, но значения в ней случайные. Как задать начальные значения — в следующем уроке.
Сколько места занимает массив
Размер массива в байтах — число элементов, умноженное на размер одного элемента. Проверим оператором sizeof, который знаем по уроку про типы. Полная программа:
#include <stdio.h>
int main(void)
{
int a[10];
short s[5];
long long_array[51];
float float_array[6];
double double_array[9];
printf("Size of a = %zu\n", sizeof(a));
printf("Size of s = %zu\n", sizeof(s));
printf("Size of long_array = %zu\n", sizeof(long_array));
printf("Size of float_array = %zu\n", sizeof(float_array));
printf("Size of double_array = %zu\n", sizeof(double_array));
printf("Elements in a = %zu\n", sizeof(a) / sizeof(a[0]));
return 0;
}
Вывод на обычном 64-разрядном Linux или macOS:
Size of a = 40
Size of s = 10
Size of long_array = 408
Size of float_array = 24
Size of double_array = 72
Elements in a = 10
Проверим числа. В этой среде int занимает 4 байта: 10 × 4 = 40. short — 2 байта: 5 × 2 = 10. long — 8 байтов: 51 × 8 = 408. float — 4 байта: 6 × 4 = 24. double — 8 байтов: 9 × 8 = 72.
Размеры типов зависят от реализации. Например, на Windows long занимает 4 байта, и в строке с long_array вместо 408 получилось бы 204. Поэтому не заучивайте цифры, а считайте через sizeof.
Последняя строка показывает приём, которым пользуются часто: sizeof(a) / sizeof(a[0]) — это размер всего массива, делённый на размер одного элемента. Получается число элементов. Если позже изменить длину массива в объявлении, это выражение подстроится само. Формат %zu нужен потому, что sizeof возвращает значение особого целого типа size_t — типа для размеров.
Как массив лежит в памяти
Элементы стоят в памяти вплотную друг к другу, в порядке индексов. Заполним пять элементов по одному:
#include <stdio.h>
int main(void)
{
int a[5];
a[0] = 5;
a[1] = 7;
a[2] = 89;
a[3] = 8;
a[4] = 21;
for (int i = 0; i < 5; i++) {
printf("a[%d] = %d\n", i, a[i]);
}
return 0;
}
Вывод:
a[0] = 5
a[1] = 7
a[2] = 89
a[3] = 8
a[4] = 21
В памяти это выглядит так:
индекс: 0 1 2 3 4
┌─────┬─────┬─────┬─────┬─────┐
a: │ 5 │ 7 │ 89 │ 8 │ 21 │
└─────┴─────┴─────┴─────┴─────┘
элемент: a[0] a[1] a[2] a[3] a[4]
Те же пять чисел с байтовыми «адресами» внутри массива (для int из 4 байтов):
байтов от начала: 0 4 8 12 16
┌─────┬─────┬─────┬─────┬─────┐
a: │ 5 │ 7 │ 89 │ 8 │ 21 │
└─────┴─────┴─────┴─────┴─────┘
индекс: 0 1 2 3 4
Элемент a[i] лежит на расстоянии i × 4 байтов от начала массива. Поэтому компьютер находит нужный элемент мгновенно: ему не нужно перебирать предыдущие. Каждая ячейка — отдельная переменная типа int. С a[2] работаем как с обычной переменной: читаем, записываем, складываем. Например, a[2] = a[0] + a[1]; запишет 12 на третье место.
Индекс не обязан быть числом из исходника. Это может быть любое целое выражение: a[i], a[i + 1], a[n - 1]. Благодаря этому цикл с переменной i обходит весь массив.
Выход за границы массива
Для int a[5] существуют только a[0]…a[4]. Запись a[5] = 1; пытается записать за пределами массива, в чужую память. C не проверяет границы сам. Программа может молча испортить другие данные, дать неверный результат или аварийно завершиться. В описании языка такое поведение называется неопределённым: предсказать результат нельзя. Следить за границами должен программист.
Поэтому в циклах по массиву из n элементов условие всегда i < n, а не i <= n. Последний индекс — n - 1.
Что запомнить
- Массив — набор однотипных элементов в памяти подряд.
- Индексы начинаются с
0; у массива изnэлементов последний индексn - 1. - Объявление:
тип имя[число_элементов];. - Размер в байтах —
число элементов × sizeof(элемента); число элементов даётsizeof(a) / sizeof(a[0]). - Выход за границы не проверяется и даёт неопределённое поведение.
