probleme de pointeur de pointeur et liste chainée

Version imprimable

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:

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:

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... :lol:

merci

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

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.

20/03/2007, 22h43
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.
20/03/2007, 22h56
mchk0123
Citation:

Envoyé par iznogoud36

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:

1 2 //ici un pointeur de pointeur d'une structure 'rule' que g créé plus haut
C'est vachement vague ...
20/03/2007, 23h46
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 ?

voici mon code test pour créer une regle

Code:

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:

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:

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:

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

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

Je reprend ton code :
Code:

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:

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

27/03/2007, 11h16
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é... :mouarf:

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?
27/03/2007, 12h10
souviron34

Citation:

Envoyé par iznogoud36

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.

Citation:

Envoyé par iznogoud36

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

Quand tu n"en a plus besoin :P

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

Code:

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:

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:

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

merci de ta patience

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

1) voici le code pour créer une regle

Code:

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:

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:

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:

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:

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

6) la fonction queue_createFromDB :

Code:

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:

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:

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

Pour simplifier un peu :

Code:

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

Citation:

Envoyé par mchk0123

Pour simplifier un peu :

Code:

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 ?? :aie:

28/03/2007, 01h22
souviron34

Citation:

Envoyé par souviron34

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

désolé :oops: :oops: c'est moi qui étais proche du dodo....
28/03/2007, 15h57
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
:lahola::lahola:

bonne journée
28/03/2007, 16h00
souviron34

Citation:

Envoyé par iznogoud36

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

??????

il y est..... 8O

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:

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?:roll:

29/03/2007, 16h44
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:

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...
29/03/2007, 20h40
mchk0123

Remarque pertinente. Effectivement pourquoi des pointeurs sur des int ?

Citation:

Envoyé par souviron34

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à.