34. Заполнение массива и обход циклом
Новый массив не заполнен: значения нужно задать самим. Сначала покажем, почему нельзя читать массив сразу после объявления. Потом заполним его циклом и запишем начальные значения при объявлении.
Что пригодится из прошлого: массивы, цикл for, область видимости. Если эти темы знакомы, читайте дальше. Если нет — загляните по ссылке, потом возвращайтесь.
Чего делать нельзя: читать незаполненный массив
Вот пример плохого кода — так делать нельзя:
int a[10];
for (int i = 0; i < 10; i++) {
printf("%d\n", a[i]); /* плохо: в a[i] ещё ничего не записано */
}
После int a[10]; для десяти элементов выделена память, но значения в ней оставила предыдущая работа компьютера. Программа напечатает что-то непредсказуемое: иногда нули, иногда странные числа. Нельзя считать, что «будут нули». Правило такое же, как для обычных локальных переменных из урока про область видимости: сначала присвой значение, потом читай.
Заполняем массив циклом
Нужно записать в каждый элемент число 5. Полная программа:
#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.
Индекс можно использовать и в вычислениях, а не только как номер места. Заполним массив квадратами индексов:
#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 │
└────┴────┴────┴────┴────┴────┘
└─ записали сами ──┘ └─ нули ─┘
Проверим на программе:
#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
Значений в фигурных скобках не может быть больше, чем элементов в массиве: компилятор сообщит об ошибке или предупреждении. А если задан хотя бы один элемент, незаданные принимают нуль. Без фигурных скобок, как в первой строке таблицы, значений нет вовсе.
Первый и последний элемент
Теперь напечатаем первый и последний элементы массива из пяти:
#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}обнуляет весь массив.
