Практическая работа №5

Цель работы

Получить практические навыки работы с одномерными массивами в C++: объявления, инициализации, перебора, определения количества элементов, поиска и изменения элементов.

Основные теоретические положения

1. Одномерные массивы

Массив — это набор элементов одного типа, расположенных последовательно в памяти.

Например:

int numbers[5] = {10, 20, 30, 40, 50};

Массив numbers содержит пять элементов типа int.

Каждый элемент массива имеет индекс.

Индекс	0	1	2	3	4
Значение	10	20	30	40	50

Индексация массива в C++ начинается с 0.

Для обращения к отдельному элементу используется его индекс:

cout << numbers[0];
cout << numbers[3];

Результат:

10
40

Значение элемента массива можно изменить:

numbers[2] = 100;

После этого массив будет содержать:

10 20 100 40 50

Индексы массива

Для массива из N элементов допустимы индексы от 0 до N - 1.

Например, для массива из пяти элементов допустимы индексы:

0 1 2 3 4

Обращение за пределы массива приводит к неопределённому поведению программы.

---

2. Объявление и инициализация массива

Массив фиксированного размера:

int numbers[5];

Массив с начальными значениями:

int numbers[5] = {4, 8, 15, 16, 23};

Если все начальные значения задаются сразу, размер массива можно не указывать:

int numbers[] = {4, 8, 15, 16, 23};

Компилятор самостоятельно определит количество элементов.

---

3. Определение количества элементов с помощью sizeof

Оператор sizeof возвращает размер объекта в байтах.

Например:

int numbers[] = {10, 20, 30, 40, 50};

cout << sizeof(numbers);

Для определения количества элементов массива можно разделить размер всего массива на размер одного элемента:

int size = sizeof(numbers) / sizeof(numbers[0]);

Общая запись:

sizeof(массив) / sizeof(массив[0])

Например:

int numbers[] = {10, 20, 30, 40, 50};

int size = sizeof(numbers) / sizeof(numbers[0]);

cout << size;

Результат:

5

Как работает выражение с sizeof

Если весь массив занимает 20 байт, а один элемент типа int — 4 байта, то:

20 / 4 = 5

Следовательно, массив содержит пять элементов.

---

4. Определение количества элементов с помощью std::size()

Начиная с C++17 количество элементов обычного массива можно определить с помощью std::size():

#include <iostream>
#include <iterator>

using namespace std;

int main() {
    int numbers[] = {10, 20, 30, 40, 50};

    cout << std::size(numbers);

    return 0;
}

Результат:

5

Оба способа:

sizeof(numbers) / sizeof(numbers[0])

и:

std::size(numbers)

возвращают количество элементов массива.

Какой способ использовать?

Для обычного массива допустимы оба варианта.

sizeof(numbers) / sizeof(numbers[0])

показывает, каким образом вычисляется количество элементов.

Запись:

std::size(numbers)

короче и проще читается.

---

5. Перебор элементов массива с помощью for

Для обработки всех элементов массива можно использовать обычный цикл for.

int numbers[] = {5, 8, 2, 10, 7};

for (int i = 0; i < std::size(numbers); i++) {
    cout << numbers[i] << " ";
}

Переменная i содержит индекс текущего элемента.

Результат:

5 8 2 10 7

Обычный for удобен, если требуется работать не только со значением элемента, но и с его индексом:

for (int i = 0; i < std::size(numbers); i++) {
    cout << "numbers[" << i << "] = " << numbers[i] << endl;
}

Условие цикла

Правильно:

i < std::size(numbers)

Неправильно:

i <= std::size(numbers)

Если использовать <=, на последней итерации программа попытается обратиться к элементу за пределами массива.

---

6. Перебор элементов с помощью range-based for (foreach)

Если индекс элемента не требуется, массив удобно перебирать с помощью range-based for.

int numbers[] = {5, 8, 2, 10, 7};

for (int number : numbers) {
    cout << number << " ";
}

Результат:

5 8 2 10 7

Такой цикл часто называют foreach, так как действие выполняется для каждого элемента массива.

Общая форма:

for (тип переменная : массив) {
    // действия
}

Например:

for (int number : numbers) {
    cout << number << endl;
}

Переменная number последовательно получает значения всех элементов массива.

---

7. Использование foreach для вычислений

С помощью range-based for можно находить сумму элементов:

int sum = 0;

for (int number : numbers) {
    sum += number;
}

Подсчитывать элементы:

int count = 0;

for (int number : numbers) {
    if (number > 0) {
        count++;
    }
}

for или foreach?

Если требуется только значение элемента:

for (int number : numbers)

обычно удобнее.

Если необходим индекс:

for (int i = 0; i < std::size(numbers); i++)

удобнее обычный цикл for.

---

8. Изменение элементов в foreach

Рассмотрим следующий цикл:

for (int number : numbers) {
    number = 0;
}

Он не изменит исходный массив.

Переменная number получает копию значения элемента.

Для изменения элемента необходимо использовать ссылку:

for (int& number : numbers) {
    number = 0;
}

Например:

int numbers[] = {5, -8, 2, -10, 7};

for (int& number : numbers) {
    if (number < 0) {
        number = 0;
    }
}

После обработки:

5 0 2 0 7

Копия и ссылка

Запись:

for (int number : numbers)

работает с копией элемента.

Запись:

for (int& number : numbers)

позволяет работать непосредственно с элементом массива и изменять его.

---

9. Вычисление суммы элементов

Для накопления результата используется отдельная переменная:

int numbers[] = {5, 8, 2, 10, 7};

int sum = 0;

for (int i = 0; i < std::size(numbers); i++) {
    sum += numbers[i];
}

cout << sum;

То же вычисление с использованием foreach:

int sum = 0;

for (int number : numbers) {
    sum += number;
}

cout << sum;

---

10. Подсчёт элементов по условию

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

int numbers[] = {5, -8, 2, -10, 7};

int count = 0;

for (int number : numbers) {
    if (number > 0) {
        count++;
    }
}

cout << count;

---

11. Поиск минимального и максимального элементов

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

int numbers[] = {7, 3, 12, 5, 9};

int maxValue = numbers[0];

for (int i = 1; i < std::size(numbers); i++) {
    if (numbers[i] > maxValue) {
        maxValue = numbers[i];
    }
}

cout << maxValue;

Если необходимо определить индекс максимального элемента:

int maxIndex = 0;

for (int i = 1; i < std::size(numbers); i++) {
    if (numbers[i] > numbers[maxIndex]) {
        maxIndex = i;
    }
}

cout << "Значение: " << numbers[maxIndex] << endl;
cout << "Индекс: " << maxIndex << endl;

---

12. Размер массива и количество используемых элементов

Необходимо различать полный размер массива и количество элементов, которые фактически используются программой.

Например:

const int MAX_SIZE = 10;

int numbers[MAX_SIZE];

Массив рассчитан на десять элементов:

cout << std::size(numbers);

Результат:

10

Однако программа может использовать только часть массива:

int n;

cin >> n;

for (int i = 0; i < n; i++) {
    cin >> numbers[i];
}

Если пользователь ввёл:

5

то фактически используются только первые пять элементов.

Размер массива и n

В таком случае:

std::size(numbers)

вернёт 10, потому что физический размер массива равен десяти элементам.

Переменная:

n

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

Задания для выполнения

Часть 1. Исследование одномерных массивов

Задание 1.1. Индексы и элементы массива

Объявите массив:

int numbers[] = {12, -5, 7, 0, 18, -3, 9};

Выведите каждый элемент массива вместе с его индексом.

Результат должен иметь следующий вид:

numbers[0] = 12
numbers[1] = -5
numbers[2] = 7
numbers[3] = 0
...

После этого измените значение элемента с индексом 3 на 25 и повторно выведите массив.

Ответьте на вопросы:

1. Какой элемент массива является первым?
2. Какой индекс имеет последний элемент массива?
3. Чем индекс элемента отличается от его значения?

---

Задание 1.2. Исследование sizeof

Используйте массив:

int numbers[] = {12, -5, 7, 0, 18, -3, 9};

Выведите:

1. размер всего массива в байтах;
2. размер одного элемента массива;
3. количество элементов массива.

Используйте:

sizeof(numbers)

sizeof(numbers[0])

sizeof(numbers) / sizeof(numbers[0])

Вывод программы оформите следующим образом:

Размер массива: ... байт
Размер одного элемента: ... байт
Количество элементов: ...

Объясните, почему деление размера массива на размер одного элемента позволяет определить количество элементов.

---

Задание 1.3. Использование std::size()

Для того же массива определите количество элементов с помощью:

std::size(numbers)

Сравните результат с:

sizeof(numbers) / sizeof(numbers[0])

Программа должна вывести:

Количество через sizeof: ...
Количество через std::size: ...

Ответьте на вопросы:

1. Одинаковый ли результат дают оба способа?
2. Какой вариант записи проще читать?
3. Начиная с какой версии стандарта C++ доступна функция std::size()?

---

Задание 1.4. Перебор элементов массива

Дан массив:

int numbers[] = {5, 8, -2, 10, -7, 4, 11};

Используя обычный цикл for:

1. выведите все элементы массива;
2. найдите сумму всех элементов;
3. определите количество положительных элементов;
4. определите количество отрицательных элементов.

Результат оформите следующим образом:

Массив: 5 8 -2 10 -7 4 11
Сумма элементов: ...
Положительных элементов: ...
Отрицательных элементов: ...

---

Задание 1.5. Использование foreach

Дан массив:

int numbers[] = {4, -7, 12, 3, -5, 8, 10};

Не используя индексы массива и применяя range-based for:

1. выведите все элементы массива;
2. найдите сумму всех элементов;
3. определите количество положительных элементов;
4. определите количество отрицательных элементов;
5. определите количество чётных элементов.

Результат оформите следующим образом:

Массив: 4 -7 12 3 -5 8 10
Сумма: ...
Положительных: ...
Отрицательных: ...
Чётных: ...

---

Задание 1.6. Изменение элементов через foreach

Создайте массив:

int values[] = {5, -3, 8, -6, 4, -1};

Выполните следующий код:

for (int value : values) {
    if (value < 0) {
        value = 0;
    }
}

Выведите массив после выполнения цикла.

Ответьте на вопрос:

Изменились ли элементы исходного массива? Почему?

После этого измените цикл:

for (int& value : values) {
    if (value < 0) {
        value = 0;
    }
}

Снова выведите массив.

Сравните результаты работы двух вариантов программы.

---

Задание 1.7. Сравнение for и foreach

Дан массив:

int numbers[] = {15, 4, 9, 21, 6};

Выведите все элементы:

1. с помощью обычного цикла for;
2. с помощью range-based for.

После этого выведите каждый элемент вместе с его индексом.

Ответьте на вопросы:

1. В каком цикле проще получить значение элемента?
2. В каком цикле проще получить индекс?
3. В каких случаях удобнее использовать обычный for?
4. В каких случаях удобнее использовать range-based for?

---

Часть 2. Задания для самостоятельного выполнения

Порядок выполнения варианта

Номер варианта соответствует порядковому номеру студента в списке группы.

Если количество студентов превышает 15, варианты повторяются по кругу.

Для своего варианта необходимо:

1. составить схему алгоритма;
2. написать программу на языке C++;
3. определить количество элементов с помощью std::size() или sizeof;
4. вывести исходный массив;
5. выполнить все задания варианта;
6. вывести полученные результаты;
7. проверить правильность работы программы.

Требования к схеме алгоритма

В схеме алгоритма необходимо отобразить:

• начало и конец алгоритма;
• исходный массив;
• инициализацию необходимых переменных;
• цикл перебора элементов;
• используемые условия;
• выполняемые вычисления;
• вывод результата.

Схема алгоритма

В блок-схеме необходимо описывать логику алгоритма, а не полностью копировать синтаксис программы C++.

Например:

sum = sum + numbers[i]

достаточно для блока выполнения операции.

---

Вариант 1

int numbers[] = {7, -3, 12, 5, -8, 10, 4};

Необходимо:

1. найти сумму всех элементов массива;
2. найти максимальный элемент и его индекс;
3. найти сумму элементов, расположенных до максимального элемента.

---

Вариант 2

int numbers[] = {8, -4, 2, -7, 11, 6, -1};

Необходимо:

1. определить количество положительных и отрицательных элементов;
2. найти минимальный элемент и его индекс;
3. заменить все отрицательные элементы значением 0 и вывести изменённый массив.

---

Вариант 3

int numbers[] = {4, 9, 2, 15, 7, 11, 6};

Необходимо:

1. найти минимальный элемент массива и его индекс;
2. вычислить среднее арифметическое элементов;
3. определить количество элементов, которые больше среднего арифметического.

---

Вариант 4

int numbers[] = {-2, 8, 0, -5, 12, 4, -1, 7};

Необходимо:

1. определить количество положительных, отрицательных и нулевых элементов;
2. найти сумму положительных элементов;
3. найти первый отрицательный элемент и вывести его индекс.

---

Вариант 5

int numbers[] = {6, 3, 10, 7, 12, 5, 8};

Необходимо:

1. определить количество чётных и нечётных элементов;
2. найти сумму элементов, расположенных на чётных индексах;
3. умножить элементы с нечётными индексами на 2 и вывести изменённый массив.

Индекс и позиция

Чётный индекс и чётная позиция элемента — не одно и то же.

Первый элемент массива имеет индекс 0.

---

Вариант 6

int numbers[] = {14, 3, 9, 2, 17, 6, 11};

Необходимо:

1. найти минимальный и максимальный элементы;
2. определить их индексы;
3. поменять минимальный и максимальный элементы местами и вывести массив.

---

Вариант 7

int numbers[] = {5, 8, 5, 2, 5, 10, 7, 5};

Введите с клавиатуры число X.

Необходимо:

1. определить, сколько раз X встречается в массиве;
2. найти индекс первого элемента, равного X;
3. заменить все элементы, равные X, значением 0.

Если число X отсутствует в массиве, вывести соответствующее сообщение.

---

Вариант 8

int numbers[] = {11, -3, 8, 6, -7, 10, 4};

Необходимо:

1. найти сумму положительных элементов;
2. найти произведение отрицательных элементов;
3. определить, каких элементов больше: положительных или отрицательных.

Если их количество одинаково, вывести соответствующее сообщение.

---

Вариант 9

int numbers[] = {2, 7, 4, 9, 6, 11, 8};

Необходимо:

1. определить количество элементов, которые больше 5;
2. найти сумму элементов, которые меньше 5;
3. все элементы, которые меньше 5, заменить значением 0.

Вывести изменённый массив.

---

Вариант 10

int numbers[] = {12, 7, 4, 15, 6, 9, 2};

Необходимо:

1. найти сумму чётных элементов;
2. найти максимальный нечётный элемент;
3. определить количество элементов, которые меньше найденного максимального нечётного элемента.

---

Вариант 11

int numbers[] = {3, 6, 8, 7, 12, 15, 14};

Необходимо:

1. определить количество элементов, которые больше предыдущего элемента;
2. определить количество элементов, которые меньше предыдущего элемента;
3. проверить, расположен ли массив строго по возрастанию.

Пример строго возрастающего массива:

2 4 7 9 15

Массив:

2 4 4 9 15

не является строго возрастающим.

---

Вариант 12

int numbers[] = {5, 12, 3, 8, 14, 6, 10};

Необходимо:

1. вычислить среднее арифметическое элементов;
2. определить количество элементов, которые больше среднего арифметического;
3. найти сумму элементов, которые меньше среднего арифметического.

---

Вариант 13

int numbers[] = {6, 4, -3, 8, 10, -5, 7};

Необходимо:

1. найти первый отрицательный элемент и его индекс;
2. найти сумму элементов, расположенных до первого отрицательного элемента;
3. определить количество элементов, расположенных после первого отрицательного элемента.

Если отрицательных элементов нет, вывести соответствующее сообщение.

---

Вариант 14

int numbers[] = {4, 9, 2, 9, 6, 9, 3};

Необходимо:

1. найти максимальный элемент;
2. определить количество повторений максимального элемента;
3. вывести индексы всех элементов, равных максимальному.

---

Вариант 15

int numbers[] = {7, 2, 11, 5, 4, 9, 6};

Необходимо:

1. найти минимальный и максимальный элементы;
2. определить разность между максимальным и минимальным элементами;
3. найти сумму элементов, расположенных между минимальным и максимальным элементами.

Минимальный и максимальный элементы в сумму не включаются.

---

Дополнительное задание

Выполняется после завершения своего варианта.

Создайте массив:

int numbers[10];

Введите количество используемых элементов n.

1 <= n <= 10

После этого введите n целых чисел.

Программа должна:

1. вывести полный размер массива с помощью std::size(numbers);
2. вывести размер всего массива в байтах;
3. вывести размер одного элемента;
4. вывести количество фактически введённых элементов n;
5. найти сумму введённых элементов;
6. найти минимальный элемент;
7. найти максимальный элемент.

Вопрос

Почему значение:

std::size(numbers)

может отличаться от значения:

n

Контрольные вопросы

1. Что называется массивом?
2. Как объявить массив из пяти элементов типа int?
3. С какого значения начинается индексация массива в C++?
4. Как обратиться к третьему элементу массива?
5. Чем индекс элемента отличается от его значения?
6. Что возвращает оператор sizeof?
7. Как определить количество элементов массива с помощью sizeof?
8. Для чего используется std::size()?
9. В чём различие между полным размером массива и количеством фактически используемых элементов?
10. Почему при переборе массива используется условие i < size, а не i <= size?
11. Что может произойти при обращении к элементу за пределами массива?
12. Что представляет собой range-based for?
13. Чем range-based for отличается от обычного цикла for?
14. В каких случаях удобнее использовать обычный for?
15. В каких случаях удобнее использовать foreach?
16. Почему for (int value : numbers) не изменяет элементы исходного массива?
17. Для чего используется for (int& value : numbers)?
18. Как найти минимальный или максимальный элемент массива?
19. Как определить индекс минимального или максимального элемента?
20. Для чего перед написанием программы составляется схема алгоритма?

Рекомендуемая литература

1. LearnCpp — Introduction to containers and arrays
2. LearnCpp — C-style arrays
3. LearnCpp — Range-based for loops
4. cppreference — Arrays
5. cppreference — Range-based for loop
6. cppreference — std::size
7. cppreference — sizeof
8. Стивен Прата. Язык программирования C++. Лекции и упражнения. 6-е изд.
9. Бьерн Страуструп. Язык программирования C++. 4-е изд.