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

Введение

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

Skills Graph

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

На этом этапе вы научитесь объявлять и инициализировать массивы в программировании на языке 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

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

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

   • Объявляет целочисленный массив из 5 элементов
   • Инициализирует все элементы определенными значениями
   • Размер массива определяется количеством элементов в списке инициализации

2. int scores[3]; с последующим присваиванием значений отдельным элементам

   • Сначала объявляет массив
   • Затем присваивает значения отдельным элементам
   • Полезно, когда вам нужно устанавливать значения динамически

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

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

1. Индексация массива

   • Доступ к элементам массива осуществляется с использованием индексов, начинающихся с нуля
   • temperatures[0] ссылается на первый элемент
   • temperatures[4] ссылается на последний элемент в массиве из 5 элементов

2. Модификация элементов массива

   • Отдельные элементы можно изменить напрямую, используя их индекс
   • temperatures[1] = 70; заменяет второй элемент на 70
   • Вы можете модифицировать элементы по любому допустимому индексу

3. Вычисления с элементами массива

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

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

• Никогда не обращайтесь к индексу массива за его пределами
• Индексы массивов начинаются с 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

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

1. Стандартный цикл for

   • Наиболее распространенный метод для перебора элементов массива
   • Позволяет точно контролировать индекс
   • Идеален для последовательной обработки элементов

2. Обратный перебор

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

3. Перебор с использованием цикла 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

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

1. Вычисление суммы

   • Используйте цикл для суммирования всех элементов массива
   • Аккумулируйте значения в отдельной переменной
   • Полезно для нахождения общей суммы

2. Вычисление среднего значения

   • Разделите общую сумму на количество элементов
   • Используйте приведение типов для получения дробной части
   • Позволяет получить среднее значение элементов массива

3. Нахождение максимального/минимального значения

   • Инициализируйте переменную первым элементом массива
   • Сравнивайте каждый последующий элемент
   • Обновляйте максимальное/минимальное значение, если найдено новое экстремальное значение

4. Поэлементные преобразования

   • Применяйте математические операции к каждому элементу
   • Можно изменять значения элементов массива в соответствии с определенными правилами
   • Полезно для масштабирования, корректировки или преобразования данных

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

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

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

На этом этапе вы научитесь динамически выделять память для массивов в программировании на языке 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

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

1. Функция malloc()

   • Выделяет запрошенный объем памяти и возвращает указатель
   • Синтаксис: pointer = (type *)malloc(size * sizeof(type))
   • Всегда проверяйте, не равен ли возвращаемый указатель NULL, чтобы убедиться, что выделение памяти прошло успешно

2. Функция realloc()

   • Изменяет размер ранее выделенного блока памяти
   • Может увеличивать или уменьшать размер массива
   • Сохраняет существующие данные при расширении

3. Функция free()

   • Освобождает динамически выделенную память
   • Предотвращает утечки памяти
   • Должен быть вызван для каждого вызова malloc()/realloc()

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

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

Резюме

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