2.4. Массивы и вложение операторов цикла
Теория
Зачем нужен этот пункт
До этого в программах использовались отдельные переменные:
a, b, x, sum.
Но часто нужно хранить не одно значение, а целый набор однотипных данных:
оценки студента, температуры за неделю, элементы вектора, строки матрицы,
результаты измерений.
Для хранения набора однотипных значений в языке C используется массив. Массив позволяет обращаться к элементам по индексу, а циклы позволяют удобно обрабатывать эти элементы один за другим.
В этом пункте рассматриваются:
- одномерные массивы;
- индексы и нумерация элементов с нуля;
- ввод и вывод элементов массива;
- типовые задачи обработки массива;
- двумерные массивы;
- вложенные циклы;
- обработка таблиц и матриц;
- инициализация массивов;
- типичные ошибки при работе с индексами.
Что такое массив
Массив — это совокупность элементов одного типа, расположенных под одним именем. Каждый элемент массива имеет свой номер, который называется индексом.
Математически массив похож на вектор или матрицу. Например, набор чисел можно представить как последовательность:
x[0], x[1], x[2], x[3], ..., x[n - 1]
Все элементы одного массива имеют один и тот же тип. Например, если массив
объявлен как массив int, то все его элементы являются целыми
числами. Если массив объявлен как массив double, то все его
элементы являются вещественными числами двойной точности.
int marks[5];
double temperature[7];
В первом случае массив marks содержит 5 элементов типа
int. Во втором случае массив temperature содержит
7 элементов типа double.
Объявление одномерного массива
Общая форма объявления одномерного массива:
тип имя_массива[количество_элементов];
Примеры:
int a[10];
float x[100];
double values[50];
char letters[26];
В записи:
int a[10];
объявляется массив a из 10 элементов типа int.
Элементы этого массива:
a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9]
Важно: если размер массива равен 10, последним допустимым
индексом будет 9, а не 10.
Индексация начинается с нуля
В языке C индексация массивов всегда начинается с нуля.
int a[5];
Допустимые элементы:
a[0]
a[1]
a[2]
a[3]
a[4]
Недопустимый элемент:
a[5] /* ошибка: выход за границы массива */
Общее правило:
Если массив содержитnэлементов, допустимые индексы идут от0доn - 1.
Это правило нужно запомнить сразу, потому что ошибка на единицу — одна из самых частых ошибок при работе с массивами.
Обращение к элементу массива
Элемент массива используется почти как обычная переменная. Ему можно присваивать значение, его можно читать, выводить, использовать в выражениях.
int a[5];
a[0] = 10;
a[1] = 20;
a[2] = a[0] + a[1];
printf("%d\n", a[2]);
В этом примере:
a[0]получает значение10;a[1]получает значение20;a[2]получает суммуa[0] + a[1], то есть30.
Индексом может быть не только число, но и выражение целого типа.
int i = 3;
a[i] = 100;
a[i - 1] = 50;
Массив и цикл
Массивы почти всегда обрабатываются с помощью циклов. Если нужно пройти
по всем элементам массива, обычно используется цикл for.
int a[5];
int i;
for (i = 0; i < 5; i++)
{
a[i] = i + 1;
}
После выполнения цикла массив будет содержать:
a[0] = 1
a[1] = 2
a[2] = 3
a[3] = 4
a[4] = 5
Обрати внимание на условие:
i < 5
Оно правильное, потому что последний допустимый индекс — 4.
Если написать i <= 5, цикл попытается обратиться к
a[5], которого в массиве нет.
Ввод элементов массива
Чтобы ввести элементы массива с клавиатуры, удобно использовать цикл.
#include <stdio.h>
int main(void)
{
int a[5];
int i;
for (i = 0; i < 5; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
return 0;
}
Здесь &a[i] — адрес конкретного элемента массива.
Функция scanf получает этот адрес и записывает введённое
значение в нужный элемент.
Например, на первой итерации i равно 0,
поэтому вводится a[0]. На второй итерации вводится
a[1], и так далее.
Вывод элементов массива
Вывод массива также обычно выполняется циклом.
#include <stdio.h>
int main(void)
{
int a[5] = { 10, 20, 30, 40, 50 };
int i;
for (i = 0; i < 5; i++)
{
printf("a[%d] = %d\n", i, a[i]);
}
return 0;
}
Результат:
a[0] = 10
a[1] = 20
a[2] = 30
a[3] = 40
a[4] = 50
При отладке программ полезно выводить не только значение элемента, но и его индекс. Так проще понять, где именно возникла ошибка.
Размер массива и фактическое количество элементов
Часто массив объявляют с некоторым максимальным размером, а реально
используют только первые n элементов.
float x[100];
int n;
Здесь массив может хранить до 100 элементов, но программа может работать,
например, только с первыми n элементами:
x[0], x[1], ..., x[n - 1]
В такой ситуации нужно обязательно проверить, что n находится
в допустимых границах.
if (n > 0 && n <= 100)
{
/* n допустимо */
}
Без такой проверки пользователь может ввести слишком большое значение, и программа начнёт обращаться за пределы массива.
Пример: ввод n элементов и вычисление суммы
#include <stdio.h>
int main(void)
{
int x[100];
int n;
int i;
int sum = 0;
while (1)
{
printf("Введите количество элементов от 1 до 100: ");
scanf("%d", &n);
if (n > 0 && n <= 100)
{
break;
}
printf("Ошибка: n должно быть в диапазоне от 1 до 100.\n");
}
for (i = 0; i < n; i++)
{
printf("x[%d] = ", i);
scanf("%d", &x[i]);
sum += x[i];
}
printf("Сумма = %d\n", sum);
return 0;
}
В этом примере массив имеет размер 100, но используется
только n первых элементов. Цикл while (1)
нужен для проверки допустимого значения n, а цикл
for — для ввода элементов и накопления суммы.
Пример: среднее значение элементов массива
Среднее значение набора чисел вычисляется как сумма значений, делённая на их количество.
#include <stdio.h>
int main(void)
{
double x[100];
int n;
int i;
double sum = 0.0;
double average;
while (1)
{
printf("Введите n от 1 до 100: ");
scanf("%d", &n);
if (n > 0 && n <= 100)
{
break;
}
printf("Ошибка ввода.\n");
}
for (i = 0; i < n; i++)
{
printf("x[%d] = ", i);
scanf("%lf", &x[i]);
sum += x[i];
}
average = sum / n;
printf("Среднее = %f\n", average);
return 0;
}
Здесь важно, что sum имеет тип double.
Это позволяет выполнять вещественное деление и получать дробный результат.
Пример: среднее и дисперсия
Дисперсия показывает, насколько значения отличаются от среднего. Один из простых вариантов вычисления:
дисперсия = сумма квадратов отклонений от среднего / количество элементов
Программа:
#include <stdio.h>
int main(void)
{
int i;
int n;
double x[100];
double average = 0.0;
double variance = 0.0;
double deviation;
while (1)
{
printf("Введите n от 1 до 100: ");
scanf("%d", &n);
if (n > 0 && n <= 100)
{
break;
}
printf("Ошибка: нужно 0 < n <= 100.\n");
}
printf("Введите значения элементов:\n");
for (i = 0; i < n; i++)
{
printf("x[%d] = ", i);
scanf("%lf", &x[i]);
average += x[i];
}
average /= n;
for (i = 0; i < n; i++)
{
deviation = x[i] - average;
variance += deviation * deviation;
}
variance /= n;
printf("Среднее = %f\n", average);
printf("Дисперсия = %f\n", variance);
return 0;
}
Здесь используется два прохода по массиву:
- первый проход вводит элементы и накапливает сумму;
- после первого прохода вычисляется среднее;
- второй проход вычисляет сумму квадратов отклонений от среднего;
- после второго прохода получается дисперсия.
Нельзя вычислить такую дисперсию в один простой проход без хранения элементов, если затем нужно использовать уже найденное среднее для каждого элемента. Поэтому массив здесь нужен для повторного обращения к введённым данным.
Поиск минимального и максимального элемента
Ещё одна типичная задача — найти минимальный или максимальный элемент массива.
#include <stdio.h>
int main(void)
{
int a[100];
int n;
int i;
int max;
printf("Введите n: ");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
scanf("%d", &a[i]);
}
max = a[0];
for (i = 1; i < n; i++)
{
if (a[i] > max)
{
max = a[i];
}
}
printf("Максимум = %d\n", max);
return 0;
}
Начальное значение max берётся из первого элемента массива.
Это лучше, чем задавать искусственное значение вроде 0,
потому что все элементы массива могут быть отрицательными.
Цикл поиска начинается с i = 1, потому что элемент
a[0] уже использован как начальный максимум.
Поиск элемента по условию
Иногда нужно не вычислить сумму, а найти первый элемент, который удовлетворяет условию.
#include <stdio.h>
int main(void)
{
int a[100];
int n;
int i;
int found = 0;
printf("Введите n: ");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++)
{
if (a[i] == 0)
{
found = 1;
break;
}
}
if (found)
{
printf("Первый нулевой элемент имеет индекс %d\n", i);
}
else
{
printf("Нулевых элементов нет\n");
}
return 0;
}
Оператор break здесь завершает цикл сразу после нахождения
первого подходящего элемента.
Двумерные массивы
Двумерный массив можно представить как таблицу, матрицу или массив строк и столбцов.
Общая форма объявления:
тип имя_массива[количество_строк][количество_столбцов];
Пример:
float z[13][6];
Здесь объявлен двумерный массив z. Первый индекс принимает
значения от 0 до 12, второй индекс — от
0 до 5.
Элементы массива:
z[0][0], z[0][1], z[0][2], ..., z[0][5]
z[1][0], z[1][1], z[1][2], ..., z[1][5]
...
z[12][0], z[12][1], z[12][2], ..., z[12][5]
В языке C двумерный массив фактически является массивом массивов.
Например, z — это массив из 13 элементов, каждый из которых
сам является массивом из 6 элементов типа float.
Обращение к элементам двумерного массива
Для обращения к элементу двумерного массива используются два индекса.
int matrix[3][4];
matrix[0][0] = 10;
matrix[0][1] = 20;
matrix[2][3] = 99;
Первый индекс обычно считают номером строки, второй — номером столбца.
| Запись | Смысл |
|---|---|
matrix[0][0] |
элемент в первой строке и первом столбце |
matrix[0][1] |
элемент в первой строке и втором столбце |
matrix[2][3] |
элемент в третьей строке и четвёртом столбце |
Как и в одномерных массивах, индексы начинаются с нуля.
Вложенные циклы
В теле цикла можно использовать другой цикл. Такие циклы называются вложенными.
Вложенные циклы особенно часто применяются для обработки двумерных массивов: внешний цикл проходит по строкам, внутренний — по столбцам.
int i;
int j;
int matrix[3][4];
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
matrix[i][j] = 0;
}
}
В этом примере:
- внешний цикл с переменной
iперебирает строки; - внутренний цикл с переменной
jперебирает столбцы; - каждый элемент матрицы получает значение
0.
Вывод двумерного массива
Чтобы вывести двумерный массив в виде таблицы, используют вложенные циклы.
#include <stdio.h>
int main(void)
{
int matrix[3][4] = {
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }
};
int i;
int j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
printf("%4d", matrix[i][j]);
}
printf("\n");
}
return 0;
}
Результат:
1 2 3 4
5 6 7 8
9 10 11 12
Спецификация %4d задаёт ширину поля 4 символа, поэтому
элементы выводятся ровными столбцами.
Сумма элементов строки матрицы
Рассмотрим задачу: для каждой строки матрицы найти сумму её элементов.
#include <stdio.h>
int main(void)
{
int a[3][4] = {
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 1, 2, 3 }
};
int i;
int j;
int rowSum;
for (i = 0; i < 3; i++)
{
rowSum = 0;
for (j = 0; j < 4; j++)
{
rowSum += a[i][j];
}
printf("Сумма строки %d = %d\n", i, rowSum);
}
return 0;
}
Переменная rowSum обнуляется перед обработкой каждой строки.
Если забыть это сделать, суммы разных строк начнут накапливаться
друг на друга.
Произведение и сумма элементов строки
Вложенные циклы позволяют выполнять более сложную обработку матрицы.
Например, для каждой строки можно найти сумму и произведение элементов,
а затем добавить к общему результату значение сумма + произведение.
#include <stdio.h>
int main(void)
{
double a[3][4] = {
{ 1.0, 2.0, 3.0, 4.0 },
{ 2.0, 2.0, 2.0, 2.0 },
{ 1.0, 3.0, 5.0, 7.0 }
};
int i;
int j;
double rowSum;
double rowProduct;
double result = 0.0;
for (i = 0; i < 3; i++)
{
rowSum = 0.0;
rowProduct = 1.0;
for (j = 0; j < 4; j++)
{
rowSum += a[i][j];
rowProduct *= a[i][j];
}
result += rowSum + rowProduct;
}
printf("Результат = %f\n", result);
return 0;
}
Здесь внешний цикл отвечает за строки. Внутренний цикл обрабатывает
элементы текущей строки. Перед каждым проходом внутреннего цикла
rowSum снова получает 0.0, а
rowProduct — 1.0.
break и continue во вложенных циклах
Во вложенных циклах операторы break и continue
действуют только на ближайший цикл, внутри которого они находятся.
int i;
int j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 5; j++)
{
if (j == 2)
{
break;
}
printf("i = %d, j = %d\n", i, j);
}
}
В этом примере break завершает только внутренний цикл
по j. Внешний цикл по i продолжает работу.
Если нужно полностью выйти из нескольких уровней вложенных циклов, обычно используют дополнительный флаг или перестраивают алгоритм.
int stop = 0;
for (i = 0; i < rows && !stop; i++)
{
for (j = 0; j < cols; j++)
{
if (a[i][j] == 0)
{
stop = 1;
break;
}
}
}
Сортировка массива: идея пузырька
Массивы часто нужно упорядочивать. Один из простых учебных алгоритмов — сортировка обменами, или пузырьковая сортировка.
Идея такая: соседние элементы сравниваются попарно. Если они стоят в неправильном порядке, они меняются местами. После одного полного прохода самый большой элемент оказывается в конце массива.
#include <stdio.h>
int main(void)
{
int a[5] = { 5, 1, 4, 2, 3 };
int n = 5;
int i;
int temp;
int swapped;
do
{
swapped = 0;
for (i = 0; i < n - 1; i++)
{
if (a[i] > a[i + 1])
{
temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
swapped = 1;
}
}
n--;
} while (swapped);
for (i = 0; i < 5; i++)
{
printf("%d ", a[i]);
}
return 0;
}
В этом варианте переменная swapped показывает, были ли обмены
на очередном проходе. Если обменов не было, массив уже упорядочен,
и внешний цикл можно завершить.
После каждого полного прохода значение n уменьшается,
потому что последний элемент текущего рассматриваемого участка уже
находится на своём месте.
Инициализация одномерного массива
Массив можно инициализировать сразу при объявлении. Для этого значения перечисляются в фигурных скобках.
int a[5] = { 10, 20, 30, 40, 50 };
После такого объявления:
a[0] = 10
a[1] = 20
a[2] = 30
a[3] = 40
a[4] = 50
Если размер массива не указан, компилятор определит его по количеству начальных значений.
double d[] = { 1.0, 2.0, 3.0, 4.0, 5.0 };
Здесь будет создан массив из 5 элементов.
Частичная инициализация массива
Если размер массива указан, а начальных значений меньше, чем элементов, явно заданные значения получают первые элементы массива.
int m[8] = { 8, 4, 2 };
По стандартным правилам C оставшиеся элементы получают нулевые значения:
m[0] = 8
m[1] = 4
m[2] = 2
m[3] = 0
m[4] = 0
m[5] = 0
m[6] = 0
m[7] = 0
Это отличается от ситуации, когда локальный автоматический массив вообще не имеет инициализатора.
int a[8];
В таком случае элементы локального массива имеют неопределённые значения, пока программа сама их не заполнит.
Инициализация двумерного массива
Двумерный массив можно инициализировать построчно.
int matrix[3][4] = {
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }
};
Каждая внутренняя пара фигурных скобок задаёт одну строку матрицы.
Можно записать значения и одним общим списком:
int matrix[3][4] = {
1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12
};
Но построчная запись обычно читается лучше, потому что визуально показывает структуру таблицы.
Массивы фиксированного размера и переменное n
В учебных программах часто используется приём:
double x[100];
int n;
Массив объявляется с максимальным размером 100, а фактически
используется только n элементов. При этом нужно следить,
чтобы n не превышало размер массива.
while (1)
{
printf("Введите n: ");
scanf("%d", &n);
if (n > 0 && n <= 100)
{
break;
}
printf("Ошибка!\n");
}
Такой подход прост и понятен для начального курса. Позже, при изучении динамической памяти, можно будет выделять массивы нужного размера во время выполнения программы.
Выход за границы массива
Язык C не выполняет автоматическую проверку границ массива при каждом обращении к элементу. Если программа обращается к несуществующему элементу, это является серьёзной ошибкой.
int a[5];
a[5] = 10; /* ошибка: допустимые индексы 0..4 */
Такая ошибка может привести к повреждению других данных программы, неправильным результатам или аварийному завершению.
Поэтому при работе с массивами нужно всегда контролировать условия циклов.
for (i = 0; i < 5; i++) /* правильно */
{
a[i] = 0;
}
for (i = 0; i <= 5; i++) /* ошибка */
{
a[i] = 0;
}
Типичные ошибки
Ошибка 1. Индекс начинается с 1
int a[5];
int i;
for (i = 1; i <= 5; i++)
{
scanf("%d", &a[i]);
}
Здесь пропускается a[0] и происходит обращение к
несуществующему a[5]. Правильно:
for (i = 0; i < 5; i++)
{
scanf("%d", &a[i]);
}
Ошибка 2. Выход за границы массива
int a[10];
a[10] = 100;
В массиве из 10 элементов последний индекс равен 9.
Ошибка 3. Использование неинициализированных элементов
int a[5];
int sum = 0;
for (i = 0; i < 5; i++)
{
sum += a[i];
}
Элементы массива не получили значений. Перед использованием массив нужно заполнить.
Ошибка 4. Неправильный начальный максимум
int max = 0;
Если все элементы массива отрицательные, такой максимум будет неверным. Лучше использовать первый элемент:
int max = a[0];
Ошибка 5. Забыли обнулить сумму строки
for (i = 0; i < rows; i++)
{
for (j = 0; j < cols; j++)
{
rowSum += a[i][j];
}
printf("%d\n", rowSum);
}
Здесь rowSum не обнуляется перед новой строкой.
Правильно:
for (i = 0; i < rows; i++)
{
rowSum = 0;
for (j = 0; j < cols; j++)
{
rowSum += a[i][j];
}
printf("%d\n", rowSum);
}
Ошибка 6. Неправильная работа с break во вложенных циклах
for (i = 0; i < rows; i++)
{
for (j = 0; j < cols; j++)
{
if (a[i][j] == 0)
{
break;
}
}
}
Этот break завершает только внутренний цикл, а не оба цикла.
Если нужно завершить весь поиск, нужен дополнительный флаг или другая
организация алгоритма.
Практические рекомендации
- Всегда помни: индексы массива идут от
0доn - 1. - Для прохода по массиву чаще всего используй цикл
for. - Проверяй значение
n, если пользователь вводит количество элементов. - Не обращайся к элементам за пределами массива.
- Перед накоплением суммы задавай начальное значение
0. - Перед накоплением произведения задавай начальное значение
1. - Для поиска минимума или максимума бери начальное значение из первого элемента массива.
- Для двумерных массивов обычно используй вложенные циклы.
- Во вложенных циклах помни, что
breakзавершает только ближайший цикл. - Для читаемости выводи индекс вместе со значением элемента при отладке.
Мини-разбор программы
Программа вводит количество элементов, заполняет массив, выводит среднее значение и максимальный элемент.
#include <stdio.h>
int main(void)
{
int a[100];
int n;
int i;
int sum = 0;
int max;
double average;
while (1)
{
printf("Введите n от 1 до 100: ");
scanf("%d", &n);
if (n > 0 && n <= 100)
{
break;
}
printf("Ошибка ввода.\n");
}
for (i = 0; i < n; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
sum += a[i];
}
max = a[0];
for (i = 1; i < n; i++)
{
if (a[i] > max)
{
max = a[i];
}
}
average = (double)sum / n;
printf("Среднее = %.2f\n", average);
printf("Максимум = %d\n", max);
return 0;
}
Разберём программу:
a[100]— массив с максимальным размером 100 элементов;n— фактическое количество используемых элементов;- цикл
while (1)проверяет допустимостьn; - первый цикл
forвводит элементы и считает сумму; max = a[0]задаёт начальный максимум;- второй цикл
forищет максимальный элемент; (double)sum / nвыполняет вещественное деление для среднего значения.
Что нужно запомнить
- Массив хранит несколько элементов одного типа под одним именем.
- Элемент массива выбирается по индексу.
- Индексация массивов в C начинается с нуля.
- Если массив содержит
nэлементов, последний индекс равенn - 1. - Элемент массива можно использовать как обычную переменную.
- Для обработки массива обычно используется цикл.
- Двумерный массив в C является массивом массивов.
- Для обработки двумерного массива обычно используются вложенные циклы.
breakиcontinueво вложенных циклах действуют только на ближайший цикл.- Массив можно инициализировать списком значений в фигурных скобках.
- При частичной инициализации оставшиеся элементы получают нулевые значения.
- Локальный массив без инициализатора содержит неопределённые значения.
- Выход за границы массива — серьёзная ошибка.
Самопроверка перед переходом дальше
- Что такое массив?
- Почему все элементы массива имеют один тип?
- Как объявить массив из 10 целых чисел?
- Какие индексы допустимы для массива
int a[10]? - Почему обращение к
a[10]является ошибкой? - Как ввести элементы массива с клавиатуры?
- Почему в
scanfдля элемента массива пишут&a[i]? - Как найти сумму элементов массива?
- Почему максимум лучше начинать с
a[0], а не с0? - Как объявить двумерный массив 3 на 4?
- Зачем нужны вложенные циклы при работе с матрицами?
- Что делает
breakво вложенном цикле? - Как инициализировать массив при объявлении?
- Что произойдёт при частичной инициализации массива?