Discussion :

[iznogoud36]

bonjour,

j'essaye de gerer une file doublement chainée, j'ai utilisé le code de la chaine dans la FAQ de développez:
http://nicolasj.developpez.com/articles/file/

elle utilise les pointeurs de pointeurs et elle marche tres bien, jusque la tout va bien ...
ensuite je voulu créer une fonction pour ajouter des elements automatiquement à la liste en fonction des resultats d'une base de données et c'est la que ca se complique...
dans mon main() ,j'ai donc

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
queue_s *p_queue = NULL;
 
queue_createFromDB(&p_queue); 
 
queue_print (&p_queue);// affichage de ma file

j'utilise un pointeur de pointeur pour manier la file
voici la fonction que j'ai créer:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
//creer la liste a partir de la BDD
void  queue_createFromDB(queue_s ** pp_queue)
{
queue_s * tmp=NULL;   //creation d'un pointeur de liste temporaire
 
//...connexion BDD + requete+creation d'une struct "rule"...
//pour chaque "rule" créée, faire:
{
       queue_post (&tmp, &p_rule);//ajouter un element a la file , ici un pointeur de pointeur d'une structure 'rule' que g créé plus haut
}
 
queue_print (&tmp);// affichage de ma file
 
*pp_queue =tmp; // je donne l'adresse à mon veritable pointeur de file
}

le probleme c'est quand j'affiche la liste dans la fonction elle apparait bien, mais quand je l'affiche dans mon main() j'ai pas du tout le meme resultat et g des chiffres bizarres qui s'affichent.
je pense avoir un probleme de pointeurs qq part ,j'ai encore des lacunes sur ce sujet, j'en suis bien conscient et j'ai passer plusieurs heures à essayer de comprendre mes erreurs , j'ai essayé plusieurs alternatives mais rien y fait. pourriez vous m'eclairer svp ?

j'espere que j'ai bien expliqué le prob...

merci

[mchk0123]

Essayer de regarder le code à l'intérieur de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
//...connexion BDD + requete+creation d'une struct "rule"...
//pour chaque "rule" créée, faire:
{
       queue_post (&tmp, &p_rule);//ajouter un element a la file , ici un pointeur de pointeur d'une structure 'rule' que g créé plus haut
}

dans la connection au SGBD au niveau de la création/allocation des p_rule.

[iznogoud36]

salut mchk0123

je ne pense pas que ca vienne de là puisque à la fin de ma fonction quand je fais un print de ma file , elle apparait comme je veux, les insertions se sont bien passées mais c'est apres qd je reviens dans le main() que ce n'est plus la meme chose.

[mchk0123]

je ne pense pas que ca vienne de là puisque à la fin de ma fonction quand je fais un print de ma file , elle apparait comme je veux, les insertions se sont bien passées mais c'est apres qd je reviens dans le main() que ce n'est plus la meme chose.

Pour ma part je ne vois que là, en tout cas le code que tu as envoyé m'a l'air bon ... Si tu pouvais mettre le code concernant la déclaration de type de p_rule et toutes les allocations/affectations/utilisation cela m'aiderais, car :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
//ici un pointeur de pointeur d'une structure 'rule' que g créé plus haut

C'est vachement vague ...

[souviron34]

d'abord pourquoi passer par un pointeur intermédiaire ??

tu n'as pas besoin du tmp, tu peux directement passer ton pointeur, puisque ce n'est pas dans cette routine que tu fais l'allocation.

D'autre part, dand ton queue-print, aucun besoin de passer un pointeur de pointeur, puisque tu ne vas pas modifier le pointeur.

Enfin, comme a dit mchk1023, le code à l'intérieur de queue_post risque d'avoir quelque chose qui ne vas pas..

Pas un moyen d'en avoir une version abrégée ?

[iznogoud36]

voici mon code test pour créer une regle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
  rule_s *p_rule = NULL;
  p_rule = rule_new();
  unsigned int test0 = 44;
  unsigned int ruleType = 0;
  rule_create( &p_rule ,&ruleType, &test );

ma fonction pour créer une struct 'rule'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 
//creer une regle de bienvenue
void rule_create (rule_s ** pp_rule,unsigned int *ruleType, unsigned int *user_Id)
{
   if (pp_rule != NULL)
   {
      rule_s *p_p = NULL;
      p_p = malloc (sizeof (*p_p));
      if (p_p != NULL)
      {
         p_p->user_Id = user_Id;
         p_p->ruleType = ruleType;
         *pp_rule = p_p;
 
      }
      else
      {
         fprintf (stderr, "Memoire insuffisante\n");
         exit (EXIT_FAILURE);
      }
   }
   return;
}

et la ma fonction post qui ajoute une 'rule' a la file

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
 
 
//ajouter un element au debut de la file
void queue_post (queue_s ** pp_queue, rule_s ** pp_rule)
{
 
   if (pp_queue != NULL)
   {
      queue_s *p_l = NULL;
      queue_s *p_p = NULL;
 
      queue_first (pp_queue);
      p_l = *pp_queue;
      p_p = malloc (sizeof (*p_p));
      if (p_p != NULL)
      {
         p_p->rule = *pp_rule;
         p_p->next = p_l;
         p_p->prev = NULL;
         if (p_l != NULL)
            p_l->prev = p_p;
         *pp_queue = p_p;
 
      }
      else
      {
         fprintf (stderr, "Memoire insuffisante\n");
         exit (EXIT_FAILURE);
      }
   }
   return;
}

et finalement la fonction print qui affiche la file

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
//imprimer toute la file
void queue_print (queue_s **pp_q)
{
  queue_first (pp_q);
   printf("->|");
 
if (pp_q != NULL && *pp_q != NULL)
    {
 
    while ((*pp_q)->next != NULL)
        {
            printf (" %u |", *(*pp_q)->rule->user_Id);
            queue_next (pp_q);
        }
 
    //dernier element de la file
    printf (" %u |->\n", *(*pp_q)->rule->user_Id);
 
 
    queue_first (pp_q);
 
    }else{
 
        printf("error");
 
    }
   return;
}

merci

[mchk0123]

Mouais, c'est bien ce que je pensais ...

Je reprend ton code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
unsigned int test = 44;
  unsigned int ruleType = 0;

Ces 2 variables test et rulteType n'existe que dans le bloc (stockées dans la piel) ou elles sont définiés car elle ne sont pas allouées avec un malloc (sur le tas).

Donc dés que tu sort du bloc, ces variables n'existent plus alors que tu à sauvé dans tes rule_p un pointeur sur ces variables :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
...
rule_create( &p_rule ,&ruleType, &test );
...
void rule_create (rule_s ** pp_rule,unsigned int *ruleType, unsigned int *user_Id) {
...
         p_p->user_Id = user_Id;
         p_p->ruleType = ruleType;
...
}

Pour bien comprendre les différentes durées de vie des variables, :

Cours magistral, le C par l'exemple

[iznogoud36]

merci du coup de main mhck0123 et souviron

en fait le malloc me faisait un peu peur et je n'osais pas trop l'utiliser car je ne le comprenais pas trop, de plus ca marchait bien sans jusqu'au moment ou j'ai voulu créer des fonctions comme rule_create, maintenant je vois plus son utilité...

je vais creer test et ruleType avec des malloc mais deux questions betes : pourquoi p_rule ne nécessite pas de malloc lors de sa creation?
et à quel moment dois je faire un free de la memoire pour ces malloc?

[souviron34]

pourquoi p_rule ne nécessite pas de malloc lors de sa creation?

Parce que c'est un pointeur, qui est affecté (et la place mémoire allant avec), par ton malloc dans rule_create :

tu fais pp = malloc...

Ensuite tu fait *pp_rule = pp

dans la fonction. Cela affecte le paramètre pp_rule. Comme cette fonction est appelée avec en paramètre &p_rule, c'est donc p_rule que tu viens d'affecter.

et à quel moment dois je faire un free de la memoire pour ces malloc?

Quand tu n"en a plus besoin

[iznogoud36]

voila j'ai suivi tes conseils, j'ai refait ma fonction queue_createFromDB,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
void  queue_createFromDB(queue_s * p_queue){
 
 
        rule_s *p_rule = NULL;
        p_rule = rule_new();
 
        unsigned int *test;
        unsigned int *ruleType;
 
        test =(unsigned int*)malloc(sizeof(unsigned int));
        if (test == NULL) // On vérifie si l'allocation a marché ou pas
        {
            exit(0); // On arrête tout
        }
        *test = 44;
 
 
        ruleType=(unsigned int*)malloc(sizeof(unsigned int));
        if (ruleType == NULL) // On vérifie si l'allocation a marché ou pas
        {
            exit(0); // On arrête tout
        }
        *ruleType = 0;
 
        //creation de la regle
        rule_create( &p_rule ,ruleType, test );
 
 
        //ajouter une regle a la file
        queue_post (&p_queue, &p_rule);
 
        //affichage de la file
        printf("file depart0\n");
        queue_print (&p_queue);
 
    return ;
 
}

je comprends un peu mieux mais j'ai toujours le mm probleme dans mon main quand je fais le print

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 //creation de la file a partir de la BDD
        queue_createFromDB(p_queue);
 
 //affichage de la file
        printf("file depart1\n");
        queue_print (&p_queue);

quand je lance, ca m'affiche:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 file depart0
->| 44 |->
 
file depart1
->|error

merci de ta patience

[souviron34]

Bon, reprenons depuis le début, je crois que tu as sauté des trucs...

1) voici le code pour créer une regle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 rule_s *p_rule = NULL;
  unsigned int test0 = 44;
  unsigned int ruleType = 0;
 
  rule_create( &p_rule , ruleType, test );

2) la routine rule_create :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//creer une regle de bienvenue
void rule_create (rule_s ** pp_rule,unsigned int ruleType, unsigned int user_Id)
{
      rule_s *p_p = NULL;
 
      p_p = malloc (sizeof (rule_s));
      if (p_p != NULL)
      {
         p_p->user_Id = user_Id;
         p_p->ruleType = ruleType;
         *pp_rule = p_p;
      }
      else
      {
         fprintf (stderr, "Memoire insuffisante\n");
         exit (EXIT_FAILURE);
      }
 
   return;
}

3) la fonction queue_post :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//ajouter un element au debut de la file
void queue_post (queue_s ** pp_queue, rule_s *pp_rule)
{
      queue_s *p_p = NULL;
      queue_s *p_l = NULL;
 
   if (*pp_queue != NULL)
   {
      queue_first (pp_queue);
      p_l = *pp_queue;
   }
 
   p_p = malloc (sizeof (queue_s));
   if (p_p != NULL)
      {
         p_p->rule = pp_rule;
         p_p->next = p_l;
         p_p->prev = NULL;
         if (p_l != NULL)
            p_l->prev = p_p;
         *pp_queue = p_p;
      }
      else
      {
         fprintf (stderr, "Memoire insuffisante\n");
         exit (EXIT_FAILURE);
      }
 
   return;
}

4) la fonction queue_first :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void queue_first (queue_s ** pp_queue )
{
      queue_s *p = *pp_queue;
 
      while ( p != NULL )
        {
           *pp_queue =  p ;
             p = p->previous ;
        }
}

5) la fonction queue_next :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void queue_next (queue_s ** pp_queue )
{
      *pp_queue =  (*pp_queue)->next ;
}

6) la fonction queue_createFromDB :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void  queue_createFromDB(queue_s **p_queue){
 
 
        rule_s *p_rule = NULL;
        unsigned int test;
        unsigned int ruleType;
 
        test = 44;
        ruleType = 0;
 
        //creation de la regle
        rule_create( &p_rule ,ruleType, test );
 
 
        //ajouter une regle a la file
        queue_post (p_queue, p_rule);
 
        //affichage de la file
        printf("file depart0\n");
        queue_print (p_queue);
 
    return ;
 
}

7) la fonction queue_print :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//imprimer toute la file
void queue_print (queue_s **pp_q)
{
  queue_first (pp_q);
   printf("->|");
 
   if (*pp_q != NULL)
    {
 
    while ((*pp_q)->next != NULL)
        {
            printf (" %u |", (*pp_q)->rule.user_Id);
            queue_next (pp_q);
        }
 
    //dernier element de la file
    printf (" %u |->\n", (*pp_q)->rule.user_Id);
 
 
    queue_first (pp_q);
 
    }else{
 
        printf( " Erreur : queue vide");
 
    }
   return;
}

et enfin

8) l'appel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
queue_s *p_queue = NULL;
 
queue_createFromDB(&p_queue); 
 
queue_print (&p_queue);// affichage de ma file

[mchk0123]

Pour simplifier un peu :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//ajouter un element au debut de la file
void queue_post (queue_s ** pp_queue, rule_s *pp_rule)
{
      queue_s *p_p = NULL;
      queue_s *p_l = NULL;
 
   // Le code mis en commentaire peut être supprimé
   // if (*pp_queue != NULL) 
   // {
      queue_first (pp_queue);
      p_l = *pp_queue;
   // }
 
...

[souviron34]

Pour simplifier un peu :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//ajouter un element au debut de la file
void queue_post (queue_s ** pp_queue, rule_s *pp_rule)
{
      queue_s *p_p = NULL;
      queue_s *p_l = NULL;
 
   // Le code mis en commentaire peut être supprimé
   // if (*pp_queue != NULL) 
   // {
      queue_first (pp_queue);
      p_l = *pp_queue;
   // }
 
...

t'a oublié quelque chose là ? ou c'était l"heure de dodo ??

[souviron34]

t'a oublié quelque chose là ? ou c'était l"heure de dodo ??

désolé c'est moi qui étais proche du dodo....

[iznogoud36]

ca marche!!

j'ai utilisé ta solution souviron, il manquait juste les malloc dans rule_create pour que ca puisse marcher, mais sinon c'est bon la liste est correctement créée et en plus j'ai compris le probleme

merci a vous deux!! je bosse seul sur ce projet et je n'aurais jamais pu le corriger sans aide


bonne journée

[souviron34]

, il manquait juste les malloc dans rule_create pour que ca puisse marcher

??????

il y est.....

[iznogoud36]

oui pour p_p le malloc y est, mais j'ai constaté que ca ne fonctionne pas si je n'alloue pas de la memoire pour les variables ruleType et user_id
voici mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
void rule_create (rule_s ** pp_rule,unsigned int ruleType, unsigned int user_Id)
{
    unsigned int * temp_ruletype;
    unsigned int * temp_user_Id;
 
   temp_ruletype =(unsigned int*)malloc(sizeof(unsigned int));
        if (temp_ruletype == NULL) // On vérifie si l'allocation a marché ou pas
        {
            exit(0); // On arrête tout
        }
        *temp_ruletype = ruleType;
 
 
        temp_user_Id=(unsigned int*)malloc(sizeof(unsigned int));
        if (temp_user_Id == NULL) // On vérifie si l'allocation a marché ou pas
        {
            exit(0); // On arrête tout
        }
        *temp_user_Id = user_Id;
 
   if (pp_rule != NULL)
   {
      rule_s *p_p = NULL;
      p_p = malloc (sizeof (rule_s));
      if (p_p != NULL)
      {
         p_p->user_Id = temp_user_Id;
         p_p->ruleType = temp_ruletype;
 
         *pp_rule = p_p;
 
 
      }
      else
      {
         fprintf (stderr, "Memoire insuffisante\n");
         exit (EXIT_FAILURE);
      }
   }
   return;
}

non?

[souviron34]

ben je ne comprends pas pourquoi tu utilises des pointeurs, à moins que tu ne nous aies pas tout dit....

Normalement, une règle devrait avoir un type, pourquoi s'embêter la vie avec un pointeur ??

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
typedef struct ma_rule_s {
 
    int user_Id ;
    int rule_type ;
    ......
} rule_s ;

Par contre, si (comme je pense que c'est le cas) il failles que tu stockes une chaîne de caractères, là oui il faudra que tu fasses de l'allocation.

Mais pour stocker 2 entiers, c'est vraiment pas la peine de passer par des pointeurs...

[mchk0123]

Remarque pertinente. Effectivement pourquoi des pointeurs sur des int ?

Par contre, si (comme je pense que c'est le cas) il failles que tu stockes une chaîne de caractères, là oui il faudra que tu fasses de l'allocation.

Et encore ! On n'est même pas obligé.
Comme les données sont extraite d'une DB, il a fort à parier que les champs de type chaînes ont une taille maximum.
Donc faire la même chose en C est naturel dans ce cas là.