Créer des tableaux bidimensionnels en C

Introduction

Dans ce laboratoire, vous apprendrez à créer et à manipuler des tableaux bidimensionnels en C. Vous commencerez par déclarer des tableaux bidimensionnels, puis explorerez diverses méthodes pour les initialiser. Ensuite, vous apprendrez à accéder et à manipuler les éléments des tableaux. Enfin, vous appliquerez vos connaissances pour calculer la moyenne des notes de deux matières et améliorer la fonctionnalité des tableaux bidimensionnels. Ce laboratoire offre une compréhension complète de la manipulation des tableaux bidimensionnels dans le langage de programmation C.

Déclarer des tableaux bidimensionnels

Dans cette étape, vous apprendrez à déclarer des tableaux bidimensionnels en C, qui sont essentiellement des tableaux de tableaux permettant de stocker des données dans une structure en grille avec des lignes et des colonnes.

Commençons par créer un nouveau fichier C pour démontrer la déclaration de tableaux bidimensionnels :

touch ~/project/two_dimensional_arrays.c

Maintenant, écrivons notre première déclaration de tableau bidimensionnel :

#include <stdio.h>

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

    return 0;
}

Dans cet exemple, grades est un tableau bidimensionnel avec 3 lignes et 4 colonnes. Cela signifie qu'il peut stocker un total de 12 valeurs entières (3 × 4 = 12).

Explorons différentes façons de déclarer des tableaux bidimensionnels en ajoutant le code suivant au fichier :

// 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};

Compilez et exécutez le programme pour vérifier :

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

La sortie de l'exemple sera une exécution de programme vide car nous n'avons pas ajouté d'instructions d'impression.

Points clés concernant la déclaration de tableaux bidimensionnels :

• La première parenthèse représente les lignes
• La deuxième parenthèse représente les colonnes
• Vous pouvez initialiser partiellement ou complètement
• Les éléments non initialisés sont automatiquement mis à zéro
• Nombre total d'éléments = nombre de lignes × nombre de colonnes

Initialiser des tableaux bidimensionnels

Dans cette étape, vous apprendrez diverses méthodes pour initialiser des tableaux bidimensionnels en C, en vous appuyant sur les compétences de déclaration de l'étape précédente.

Modifions le fichier précédent pour explorer différentes techniques d'initialisation.

Maintenant, remplacez le code existant par les méthodes d'initialisation suivantes :

#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;
}

Compilez et exécutez le programme :

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Exemple de sortie :

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

Principales méthodes d'initialisation :

1. Initialisation complète : Spécifiez les valeurs pour chaque ligne
2. Initialisation partielle : Les éléments non spécifiés sont mis à zéro
3. Initialisation aplatie : Les valeurs sont remplies ligne par ligne
4. Initialisation à zéro : Tous les éléments sont mis à zéro

Points importants :

• Vous pouvez initialiser partiellement les tableaux
• Les éléments non spécifiés sont automatiquement mis à zéro
• Le nombre total d'initialiseurs ne peut pas dépasser la taille du tableau
• Les accolades imbriquées aident à clarifier l'initialisation ligne par ligne

Accéder aux éléments d'un tableau bidimensionnel

Dans cette étape, vous apprendrez à accéder aux éléments individuels d'un tableau bidimensionnel en utilisant l'indexation et des boucles imbriquées en C.

Mettons à jour notre fichier précédent pour démontrer l'accès aux éléments.

Ajoutez le code suivant pour explorer différentes façons d'accéder aux éléments du tableau :

#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;
}

Compilez et exécutez le programme :

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Exemple de sortie :

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

Points clés concernant l'accès aux éléments d'un tableau bidimensionnel :

• Utilisez deux indices : array[row][column]
• Le premier indice représente la ligne (verticale)
• Le deuxième indice représente la colonne (horizontale)
• L'indexation commence à 0
• Les boucles imbriquées sont utiles pour parcourir l'ensemble des tableaux
• Vous pouvez lire et modifier directement les éléments individuels

Calculer les moyennes de notes pour deux matières

Dans cette étape, vous apprendrez à utiliser des tableaux bidimensionnels pour calculer la moyenne des notes de plusieurs étudiants dans différentes matières.

Mettons à jour notre fichier précédent pour calculer les moyennes des matières.

Ajoutez le code suivant pour calculer et afficher les moyennes des notes :

#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;
}

Compilez et exécutez le programme :

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Exemple de sortie :

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)

Concepts clés démontrés :

• Utilisation de boucles imbriquées pour traiter des tableaux bidimensionnels
• Calcul des moyennes sur les lignes et les colonnes
• Recherche des moyennes les plus élevées et les plus basses
• Conversion de type pour calculer des moyennes en virgule flottante
• Définition de constantes pour les dimensions des tableaux

Améliorer la fonctionnalité des tableaux bidimensionnels

Dans cette étape finale, vous apprendrez des techniques avancées pour améliorer la fonctionnalité des tableaux bidimensionnels, notamment le passage de tableaux à des fonctions, l'allocation dynamique de mémoire et la création d'opérations de tableau plus complexes.

Mettons à jour notre fichier précédent pour démontrer ces concepts avancés.

Remplacez le code précédent par cet exemple complet :

#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;
}

Compilez et exécutez le programme :

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Exemple de sortie :

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

Concepts avancés clés démontrés :

• Passage de tableaux bidimensionnels à des fonctions
• Transposition de tableau
• Allocation dynamique de mémoire pour des tableaux bidimensionnels
• Gestion de la mémoire avec malloc() et free()
• Techniques de manipulation de tableaux flexibles

Résumé

Dans ce laboratoire, vous avez appris à déclarer des tableaux bidimensionnels en C, qui sont des tableaux de tableaux permettant de stocker des données dans une structure en grille composée de lignes et de colonnes. Vous avez exploré différentes méthodes de déclaration et d'initialisation de tableaux bidimensionnels, notamment l'initialisation complète, l'initialisation partielle et l'initialisation aplatie. Vous avez également appris que les éléments non initialisés sont automatiquement mis à zéro et que le nombre total d'éléments dans un tableau bidimensionnel est déterminé par le produit du nombre de lignes et du nombre de colonnes.

En vous appuyant sur les compétences de déclaration, vous avez ensuite appris diverses méthodes pour initialiser des tableaux bidimensionnels en C, notamment en assignant les valeurs ligne par ligne, colonne par colonne ou en utilisant une approche aplatie. Vous avez également exploré comment accéder à des éléments individuels dans le tableau bidimensionnel en utilisant les indices de ligne et de colonne.