Guide : Implémenter un Fichier en Tableau Circulaire en C

Les fichiers en tableaux circulaires (ou files d’attente circulaires ) sont des structures de données utiles pour gérer les opérations de type FIFO (First In, First Out) avec une mémoire fixe. Ce guide vous montre comment créer une f

1. Introduction aux Fichiers en Tableaux Circulaires

Un fichier est une structure de données où :

Enqueue (insertion) : Les données sont ajoutées à la fin.
Dequeue (retrait) : Les données sont retirées du début.
La gestion circulaire permet de réuti

2. Structure de base

Voici la structure de base pour un fichier en tableau circulaire

typedef struct {
    int *data;      // Tableau dynamique pour stocker les éléments
    int capacity;   // Capacité maximale du tableau
    int head;       // Indice du premier élément
    int tail;       // Indice du prochain emplacement d'insertion
    int size;       // Nombre d'éléments actuels dans la file
} CircularQueue;

3. Étapes pour créer le fichier

a. Initialisation

Créez une fonction pour initialiser le fichier avec une capacité donnée :

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

void initializeQueue(CircularQueue *queue, int capacity) {
    queue->data = (int *)malloc(capacity * sizeof(int));
    if (queue->data == NULL) {
        printf("Erreur d'allocation mémoire.\n");
        exit(1);
    }
    
  
queue->capacity = capacity;
    queue->head = 0;
    queue->tail = 0;
    queue->size = 0;
}

b. Enqueue (Insertion dans le fichier)

Ajoutez un élément au fichier. Assurez-vous que le fichier n’est pas plein

 int enqueue(CircularQueue *queue, int value) {
    if (queue->size == queue->capacity) {
        return -1; // La file est pleine
    }
    queue->data[queue->tail] = value;
    queue->tail = (queue->tail + 1) % queue->capacity; // Gestion circulaire
    queue->size++;
    return 0;
}

c. Dequeue (Retrait de la file)

Retirez un élément du fichier. Assurez-vous que le fichier

 int dequeue(CircularQueue *queue, int *value) {
    if (queue->size == 0) {
        return -1; // La file est vide
    }
    *value = queue->data[queue->head];
    queue->head = (queue->head + 1) % queue->capacity; // Gestion circulaire
    queue->size--;
    return 0;
}

d. Vérification de l’état du dossier

Ajouter des fonctions pour vérifier si le fichier

 int isQueueFull(CircularQueue *queue) {
    
  
return queue->size == queue->capacity;
}

int isQueueEmpty(CircularQueue *queue) {
    return queue->size == 0;
}

e. Libération de la mémoire

Libérez la mémoire allouée pour le fichier lorsque vous avez terminé son utilisation :

 void freeQueue(CircularQueue *queue) {
    free(queue->data);
    queue->data = NULL;
    queue->capacity = queue->head = queue->tail = queue->size = 0;
}

4. Code complet

Voici un programme complet pour un fichier en tableau circulaire avec toutes les opérations :

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

typedef struct {
    int *data;      // Tableau pour stocker les éléments
    int capacity;   // Capacité maximale
    int head;       // Indice du premier élément
    int tail;       // Indice du prochain emplacement d'insertion
    int size;       // Nombre d'éléments actuels
} CircularQueue;

// Initialisation de la file
void initializeQueue(CircularQueue *queue, int capacity) {
    queue->data = (int *)malloc(capacity * sizeof(int));
    if (queue->data == NULL) {
        printf("Erreur d'allocation mémoire.\n");
        exit(1);
    }
    queue->capacity = capacity;
    queue->head = 0;
    
    
queue->tail = 0;
    queue->size = 0;
}

// Ajouter un élément à la file
int enqueue(CircularQueue *queue, int value) {
    if (queue->size == queue->capacity) {
        return -1; // La file est pleine
    }
    queue->data[queue->tail] = value;
    queue->tail = (queue->tail + 1) % queue->capacity; // Gestion circulaire
    queue->size++;
    return 0;
}

// Retirer un élément de la file
int dequeue(CircularQueue *queue, int *value) {
    if (queue->size == 0) {
        return -1; // La file est vide
    }
    *value = queue->data[queue->head];
    queue->head = (queue->head + 1) % queue->capacity; // Gestion circulaire
    queue->size--;
    return 0;
}

// Vérifier si la file est pleine
int isQueueFull(CircularQueue *queue) {
    return queue->size == queue->capacity;
}

// Vérifier si la file est vide
int isQueueEmpty(CircularQueue *queue) {
    return queue->size == 0;
}


}
// Libérer la mémoire de la file
void freeQueue(CircularQueue *queue) {
    free(queue->data);
    queue->data = NULL;
    queue->capacity = queue->head = queue->tail = queue->size = 0;
}

// Programme principal
int main() {
    CircularQueue queue;
    initializeQueue(&
    in
queue, 5); // Capacité de la file : 5

    // Ajout d'éléments dans la file
    enqueue(&queue, 10);
    enqueue(&queue, 20);
    enqueue(&
    enqueu
queue, 30);
    enqueue(&queue, 40);
    enqueue(&queue, 50);

    if (enqueue(&queue, 60) == -1) {
        printf("La file est pleine !\n");
    }

    
    }

// Retirer des éléments de la file
    int value;
    while (!isQueueEmpty(&queue)) {
        dequeue(&queue, &value);
        printf("Élément retiré : %d\n", value);
    }

    if (dequeue(&queue, &value) == -1) {
        printf("La file est vide !\n");
    }

    // Libérer la mémoire
    freeQueue(&
    freeQueue(&queu
queue);
    return 0;
}

5. Fonctionnement du Code

Initialisation

Créez un fichier avec une capacité fixe.
Allouez dynamiquement un tableau pour stocker les éléments.

Insertion

Ajoutez un élément au fichier en utilisant l’indice tail.
Incrémentez tailde manière circulaire.

Retrait

Supprimez un élément du fichier en utilisant l’indice head.
Incrémentez headde manière circulaire.

Vérifications

Vérifiez si le fichier est plein

Libération

Libérez la mémoire à

6. Points à noter

Capacité fixe : La circulaire fichier à une taille fixe, définie lors de l
Gestion circulaire : Les indices headet tailbouclent grâce à l’opération modulo ( %).
Simplicité : Cette implémentation ne nécessite pas de réallocation dynamique, ce qui la rend rapide et efficace.

7. Extensions et améliorations

Augmentation dynamique : Implémentez une fonction pour augmenter la taille du fichier lorsque nécessaire.
Version thread-safe : Utilisez des verrous ou des opérations atomiques pou
Support pour d’autres types : Modifiez le fichier pour prendre en charge des types génériquesvoid *).

En suivant ce guide, vous pouvez facilement implémenter et utiliser un fichier en tableau circulaire pour diverses applications en C, comme la gestion de flux de données ou les tâches FIFO.