Манипуляции с элементами массива в языке C

Введение

В этом лабораторном занятии вы научитесь манипулировать элементами массивов в программировании на языке C. Лабораторная работа охватывает основные навыки объявления и инициализации массивов, доступа к элементам массива и их модификации, перебора элементов массива, выполнения вычислений с массивами и динамического выделения памяти для массивов. Вы изучите различные методы работы с массивами, включая объявление и инициализацию массивов с определенными значениями, частичную инициализацию массивов и динамическое присваивание значений элементам массива. По завершении лабораторной работы вы получите твердое понимание того, как эффективно управлять и манипулировать структурой данных массива в языке C.

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

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

Начнем с создания нового файла на языке C для изучения объявления и инициализации массивов:

cd ~/project
touch array_basics.c

Теперь напишем программу, которая демонстрирует различные способы объявления и инициализации массивов:

#include <stdio.h>

int main() {
    // Method 1: Declare and initialize an array with specific values
    int numbers[5] = {10, 20, 30, 40, 50};

    // Method 2: Declare an array and initialize later
    int scores[3];
    scores[0] = 85;
    scores[1] = 92;
    scores[2] = 78;

    // Method 3: Partially initialize an array (remaining elements set to 0)
    int grades[4] = {100, 95};

    // Print the arrays to verify initialization
    printf("Numbers array: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    printf("Scores array: ");
    for (int i = 0; i < 3; i++) {
        printf("%d ", scores[i]);
    }
    printf("\n");

    printf("Grades array: ");
    for (int i = 0; i < 4; i++) {
        printf("%d ", grades[i]);
    }
    printf("\n");

    return 0;
}

Скомпилируйте и запустите программу:

gcc array_basics.c -o array_basics
./array_basics

Пример вывода:

Numbers array: 10 20 30 40 50
Scores array: 85 92 78
Grades array: 100 95 0 0

Разберем методы инициализации массивов:

int numbers[5] = {10, 20, 30, 40, 50};
- Объявляет целочисленный массив из 5 элементов
- Инициализирует все элементы определенными значениями
- Размер массива определяется количеством элементов в списке инициализации
int scores[3]; с последующим присваиванием значений отдельным элементам
- Сначала объявляет массив
- Затем присваивает значения отдельным элементам
- Полезно, когда вам нужно устанавливать значения динамически
int grades[4] = {100, 95};
- Частично инициализирует массив
- Неуказанные элементы автоматически устанавливаются в 0
- Позволяет сэкономить время, когда вам нужно установить только некоторые начальные значения

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

Индексы массивов начинаются с 0
Вы должны указать тип элементов, которые будет хранить массив
Массивы имеют фиксированный размер после объявления
Всегда убедитесь, что не обращаетесь к элементам массива за пределами его объявленного размера

Доступ и модификация элементов массива

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

Создадим новый файл на языке C для практики доступа и модификации элементов массива:

cd ~/project
touch array_access.c

Теперь напишем программу, которая демонстрирует доступ к элементам массива и их модификацию:

#include <stdio.h>

int main() {
    // Declare and initialize an array
    int temperatures[5] = {72, 68, 75, 80, 65};

    // Accessing individual array elements
    printf("First temperature: %d\n", temperatures[0]);
    printf("Third temperature: %d\n", temperatures[2]);

    // Modifying array elements
    temperatures[1] = 70;  // Change the second element
    temperatures[4] = 73;  // Change the last element

    // Print the modified array
    printf("Modified temperatures: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", temperatures[i]);
    }
    printf("\n");

    // Demonstrate array element calculation
    int average = (temperatures[0] + temperatures[1] + temperatures[2] +
                   temperatures[3] + temperatures[4]) / 5;
    printf("Average temperature: %d\n", average);

    return 0;
}

Скомпилируйте и запустите программу:

gcc array_access.c -o array_access
./array_access

Пример вывода:

First temperature: 72
Third temperature: 75
Modified temperatures: 72 70 75 80 73
Average temperature: 74

Разберем основные концепции:

Индексация массива
- Доступ к элементам массива осуществляется с использованием индексов, начинающихся с нуля
- temperatures[0] ссылается на первый элемент
- temperatures[4] ссылается на последний элемент в массиве из 5 элементов
Модификация элементов массива
- Отдельные элементы можно изменить напрямую, используя их индекс
- temperatures[1] = 70; заменяет второй элемент на 70
- Вы можете модифицировать элементы по любому допустимому индексу
Вычисления с элементами массива
- Вы можете выполнять вычисления, используя отдельные элементы массива
- В примере мы вычислили среднюю температуру
- В математических операциях обращайтесь к элементам напрямую по их индексу

Общие ошибки, которые нужно избегать:

Никогда не обращайтесь к индексу массива за его пределами
Индексы массивов начинаются с 0, а не с 1
Будьте осторожны, чтобы не превысить объявленный размер массива

Перебор элементов массива

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

Создадим новый файл на языке C для изучения методов перебора элементов массива:

cd ~/project
touch array_iteration.c

Теперь напишем программу, которая демонстрирует несколько способов перебора элементов массива:

#include <stdio.h>

int main() {
    // Declare and initialize an array of student scores
    int scores[6] = {85, 92, 78, 90, 88, 95};
    int total = 0;

    // Method 1: Using a standard for loop
    printf("Method 1 - Standard For Loop:\n");
    for (int i = 0; i < 6; i++) {
        printf("Score %d: %d\n", i + 1, scores[i]);
        total += scores[i];
    }

    // Calculate and print average
    float average = (float)total / 6;
    printf("\nTotal Score: %d\n", total);
    printf("Average Score: %.2f\n", average);

    // Method 2: Reverse iteration
    printf("\nMethod 2 - Reverse Iteration:\n");
    printf("Scores in reverse order:\n");
    for (int i = 5; i >= 0; i--) {
        printf("Score %d: %d\n", i + 1, scores[i]);
    }

    // Method 3: While loop iteration
    printf("\nMethod 3 - While Loop Iteration:\n");
    int j = 0;
    while (j < 6) {
        if (scores[j] >= 90) {
            printf("High score detected: %d\n", scores[j]);
        }
        j++;
    }

    return 0;
}

Скомпилируйте и запустите программу:

gcc array_iteration.c -o array_iteration
./array_iteration

Пример вывода:

Method 1 - Standard For Loop:
Score 1: 85
Score 2: 92
Score 3: 78
Score 4: 90
Score 5: 88
Score 6: 95

Total Score: 528
Average Score: 88.00

Method 2 - Reverse Iteration:
Scores in reverse order:
Score 6: 95
Score 5: 88
Score 4: 90
Score 3: 78
Score 2: 92
Score 1: 85

Method 3 - While Loop Iteration:
High score detected: 92
High score detected: 90
High score detected: 95

Основные методы перебора элементов массива:

Стандартный цикл for
- Наиболее распространенный метод для перебора элементов массива
- Позволяет точно контролировать индекс
- Идеален для последовательной обработки элементов
Обратный перебор
- Перебор элементов массива от последнего к первому
- Полезен для выполнения определенных требований к обработке
- Использует убывающий счетчик цикла
Перебор с использованием цикла while
- Предоставляет гибкий контроль над перебором
- Может включать условную обработку
- Полезен для сложной логики перебора

Важные принципы перебора элементов массива:

Всегда определяйте четкие границы цикла
Используйте длину массива, чтобы избежать выхода за пределы массива
Выбирайте наиболее подходящий метод перебора для конкретной задачи

Выполнение вычислений с массивами

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

Создадим новый файл на языке C для практики вычислений с массивами:

cd ~/project
touch array_calculations.c

Теперь напишем программу, которая демонстрирует различные методы вычислений с массивами:

#include <stdio.h>
#include <limits.h>

int main() {
    // Declare and initialize an array of sales data
    int sales[7] = {1200, 1500, 980, 1750, 1100, 1300, 1600};

    // Calculate Total Sales
    int total_sales = 0;
    for (int i = 0; i < 7; i++) {
        total_sales += sales[i];
    }
    printf("Total Weekly Sales: $%d\n", total_sales);

    // Calculate Average Sales
    float average_sales = (float)total_sales / 7;
    printf("Average Daily Sales: $%.2f\n", average_sales);

    // Find Maximum Sales
    int max_sales = sales[0];  // Start with first element
    for (int i = 1; i < 7; i++) {
        if (sales[i] > max_sales) {
            max_sales = sales[i];
        }
    }
    printf("Highest Daily Sales: $%d\n", max_sales);

    // Find Minimum Sales
    int min_sales = sales[0];  // Start with first element
    for (int i = 1; i < 7; i++) {
        if (sales[i] < min_sales) {
            min_sales = sales[i];
        }
    }
    printf("Lowest Daily Sales: $%d\n", min_sales);

    // Apply Percentage Increase
    float increase_percentage = 1.1;  // 10% increase
    printf("\nSales After 10%% Increase:\n");
    for (int i = 0; i < 7; i++) {
        float increased_sale = sales[i] * increase_percentage;
        printf("Day %d: $%.2f\n", i + 1, increased_sale);
    }

    return 0;
}

Скомпилируйте и запустите программу:

gcc array_calculations.c -o array_calculations
./array_calculations

Пример вывода:

Total Weekly Sales: $9430
Average Daily Sales: $1347.14
Highest Daily Sales: $1750
Lowest Daily Sales: $980

Sales After 10% Increase:
Day 1: $1320.00
Day 2: $1650.00
Day 3: $1078.00
Day 4: $1925.00
Day 5: $1210.00
Day 6: $1430.00
Day 7: $1760.00

Основные методы вычислений с массивами:

Вычисление суммы
- Используйте цикл для суммирования всех элементов массива
- Аккумулируйте значения в отдельной переменной
- Полезно для нахождения общей суммы
Вычисление среднего значения
- Разделите общую сумму на количество элементов
- Используйте приведение типов для получения дробной части
- Позволяет получить среднее значение элементов массива
Нахождение максимального/минимального значения
- Инициализируйте переменную первым элементом массива
- Сравнивайте каждый последующий элемент
- Обновляйте максимальное/минимальное значение, если найдено новое экстремальное значение
Поэлементные преобразования
- Применяйте математические операции к каждому элементу
- Можно изменять значения элементов массива в соответствии с определенными правилами
- Полезно для масштабирования, корректировки или преобразования данных

Важные принципы вычислений:

Всегда учитывайте границы массива
Используйте подходящие типы данных
Будьте осторожны при целочисленном делении
Инициализируйте переменные - аккумуляторы перед вычислениями

Динамическое выделение памяти для массива

На этом этапе вы научитесь динамически выделять память для массивов в программировании на языке C с использованием функций malloc(), realloc() и free(). Динамическое выделение памяти позволяет создавать массивы с размерами, определяемыми во время выполнения программы.

Создадим новый файл на языке C для изучения динамического выделения памяти:

cd ~/project
touch dynamic_array.c

Теперь напишем программу, которая демонстрирует динамическое выделение памяти для массива:

#include <stdio.h>
#include <stdlib.h>

int main() {
    // Dynamic memory allocation for an integer array
    int array_size;
    printf("Enter the number of elements: ");
    scanf("%d", &array_size);

    // Allocate memory dynamically
    int *dynamic_array = (int *)malloc(array_size * sizeof(int));

    // Check if memory allocation was successful
    if (dynamic_array == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Input array elements
    printf("Enter %d integers:\n", array_size);
    for (int i = 0; i < array_size; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &dynamic_array[i]);
    }

    // Print array elements
    printf("\nArray elements:\n");
    for (int i = 0; i < array_size; i++) {
        printf("%d ", dynamic_array[i]);
    }
    printf("\n");

    // Dynamically resize the array
    int new_size;
    printf("\nEnter new array size: ");
    scanf("%d", &new_size);

    // Reallocate memory
    int *resized_array = (int *)realloc(dynamic_array, new_size * sizeof(int));

    // Check if reallocation was successful
    if (resized_array == NULL) {
        printf("Memory reallocation failed!\n");
        free(dynamic_array);
        return 1;
    }

    dynamic_array = resized_array;

    // If new size is larger, initialize new elements
    if (new_size > array_size) {
        for (int i = array_size; i < new_size; i++) {
            dynamic_array[i] = 0;
        }
    }

    // Print resized array
    printf("Resized array:\n");
    for (int i = 0; i < new_size; i++) {
        printf("%d ", dynamic_array[i]);
    }
    printf("\n");

    // Free dynamically allocated memory
    free(dynamic_array);

    return 0;
}

Скомпилируйте и запустите программу:

gcc dynamic_array.c -o dynamic_array
./dynamic_array

Пример взаимодействия с программой:

Enter the number of elements: 3
Enter 3 integers:
Element 1: 10
Element 2: 20
Element 3: 30

Array elements:
10 20 30

Enter new array size: 5
Resized array:
10 20 30 0 0

Основные концепции динамического выделения памяти:

Функция malloc()
- Выделяет запрошенный объем памяти и возвращает указатель
- Синтаксис: pointer = (type *)malloc(size * sizeof(type))
- Всегда проверяйте, не равен ли возвращаемый указатель NULL, чтобы убедиться, что выделение памяти прошло успешно
Функция realloc()
- Изменяет размер ранее выделенного блока памяти
- Может увеличивать или уменьшать размер массива
- Сохраняет существующие данные при расширении
Функция free()
- Освобождает динамически выделенную память
- Предотвращает утечки памяти
- Должен быть вызван для каждого вызова malloc()/realloc()

Важные принципы выделения памяти:

Всегда проверяйте успешность выделения памяти
Освобождайте динамически выделенную память, когда она больше не нужна
Будьте осторожны при изменении размера массивов
Корректно обрабатывайте возможные ошибки выделения памяти

Резюме

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