bulgakov

34. Заполнение массива и обход циклом

Новый массив не заполнен: значения нужно задать самим. Сначала покажем, почему нельзя читать массив сразу после объявления. Потом заполним его циклом и запишем начальные значения при объявлении.

Что пригодится из прошлого: массивы, цикл for, область видимости. Если эти темы знакомы, читайте дальше. Если нет — загляните по ссылке, потом возвращайтесь.

Чего делать нельзя: читать незаполненный массив

Вот пример плохого кода — так делать нельзя:

C
int a[10];
for (int i = 0; i < 10; i++) {
    printf("%d\n", a[i]);   /* плохо: в a[i] ещё ничего не записано */
}

После int a[10]; для десяти элементов выделена память, но значения в ней оставила предыдущая работа компьютера. Программа напечатает что-то непредсказуемое: иногда нули, иногда странные числа. Нельзя считать, что «будут нули». Правило такое же, как для обычных локальных переменных из урока про область видимости: сначала присвой значение, потом читай.

Заполняем массив циклом

Нужно записать в каждый элемент число 5. Полная программа:

C
#include <stdio.h>

int main(void)
{
    int a[10];

    for (int i = 0; i < 10; i++) {
        a[i] = 5;
    }

    for (int i = 0; i < 10; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}

Вывод:

5 5 5 5 5 5 5 5 5 5 

Разберём цикл. Переменная i принимает значения от 0 до 9. Выражение a[i] означает «элемент массива a с номером i». На первом шаге это a[0], на втором a[1], на десятом a[9]. Один и тот же код a[i] = 5; поэтому заполняет весь массив. Второй цикл читает каждый элемент и печатает его.

Условие i < 10 важно: i дойдёт до 9, а до 10 уже нет. Число 10 — это количество элементов, а не последний индекс. Последний индекс — 9.

Индекс можно использовать и в вычислениях, а не только как номер места. Заполним массив квадратами индексов:

C
#include <stdio.h>

int main(void)
{
    int a[6];

    for (int i = 0; i < 6; i++) {
        a[i] = i * i;
    }

    for (int i = 0; i < 6; i++) {
        printf("a[%d] = %d\n", i, a[i]);
    }
    return 0;
}

Вывод:

a[0] = 0
a[1] = 1
a[2] = 4
a[3] = 9
a[4] = 16
a[5] = 25

Шаги: i = 0 → 0 · 0 = 0; i = 1 → 1; i = 2 → 4; i = 3 → 9; i = 4 → 16; i = 5 → 25.

Цикл по шагам. Знак ▼ показывает, на какую коробочку смотрит a[i], знак ? — ещё не заполненную:

i = 0
        ▼
      ┌───┬───┬───┬───┬───┬───┐
a:    │ 0 │ ? │ ? │ ? │ ? │ ? │
      └───┴───┴───┴───┴───┴───┘

i = 1
            ▼
      ┌───┬───┬───┬───┬───┬───┐
a:    │ 0 │ 1 │ ? │ ? │ ? │ ? │
      └───┴───┴───┴───┴───┴───┘

i = 2
                ▼
      ┌───┬───┬───┬───┬───┬───┐
a:    │ 0 │ 1 │ 4 │ ? │ ? │ ? │
      └───┴───┴───┴───┴───┴───┘

... и так до i = 5

Начальные значения при объявлении

Значения можно записать сразу при объявлении, в фигурных скобках через запятую. Это называется инициализацией. Есть четыре формы:

Запись Что получится
int arr[50]; 50 элементов; у локального массива значения не заданы (у глобального все нули, как у любой глобальной переменной)
int arr[] = {10, 20, 30, 40}; 4 элемента: размер подсчитает компилятор
int arr[6] = {10, 20, 30, 40, 50, 60}; 6 элементов, все значения заданы
int arr[6] = {10, 20, 30, 40}; 6 элементов: 10 20 30 40 0 0

В последней строке значений меньше, чем элементов. Тогда остальные элементы становятся нулями. Это правило C. Из него следует приём int zeros[4] = {0};: первый элемент равен нулю по записи, остальные по правилу, итого весь массив нулевой.

Для четвёртой формы схема из шести коробочек:

индекс:     0    1    2    3    4    5
          ┌────┬────┬────┬────┬────┬────┐
d:        │ 10 │ 20 │ 30 │ 40 │  0 │  0 │
          └────┴────┴────┴────┴────┴────┘
          └─ записали сами ──┘ └─ нули ─┘

Проверим на программе:

C
#include <stdio.h>

int main(void)
{
    int b[] = {10, 20, 30, 40};
    int c[6] = {10, 20, 30, 40, 50, 60};
    int d[6] = {10, 20, 30, 40};
    int zeros[4] = {0};

    printf("b has %zu elements\n", sizeof(b) / sizeof(b[0]));
    for (int i = 0; i < 6; i++) {
        printf("%d ", c[i]);
    }
    printf("\n");
    for (int i = 0; i < 6; i++) {
        printf("%d ", d[i]);
    }
    printf("\n");
    for (int i = 0; i < 4; i++) {
        printf("%d ", zeros[i]);
    }
    printf("\n");
    return 0;
}

Вывод:

b has 4 elements
10 20 30 40 50 60 
10 20 30 40 0 0 
0 0 0 0 

Значений в фигурных скобках не может быть больше, чем элементов в массиве: компилятор сообщит об ошибке или предупреждении. А если задан хотя бы один элемент, незаданные принимают нуль. Без фигурных скобок, как в первой строке таблицы, значений нет вовсе.

Первый и последний элемент

Теперь напечатаем первый и последний элементы массива из пяти:

C
#include <stdio.h>

int main(void)
{
    int a[5] = {10, 20, 30, 40};
    printf("First elem. is %d\n", a[0]);
    printf("Last elem. is %d\n", a[4]);
    return 0;
}

Вывод:

First elem. is 10
Last elem. is 0

Сюрприз во второй строке: напечатан 0, хотя в списке только четыре значения. Массив состоит из пяти элементов: a[0]=10, a[1]=20, a[2]=30, a[3]=40, и a[4] не задан явно. Поэтому по правилу выше он стал нулём. Последний элемент всегда a[4]: индекс последнего на единицу меньше размера.

Что запомнить

  • Незаполненный массив читать нельзя: значения в нём не определены.
  • Цикл for (int i = 0; i < n; i++) с a[i] обходит все n элементов.
  • Начальные значения пишут в {...}. Недостающие элементы становятся нулями.
  • int a[] = {...} сам считает число элементов; {0} обнуляет весь массив.
ПрактикаЗагружаем тест…