bulgakov

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.

Как объявить массив

Запись состоит из типа элементов, имени и числа элементов в квадратных скобках:

C
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, который знаем по уроку про типы. Полная программа:

C
#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 — типа для размеров.

Как массив лежит в памяти

Элементы стоят в памяти вплотную друг к другу, в порядке индексов. Заполним пять элементов по одному:

C
#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]).
  • Выход за границы не проверяется и даёт неопределённое поведение.
ПрактикаЗагружаем тест…