Les Files

a marqué ce sujet comme résolu.

Bonsoir, j’ai beaucoup de mal avec les files en C j’ai commencé a faire des petits exercices voila ce que j’ai pu faire si quelqu’un pourrait m’aider s’il vous plait merci d’avance : typedef struct { int **tab; int tailleMax; int tête; int taille; } fifo;

les fonction que je dois créer : fifo fifoCreer(int tailleMax); // creer une fifo vide bornée par tailleMax et la retourner je dois écrire le code C de la fonction qui crée une structure fifo, alloue le tableau et initialise les autres champ la 2 ème fonction int fifoAjouter(fifo file,int *element); // retourne 1 si Ok, 0 si la file est pleine

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

typedef struct {
int **tab;
int tailleMax;
int tete;
int taille;
} fifo;

fifo *fifoCreer(int tailleMax){

fifo *file=malloc(sizeof(fifo)); // on creer un tableau de sctruture
int **tab=malloc(tailleMax*sizeof(int *));
int i;
    for(i=0;i<tailleMax;i++){
        tab[i]=malloc(tailleMax*sizeof(int));}

file->tete=0;
file->taille=0;
return file;}

int fifoAjouter(fifo *file,int *element){
 if(file->tailleMax==file->taille){
    return 0;}
    else {
        return 1;}
}

int main(){

fifo *file;
fifoCreer(100);
fifoAjouter(&file,&44);
return 0;}
+0 -0

Tu peux nous en dire plus sur ce qui te bloque ? Quelle(s) erreur(s) tu rencontres ?
Premier petit indice, ton premier malloc n’est pas bon, tu crées un objet de type pointeur sur fifo, il faut donc faire un malloc de la taille d’un fifo et pas d’un *file. Ensuite on discutera de ton tableau.

+0 -0

J’imagine que tes questions portent sur la fonction fifoAjouter et sur le cas où il y a de la place pour ajouter le nouvel élément ? Mais quelles sont-elles ?

Premier petit indice, ton premier malloc n’est pas bon, tu crées un objet de type pointeur sur fifo, il faut donc faire un malloc de la taille d’un fifo et pas d’un *file.

backmachine

Quelle différence ? *file est de type fifo.

Il n’y a pas de tableau de structures. file est de type fifo* car c’est un pointeur sur une valeur de type fifo, mais ça n’en fait pas un tableau. D’ailleurs le malloc ne prévoit la taille que d’une structure fifo.
À la limite tu peux voir cela comme un tableau d’un seul élément, mais c’est tout.

Par contre tab (de type int**) dans ta structure est utilisé comme un tableau dynamique de tailleMax éléments (voir le malloc).

Mais je ne comprends pas pourquoi tu alloues un tableau d'int* plutôt qu’un tableau d'int. C’est l’interface imposée ?

Salut,

Je vois trois problèmes de prime abord :

  1. Comme l’a souligné @entwanne, la ligne fifo *file = malloc(sizeof(fifo)) alloue une struture fifo et non plusieurs ;
  2. La ligne fifoAjouter(&file, &44) est incorrecte, les constantes entières n’ayant pas d’adresses (en tous les cas en C) ;
  3. Lors de l’appel à fifoAjouter() tu passes l’adresse de ta variable file en argument. Or, cette dernière est un pointeur sur structure fifo, la fonction fifoAjouter() reçoit donc un pointeur de pointeur sur structure fifo et non un pointeur sur structure fifo.

Sinon, essaye de mieux mettre en forme tes messages, tu mélanges les citations avec tes réponses. :)

+1 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte