Manipuler les tableaux en C

Introduction

Dans ce laboratoire (lab), vous apprendrez à manipuler les tableaux (arrays) en programmation C. Le laboratoire couvre les concepts fondamentaux de la déclaration, de l'initialisation, de l'accès et de l'itération des tableaux. Vous commencerez par découvrir la syntaxe de déclaration des tableaux, puis vous passerez à l'initialisation d'un tableau d'entiers avec des valeurs, à l'accès aux éléments du tableau à l'aide d'indices, et enfin à l'affichage des éléments dans une boucle for. À la fin de ce laboratoire, vous aurez une bonne compréhension de la manipulation des tableaux en C.

Présenter la syntaxe de déclaration de tableau

Dans cette étape, nous allons présenter le concept fondamental de la déclaration de tableaux en programmation C. Les tableaux sont des structures de données essentielles qui vous permettent de stocker plusieurs éléments du même type dans une zone mémoire contiguë. Imaginez un tableau comme une rangée de boîtes de stockage, où chaque boîte peut contenir un type spécifique d'objet, et vous pouvez accéder à ces boîtes en utilisant leur numéro d'index unique.

Qu'est-ce qu'un tableau (array)?

Un tableau est une collection de variables qui sont accessibles via un numéro d'index. Tous les éléments d'un tableau sont du même type. Imaginez une bibliothèque où chaque étagère peut contenir des livres du même genre - c'est similaire à la façon dont un tableau fonctionne en programmation. Chaque "livre" (ou élément) peut être accédé par sa position (index) sur l'étagère.

Syntaxe de déclaration des tableaux (arrays)

Pour déclarer un tableau en C, vous utilisez la syntaxe suivante :

type arrayName[arraySize];

type : Le type de données des éléments du tableau (par exemple, int, float, char). Cela détermine le type de données que le tableau peut stocker.
arrayName : Le nom du tableau, que vous utiliserez pour référencer et manipuler le tableau.
arraySize : Le nombre d'éléments que le tableau peut contenir, définissant la capacité de stockage totale du tableau.

Exemple : Déclaration et initialisation d'un tableau (array)

Commençons par créer un nouveau fichier dans le WebIDE pour explorer la déclaration de tableaux. Cet exemple pratique vous aidera à comprendre le fonctionnement des tableaux dans des scénarios de programmation réels.

Ouvrez le WebIDE et suivez ces étapes :

Cliquez avec le bouton droit dans l'explorateur de fichiers et sélectionnez "Nouveau fichier".
Nommez le fichier arrays_intro.c.
Cliquez sur le fichier pour l'ouvrir dans l'éditeur.

Maintenant, écrivons un programme simple pour démontrer la déclaration et l'initialisation d'un tableau :

#include <stdio.h>

int main() {
    // Declaring an integer array with 5 elements
    int numbers[5] = {10, 20, 30, 40, 50};

    // Printing array elements
    printf("Array elements:\n");
    for (int i = 0; i < 5; i++) {
        printf("numbers[%d] = %d\n", i, numbers[i]);
    }

    return 0;
}

Analysons la déclaration du tableau :

int numbers[5] : Cela déclare un tableau d'entiers nommé numbers qui peut contenir 5 éléments. C'est comme créer une étagère avec 5 emplacements pour stocker des valeurs entières.
{10, 20, 30, 40, 50} : Cela initialise le tableau avec des valeurs spécifiques, remplissant chaque "emplacement d'étagère" avec un nombre prédéfini.
Le premier élément numbers[0] est 10, le deuxième numbers[1] est 20, et ainsi de suite. N'oubliez pas que l'indexation des tableaux commence à 0 en C.

Compilez et exécutez le programme :

Pour compiler et exécuter le programme, utilisez les commandes suivantes dans le terminal :

gcc arrays_intro.c -o arrays_intro
./arrays_intro

Exemple de sortie :

Array elements:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

Cette sortie montre comment chaque élément du tableau peut être accédé et affiché en utilisant son index. Comprendre ce concept de base est la première étape pour maîtriser la manipulation des tableaux en programmation C.

Initialiser un tableau d'entiers avec des valeurs

Dans cette étape, nous allons explorer différentes façons d'initialiser des tableaux d'entiers en programmation C. Comprendre l'initialisation des tableaux est crucial pour travailler efficacement avec des collections de données.

Ouvrez le WebIDE et créez un nouveau fichier :

Cliquez avec le bouton droit dans l'explorateur de fichiers et sélectionnez "Nouveau fichier".
Nommez le fichier array_initialization.c.
Cliquez sur le fichier pour l'ouvrir dans l'éditeur.

Lorsque vous travaillez avec des tableaux en C, vous découvrirez rapidement qu'il existe plusieurs approches pour les initialiser. Chaque méthode a son propre cas d'utilisation et peut vous aider à configurer efficacement votre stockage de données. Plongeons dans ces techniques d'initialisation et comprenons comment elles fonctionnent :

#include <stdio.h>

int main() {
    // Method 1: Full initialization
    int scores[5] = {85, 92, 78, 90, 88};

    // Method 2: Partial initialization (remaining elements set to 0)
    int temperatures[5] = {72, 75, 80};

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

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

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

    printf("\nAges array:\n");
    for (int i = 0; i < 5; i++) {
        printf("ages[%d] = %d\n", i, ages[i]);
    }

    return 0;
}

Lorsque vous exécutez ce code, vous verrez comment les différentes méthodes d'initialisation fonctionnent en pratique. Le code démontre trois principales façons de créer et de peupler des tableaux, chacune servant un objectif différent en programmation.

Compilez et exécutez le programme :

gcc array_initialization.c -o array_initialization
./array_initialization

Exemple de sortie :

Scores array:
scores[0] = 85
scores[1] = 92
scores[2] = 78
scores[3] = 90
scores[4] = 88

Temperatures array:
temperatures[0] = 72
temperatures[1] = 75
temperatures[2] = 80
temperatures[3] = 0
temperatures[4] = 0

Ages array:
ages[0] = 0
ages[1] = 0
ages[2] = 0
ages[3] = 0
ages[4] = 0

Analysons les concepts clés de l'initialisation des tableaux que tout débutant devrait comprendre, en nous concentrant sur le code :

Méthode 1 : Initialisation complète int scores[5] = {85, 92, 78, 90, 88}; : Ici, nous déclarons un tableau nommé scores de taille 5 et le initialisons avec 5 valeurs spécifiques. C'est une façon simple d'attribuer des valeurs spécifiques à chaque position du tableau au moment de la déclaration. Chaque élément du tableau est défini selon l'ordre des valeurs entre les accolades.
Méthode 2 : Initialisation partielle int temperatures[5] = {72, 75, 80}; : Dans ce cas, le tableau temperatures de taille 5 est initialisé avec seulement trois valeurs. C gère cela en définissant les éléments restants (aux indices 3 et 4) à zéro. L'initialisation partielle est utile lorsque vous connaissez les premières valeurs et que vous voulez que les autres prennent la valeur par défaut de zéro.
Méthode 3 : Initialiser tous les éléments à zéro int ages[5] = {0}; : Cela initialise un tableau nommé ages de taille 5, avec tous les éléments définis à zéro. C'est un raccourci pratique si vous avez besoin que toutes les valeurs du tableau commencent à zéro. C'est très courant dans des situations telles que le comptage ou les états initiaux de structures de données.
La taille du tableau est fixée à la déclaration : Il est important de se rappeler qu'une fois que vous avez déclaré un tableau avec une taille spécifique (par exemple, [5]), cette taille ne peut pas être modifiée par la suite. Vous ne pouvez pas ajouter ou supprimer des éléments du tableau sans en créer un nouveau.
L'indexation commence toujours à 0 : Comme vous l'avez déjà vu, les éléments du tableau sont accessibles via des indices, et ces indices commencent toujours par 0 pour le premier élément. Dans le tableau scores, scores[0] fait référence au premier élément, scores[1] au deuxième, et ainsi de suite.

Ces méthodes d'initialisation offrent une flexibilité dans la façon dont vous configurez et travaillez avec les tableaux. Au fur et à mesure de votre progression dans votre apprentissage de la programmation C, vous trouverez ces techniques inestimables pour gérer efficacement et proprement des collections de données.

Accéder aux éléments d'un tableau à l'aide d'indices

En C, les tableaux (arrays) sont indexés à partir de zéro, ce qui signifie que le premier élément se trouve à l'indice 0, le deuxième à l'indice 1, et ainsi de suite. Ce concept peut sembler contre-intuitif au départ, mais c'est une convention standard dans de nombreux langages de programmation, issue de la gestion mémoire de bas niveau.

Ouvrez le WebIDE et créez un nouveau fichier :

Cliquez avec le bouton droit dans l'explorateur de fichiers et sélectionnez "Nouveau fichier".
Nommez le fichier array_indexing.c.
Cliquez sur le fichier pour l'ouvrir dans l'éditeur.

Écrivons un programme qui démontre l'indexation et la manipulation de tableaux :

#include <stdio.h>

int main() {
    // Declare and initialize an array of student grades
    int grades[5] = {85, 92, 78, 90, 88};

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

    // Modifying array elements
    printf("\nBefore modification:\n");
    for (int i = 0; i < 5; i++) {
        printf("grades[%d] = %d\n", i, grades[i]);
    }

    // Modify a specific element
    grades[1] = 95;  // Change the second grade
    grades[4] = 87;  // Change the last grade

    printf("\nAfter modification:\n");
    for (int i = 0; i < 5; i++) {
        printf("grades[%d] = %d\n", i, grades[i]);
    }

    // Calculate average grade
    int total = 0;
    for (int i = 0; i < 5; i++) {
        total += grades[i];
    }
    float average = (float)total / 5;
    printf("\nAverage grade: %.2f\n", average);

    return 0;
}

Dans cet exemple, nous travaillons avec un tableau de notes d'étudiants. Le code démontre plusieurs opérations importantes sur les tableaux que tout débutant devrait comprendre. Nous commençons par déclarer un tableau avec cinq éléments entiers, représentant différentes notes d'étudiants.

Compilez et exécutez le programme :

gcc array_indexing.c -o array_indexing
./array_indexing

Exemple de sortie :

First grade (index 0): 85
Third grade (index 2): 78

Before modification:
grades[0] = 85
grades[1] = 92
grades[2] = 78
grades[3] = 90
grades[4] = 88

After modification:
grades[0] = 85
grades[1] = 95
grades[2] = 78
grades[3] = 90
grades[4] = 87

Average grade: 87.00

La sortie illustre comment nous pouvons accéder à des éléments spécifiques d'un tableau, afficher leurs valeurs et les modifier. Les boucles for démontrent une façon efficace d'itérer sur tous les éléments d'un tableau, ce qui est crucial lorsque vous travaillez avec des tableaux de n'importe quelle taille.

Points clés concernant l'indexation des tableaux, en mettant l'accent sur des lignes de code spécifiques :

Les indices de tableau commencent à 0 : Le premier élément du tableau grades est accessible via grades[0], et non grades[1]. L'instruction printf printf("First grade (index 0): %d\n", grades[0]); démontre ce concept clé.
Accéder à des éléments individuels à l'aide de array[index] : L'instruction printf("Third grade (index 2): %d\n", grades[2]); montre comment accéder à un élément spécifique à un indice donné. Ici, nous accédons au troisième élément à l'indice 2.
Modifier les éléments d'un tableau en assignant de nouvelles valeurs : Les lignes grades[1] = 95; et grades[4] = 87; montrent comment changer les valeurs stockées dans le tableau. La valeur à l'indice 1 est mise à jour à 95 et la valeur à l'indice 4 est mise à jour à 87. C'est un accès et une modification directs à l'aide de l'indice et de l'opérateur d'affectation.
Faites attention à ne pas accéder à des indices en dehors des limites du tableau : Si vous essayez d'accéder à grades[5] (rappelez-vous que le tableau a 5 éléments, avec des indices de 0 à 4), vous risquez de provoquer une erreur (cela s'appelle un "dépassement de tampon" ou "accès hors limites"). Accéder à un indice qui n'existe pas entraînera un comportement imprévisible.
Utilisez des boucles pour itérer efficacement sur les éléments d'un tableau : Les boucles for, comme celle utilisée pour afficher le tableau, sont un moyen efficace de parcourir chaque élément d'un tableau de l'indice 0 à 4 de manière séquentielle :

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

Cette boucle utilise la variable i comme indice de 0 à 4.

Comprendre ces principes vous aidera à manipuler efficacement les tableaux dans votre apprentissage de la programmation C. La pratique et l'expérimentation sont essentielles pour maîtriser les opérations sur les tableaux.

Afficher les éléments dans une boucle for

Lorsque vous commencez à apprendre la programmation, le concept des boucles peut sembler intimidant. Cependant, ce sont des outils incroyablement puissants qui vous permettent d'effectuer des tâches répétitives de manière efficace et élégante. Une boucle for offre une façon structurée de parcourir les éléments d'un tableau, vous donnant un contrôle précis sur la façon dont vous interagissez avec chaque élément.

Ouvrez le WebIDE et créez un nouveau fichier :

Cliquez avec le bouton droit dans l'explorateur de fichiers et sélectionnez "Nouveau fichier".
Nommez le fichier array_loop_print.c.
Cliquez sur le fichier pour l'ouvrir dans l'éditeur.

Écrivons un programme qui démontre différentes façons d'afficher les éléments d'un tableau :

#include <stdio.h>

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

    // Method 1: Using a standard for loop with index
    printf("Method 1: Printing with index\n");
    for (int i = 0; i < 5; i++) {
        printf("Temperature %d: %d degrees\n", i + 1, temperatures[i]);
    }

    // Method 2: Printing array with descriptive labels
    printf("\nMethod 2: Printing with labels\n");
    char *days[] = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"};
    for (int i = 0; i < 5; i++) {
        printf("%s's temperature: %d degrees\n", days[i], temperatures[i]);
    }

    // Method 3: Calculating and printing additional information
    printf("\nMethod 3: Calculating average temperature\n");
    int total = 0;
    for (int i = 0; i < 5; i++) {
        total += temperatures[i];
        printf("Adding %d degrees\n", temperatures[i]);
    }
    float average = (float)total / 5;
    printf("Average temperature: %.1f degrees\n", average);

    return 0;
}

Dans cet exemple, nous ne nous contentons pas d'afficher les éléments d'un tableau, mais nous démontrons à quel point les boucles peuvent être polyvalentes. Chaque méthode montre une approche différente pour travailler avec les tableaux, vous aidant à comprendre la flexibilité des boucles for en programmation C.

Compilez et exécutez le programme :

gcc array_loop_print.c -o array_loop_print
./array_loop_print

Exemple de sortie :

Method 1: Printing with index
Temperature 1: 72 degrees
Temperature 2: 75 degrees
Temperature 3: 80 degrees
Temperature 4: 68 degrees
Temperature 5: 85 degrees

Method 2: Printing with labels
Monday's temperature: 72 degrees
Tuesday's temperature: 75 degrees
Wednesday's temperature: 80 degrees
Thursday's temperature: 68 degrees
Friday's temperature: 85 degrees

Method 3: Calculating average temperature
Adding 72 degrees
Adding 75 degrees
Adding 80 degrees
Adding 68 degrees
Adding 85 degrees
Average temperature: 76.0 degrees

Points clés concernant les boucles for et les tableaux, en mettant l'accent sur le code :

La variable de boucle i commence à 0 et va jusqu'à taille_du_tableau - 1 : L'initialisation standard de la boucle for (int i = 0; i < 5; i++) dans la Méthode 1 garantit que la boucle itère du premier élément (indice 0) au dernier élément (indice 4) du tableau temperatures, affichant chaque élément. La condition i < 5 détermine la durée de la boucle.
Vous pouvez utiliser l'indice de boucle pour accéder aux éléments du tableau : Dans la boucle for, temperatures[i] est utilisé pour accéder à l'élément à l'indice correspondant i à chaque cycle de boucle. Cela montre comment le compteur de boucle sert d'indice de tableau.
Les boucles sont idéales pour effectuer des opérations sur des tableaux entiers : La Méthode 3 montre un tableau avec une boucle for calculant un total et affichant des informations supplémentaires pendant la boucle. La boucle for est utilisée pour parcourir tous les éléments du tableau et calculer le total.
Vous pouvez combiner des boucles avec des calculs et des tableaux supplémentaires : La Méthode 2 combine la boucle for avec le tableau supplémentaire days, et la Méthode 3 effectue un calcul pendant la boucle. Cela montre comment utiliser les tableaux et les boucles ensemble.

Comprendre ces concepts vous aidera à écrire un code plus efficace et plus lisible. Au fur et à mesure de votre progression dans votre apprentissage de la programmation, vous constaterez que les boucles et les tableaux sont des outils essentiels pour résoudre des problèmes complexes et implémenter des algorithmes sophistiqués.

Opérations avancées sur les tableaux

Dans cette étape, nous allons explorer certaines opérations avancées que vous pouvez effectuer sur les tableaux, telles que la recherche des valeurs maximale et minimale, et le tri du tableau. Ces techniques sont essentielles pour l'analyse des données, le traitement et la mise en œuvre d'algorithmes.

Écrivons un programme pour trouver les valeurs maximale et minimale dans un tableau :

cd ~/project
touch find_max_min.c

#include <stdio.h>

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

    for (int i = 1; i < 5; i++) {
        if (numbers[i] > max) {
            max = numbers[i];
        }
        if (numbers[i] < min) {
            min = numbers[i];
        }
    }

    printf("Maximum value: %d\n", max);
    printf("Minimum value: %d\n", min);

    return 0;
}

Ce code démontre une technique simple mais puissante pour trouver les valeurs maximale et minimale dans un tableau. En initialisant max et min avec le premier élément, puis en comparant chaque élément suivant, nous pouvons identifier efficacement les valeurs extrêmes du tableau.

Lignes de code clés :

Initialisation : int max = numbers[0]; int min = numbers[0]; - Les variables max et min sont initialisées avec le premier élément du tableau. Cette étape fournit un point de départ pour la comparaison.
Boucle de comparaison : for (int i = 1; i < 5; i++) - Cette boucle for commence à l'indice 1 (le deuxième élément) jusqu'à la fin du tableau. Cela garantit que chaque valeur suivante est vérifiée par rapport aux valeurs max et min existantes.
Recherche du maximum : if (numbers[i] > max) { max = numbers[i]; } - Ce bloc vérifie si l'élément actuel est supérieur au max actuel. Si c'est le cas, la variable max est mise à jour avec la valeur de l'élément actuel.
Recherche du minimum : if (numbers[i] < min) { min = numbers[i]; } - De même, ce bloc vérifie si l'élément actuel est inférieur au min actuel, et met à jour min lorsqu'une valeur plus petite est trouvée.

Ensuite, écrivons un programme pour trier le tableau par ordre croissant en utilisant l'algorithme de tri à bulles (bubble sort) :

cd ~/project
touch bubble_sort.c

#include <stdio.h>

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

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

    bubbleSort(numbers, 5);

    printf("Sorted array:\n");
    for (int i = 0; i < 5; i++) {
        printf("numbers[%d] = %d\n", i, numbers[i]);
    }

    return 0;
}

Le tri à bulles est un algorithme de tri classique qui parcourt répétitivement la liste, compare les éléments adjacents et les échange s'ils sont dans le mauvais ordre. Bien que ce ne soit pas la méthode de tri la plus efficace pour de grands ensembles de données, il constitue une excellente introduction aux concepts de tri et à la manipulation de tableaux.

Lignes de code clés :

Boucle externe : for (int i = 0; i < n-1; i++) - Cette boucle externe contrôle le nombre de passages à travers le tableau. La boucle s'exécute jusqu'à n - 1 fois (où n est la taille du tableau) car le plus grand élément sera à sa position finale après chaque passage.
Boucle interne : for (int j = 0; j < n-i-1; j++) - La boucle interne effectue les comparaisons et les échanges réels. À mesure que les plus grands éléments "remontent" à la fin, la plage de la boucle interne se réduit, c'est pourquoi nous avons n - i - 1 au lieu de n.
Comparaison : if (arr[j] > arr[j+1]) - Cette instruction vérifie si l'élément actuel est supérieur à l'élément suivant.
Échange : Les lignes int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; effectuent l'échange des deux éléments lorsque arr[j] est supérieur à arr[j+1]. Une variable temporaire temp est utilisée pour éviter de perdre l'une des valeurs lors de l'échange.

Pour compiler et exécuter les programmes, utilisez les commandes suivantes dans le terminal :

gcc find_max_min.c -o find_max_min
./find_max_min

gcc bubble_sort.c -o bubble_sort
./bubble_sort

Exemple de sortie pour la recherche du maximum et du minimum :

Maximum value: 50
Minimum value: 10

Exemple de sortie pour le tri :

Sorted array:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

Ces exemples illustrent des opérations fondamentales sur les tableaux qui constituent les éléments de base de techniques de traitement de données plus complexes en programmation C.

Résumé

Dans ce laboratoire, nous avons appris les concepts fondamentaux de la déclaration et de l'initialisation de tableaux en programmation C. Nous avons exploré la syntaxe pour déclarer un tableau d'entiers, y compris comment l'initialiser avec des valeurs spécifiques. Nous avons également appris à accéder aux éléments individuels d'un tableau à l'aide de leurs indices, et à afficher les éléments d'un tableau dans une boucle for. Enfin, nous avons exploré certaines opérations avancées sur les tableaux, telles que la recherche des valeurs maximale et minimale, et le tri d'un tableau avec l'algorithme de tri à bulles (bubble sort). Ces compétences sont essentielles pour travailler avec les tableaux, qui sont une structure de données cruciale en programmation C.