Criar Arrays Bidimensionais em C

Introdução

Neste laboratório, você aprenderá como criar e manipular arrays bidimensionais em C. Começará declarando arrays bidimensionais e, em seguida, explorará vários métodos para inicializá-los. Em seguida, aprenderá como acessar e manipular os elementos dos arrays. Por fim, aplicará seus conhecimentos para calcular a média das notas de duas disciplinas e aprimorar a funcionalidade dos arrays bidimensionais. Este laboratório oferece uma compreensão abrangente do trabalho com arrays bidimensionais na linguagem de programação C.

Declarar Arrays Bidimensionais

Nesta etapa, você aprenderá como declarar arrays bidimensionais em C, que são essencialmente arrays de arrays que permitem armazenar dados em uma estrutura semelhante a uma grade com linhas e colunas.

Vamos começar criando um novo arquivo C para demonstrar a declaração de um array bidimensional:

touch ~/project/two_dimensional_arrays.c

Agora, vamos escrever nossa primeira declaração de array bidimensional:

#include <stdio.h>

int main() {
    // Declare a 3x4 integer two-dimensional array
    int grades[3][4];

    return 0;
}

Neste exemplo, grades é um array bidimensional com 3 linhas e 4 colunas. Isso significa que ele pode armazenar um total de 12 valores inteiros (3 × 4 = 12).

Vamos explorar diferentes maneiras de declarar arrays bidimensionais, adicionando o seguinte código ao arquivo:

// Method 1: Declaration with initialization
int matrix[2][3] = {
    {1, 2, 3},   // First row
    {4, 5, 6}    // Second row
};

// Method 2: Partial initialization
int scores[3][3] = {
    {10, 20, 30},
    {40, 50}     // Remaining elements will be zero
};

// Method 3: Flattened initialization
int simple_matrix[2][3] = {1, 2, 3, 4, 5, 6};

Compile e execute o programa para verificar:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

A saída de exemplo será uma execução de programa vazia, pois não adicionamos nenhuma instrução de impressão.

Pontos-chave sobre a declaração de arrays bidimensionais:

• O primeiro colchete representa as linhas
• O segundo colchete representa as colunas
• Você pode inicializar parcial ou totalmente
• Elementos não inicializados são automaticamente definidos como zero
• Total de elementos = linhas × colunas

Inicializar Arrays Bidimensionais

Nesta etapa, você aprenderá vários métodos para inicializar arrays bidimensionais em C, construindo sobre as habilidades de declaração da etapa anterior.

Vamos modificar o arquivo anterior para explorar diferentes técnicas de inicialização.

Agora, substitua o código existente pelos seguintes métodos de inicialização:

#include <stdio.h>

int main() {
    // Method 1: Complete initialization
    int scores[3][4] = {
        {85, 92, 78, 90},    // First row
        {76, 88, 95, 82},    // Second row
        {63, 71, 89, 93}     // Third row
    };

    // Method 2: Partial initialization
    int temperatures[2][3] = {
        {25, 30, 22},        // First row
        {28}                 // Partial second row
    };

    // Method 3: Flattened initialization
    int matrix[2][3] = {1, 2, 3, 4, 5, 6};

    // Method 4: Initialize all elements to zero
    int zeros[3][3] = {0};

    // Print the first method to demonstrate
    printf("Student Scores:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", scores[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Compile e execute o programa:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Saída de exemplo:

Student Scores:
85 92 78 90
76 88 95 82
63 71 89 93

Principais métodos de inicialização:

1. Inicialização completa: Especifique valores para cada linha
2. Inicialização parcial: Elementos não especificados são definidos como zero
3. Inicialização achatada: Valores preenchidos linha por linha
4. Inicialização com zero: Todos os elementos definidos como zero

Pontos importantes:

• Você pode inicializar parcialmente arrays
• Elementos não especificados são automaticamente definidos como zero
• O número total de inicializadores não pode exceder o tamanho do array
• Chaves aninhadas ajudam a esclarecer a inicialização por linha

Acessar Elementos de Arrays Bidimensionais

Nesta etapa, você aprenderá como acessar elementos individuais em um array bidimensional usando indexação e loops aninhados em C.

Vamos atualizar nosso arquivo anterior para demonstrar o acesso a elementos.

Adicione o seguinte código para explorar diferentes maneiras de acessar elementos de array:

#include <stdio.h>

int main() {
    // Create a 3x4 student grades array
    int grades[3][4] = {
        {85, 92, 78, 90},    // First student's grades
        {76, 88, 95, 82},    // Second student's grades
        {63, 71, 89, 93}     // Third student's grades
    };

    // Method 1: Direct element access
    printf("First student's first grade: %d\n", grades[0][0]);
    printf("Second student's third grade: %d\n", grades[1][2]);

    // Method 2: Accessing elements using nested loops
    printf("\nAll grades using nested loops:\n");
    for (int student = 0; student < 3; student++) {
        for (int subject = 0; subject < 4; subject++) {
            printf("Student %d, Subject %d: %d\n",
                   student + 1, subject + 1, grades[student][subject]);
        }
    }

    // Method 3: Modifying array elements
    grades[2][3] = 95;  // Update last grade of third student
    printf("\nUpdated third student's last grade: %d\n", grades[2][3]);

    return 0;
}

Compile e execute o programa:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Saída de exemplo:

First student's first grade: 85
Second student's third grade: 95

All grades using nested loops:
Student 1, Subject 1: 85
Student 1, Subject 2: 92
Student 1, Subject 3: 78
Student 1, Subject 4: 90
Student 2, Subject 1: 76
Student 2, Subject 2: 88
Student 2, Subject 3: 95
Student 2, Subject 4: 82
Student 3, Subject 1: 63
Student 3, Subject 2: 71
Student 3, Subject 3: 89
Student 3, Subject 4: 95

Updated third student's last grade: 95

Pontos-chave sobre o acesso a elementos de arrays bidimensionais:

• Use dois índices: array[linha][coluna]
• O primeiro índice representa a linha (vertical)
• O segundo índice representa a coluna (horizontal)
• A indexação começa em 0
• Loops aninhados são úteis para percorrer arrays inteiros
• Você pode ler e modificar diretamente elementos individuais

Calcular Médias de Notas para Duas Disciplinas

Nesta etapa, você aprenderá como usar arrays bidimensionais para calcular as médias de notas de vários alunos em diferentes matérias.

Vamos atualizar nosso arquivo anterior para calcular as médias das matérias.

Adicione o seguinte código para calcular e exibir as médias das notas:

#include <stdio.h>

#define STUDENTS 5
#define SUBJECTS 3

int main() {
    // Create a two-dimensional array for student marks
    int marks[STUDENTS][SUBJECTS] = {
        {85, 92, 78},
        {76, 88, 95},
        {63, 71, 89},
        {90, 84, 77},
        {82, 79, 91}
    };

    // Arrays to store subject averages
    float subject_averages[SUBJECTS];

    // Compute average for each subject
    for (int subject = 0; subject < SUBJECTS; subject++) {
        int subject_total = 0;

        // Sum marks for current subject
        for (int student = 0; student < STUDENTS; student++) {
            subject_total += marks[student][subject];
        }

        // Calculate average
        subject_averages[subject] = (float)subject_total / STUDENTS;
    }

    // Display subject averages
    printf("Subject Averages:\n");
    for (int subject = 0; subject < SUBJECTS; subject++) {
        printf("Subject %d: %.2f\n", subject + 1, subject_averages[subject]);
    }

    // Bonus: Find highest and lowest subject average
    float highest_avg = subject_averages[0];
    float lowest_avg = subject_averages[0];
    int highest_subject = 0;
    int lowest_subject = 0;

    for (int subject = 1; subject < SUBJECTS; subject++) {
        if (subject_averages[subject] > highest_avg) {
            highest_avg = subject_averages[subject];
            highest_subject = subject;
        }
        if (subject_averages[subject] < lowest_avg) {
            lowest_avg = subject_averages[subject];
            lowest_subject = subject;
        }
    }

    printf("\nHighest Average: Subject %d (%.2f)\n",
           highest_subject + 1, highest_avg);
    printf("Lowest Average: Subject %d (%.2f)\n",
           lowest_subject + 1, lowest_avg);

    return 0;
}

Compile e execute o programa:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Saída de exemplo:

Subject Averages:
Subject 1: 79.20
Subject 2: 82.80
Subject 3: 86.00

Highest Average: Subject 3 (86.00)
Lowest Average: Subject 1 (79.20)

Conceitos-chave demonstrados:

• Uso de loops aninhados para processar arrays bidimensionais
• Cálculo de médias em linhas e colunas
• Encontrar as médias mais altas e mais baixas
• Conversão de tipo (type casting) para calcular médias de ponto flutuante
• Definição de constantes para dimensões de array

Aprimorar Funcionalidade de Arrays Bidimensionais

Nesta etapa final, você aprenderá técnicas avançadas para aprimorar a funcionalidade de arrays bidimensionais, incluindo a passagem de arrays para funções, alocação dinâmica de memória e a criação de operações de array mais complexas.

Vamos atualizar nosso arquivo anterior para demonstrar esses conceitos avançados.

Substitua o código anterior por este exemplo abrangente:

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

#define ROWS 3
#define COLS 4

// Function to print a two-dimensional array
void printArray(int arr[ROWS][COLS]) {
    printf("Array Contents:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d ", arr[i][j]);
        }
        printf("\n");
    }
}

// Function to transpose a two-dimensional array
void transposeArray(int original[ROWS][COLS], int transposed[COLS][ROWS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            transposed[j][i] = original[i][j];
        }
    }
}

int main() {
    // Static two-dimensional array
    int matrix[ROWS][COLS] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    // Print original array
    printf("Original Array:\n");
    printArray(matrix);

    // Transpose the array
    int transposed[COLS][ROWS];
    transposeArray(matrix, transposed);

    // Print transposed array
    printf("\nTransposed Array:\n");
    for (int i = 0; i < COLS; i++) {
        for (int j = 0; j < ROWS; j++) {
            printf("%4d ", transposed[i][j]);
        }
        printf("\n");
    }

    // Dynamic memory allocation for 2D array
    int **dynamicMatrix;
    dynamicMatrix = (int **)malloc(ROWS * sizeof(int *));
    for (int i = 0; i < ROWS; i++) {
        dynamicMatrix[i] = (int *)malloc(COLS * sizeof(int));
    }

    // Initialize dynamic matrix
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            dynamicMatrix[i][j] = i * COLS + j + 1;
        }
    }

    // Print dynamic matrix
    printf("\nDynamic Matrix:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d ", dynamicMatrix[i][j]);
        }
        printf("\n");
    }

    // Free dynamically allocated memory
    for (int i = 0; i < ROWS; i++) {
        free(dynamicMatrix[i]);
    }
    free(dynamicMatrix);

    return 0;
}

Compile e execute o programa:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Saída de exemplo:

Original Array:
   1   2   3   4
   5   6   7   8
   9  10  11  12

Transposed Array:
   1   5   9
   2   6  10
   3   7  11
   4   8  12

Dynamic Matrix:
   1   2   3   4
   5   6   7   8
   9  10  11  12

Conceitos avançados-chave demonstrados:

• Passagem de arrays bidimensionais para funções
• Transposição de array
• Alocação dinâmica de memória para arrays 2D
• Gerenciamento de memória com malloc() e free()
• Técnicas flexíveis de manipulação de array

Resumo

Neste laboratório, você aprendeu como declarar arrays bidimensionais em C, que são arrays de arrays que permitem armazenar dados em uma estrutura semelhante a uma grade com linhas e colunas. Você explorou diferentes métodos de declaração e inicialização de arrays bidimensionais, incluindo inicialização completa, inicialização parcial e inicialização achatada. Você também aprendeu que elementos não inicializados são automaticamente definidos como zero, e o número total de elementos em um array bidimensional é determinado pelo produto do número de linhas e colunas.

Com base nas habilidades de declaração, você então aprendeu vários métodos para inicializar arrays bidimensionais em C, incluindo a atribuição de valores linha por linha, coluna por coluna, ou usando uma abordagem achatada. Você também explorou como acessar elementos individuais dentro do array bidimensional usando índices de linha e coluna.