Discussion :

[Trunks]

Bonjour,

J'ai une structure node qui se présente ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
typedef struct s_node    t_node;
 
struct                    s_node
{
  int                     value;
	t_node                  *parent;
	int                     nb_children;
	t_node                  **children;
};

Pour ajouter un pointeur à children, je fais :

Code :

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

1
2
3
4
5
t_node *this;
 
this->nbchildren++;
 
children = realloc(children, this->nb_children * sizeof(int *));

Or, ça me fait une erreur de segmentation. Est-ce que quelqu'un peut m'expliquer pourquoi?

Merci

[Trunks]

J'ai fait un exemple plus simple si vous voulez tester :

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
#include <stdlib.h>
#include <stdio.h>
 
int main()
{
  int **pp;
  int i;
 
  pp = malloc(7 * sizeof(int *));
 
  for (i = 0; i < 7; i++)
  {
    pp[i] = malloc(sizeof(int));
    (*pp)[i] = 7 - i;
    printf("(*pp)[%i] : %p\n", i, &(*pp)[i]);
  }
 
  pp = realloc(pp, 8 * sizeof(int *));
  pp[7] = malloc(sizeof(int));
  (*pp)[7] = 7 - i;
 
  for (i = 0; i < 8; i++)
    printf("(*pp)[%i] : %p\n", i, &(*pp)[i]);
 
  printf("\n");
 
  printf("%i\n", sizeof(*pp));
 
  return 0;
}

[Franck.H]

Code un peu revu, j'ai juste compilé et lancé et aucune erreur de segmentation mais je n'est pas testé plus loin. Le mieux est d'utiliser sizeof de la même manière que je l'ai mis.
Par ailleurs, pour realloc, il est préférable d'utiliser un pointeur temporaire, comme ca lorsque la reallocation echoue le pointeur d'origine n'est pas changé, si ca reussi bin plus qu'à mettre à jour ton pointeur en faisant une simple affectation (voir le 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
43
44
45
46
47
48
#include <stdlib.h>
#include <stdio.h>
 
 
int main (void)
{
  int ** pp       = NULL;
  int ** pp_temp  = NULL;
  int    i        = 0;
 
 
  pp = malloc (7 * sizeof (* pp));
 
  for (i = 0; i < 7; i++)
  {
    pp[i] = malloc (sizeof (** pp));
    pp[i] = 7 - i;
    printf("(*pp)[%i] : %p\n", i, &(*pp)[i]);
  }
 
 
  pp_temp = realloc (pp, 8 * sizeof (* pp));
 
  if (! pp_temp)
  {
     /* Liberation de la memoire et fermeture du programme a faire. */
     /* ... */
  }
 
  pp = pp_temp;  /* --- Mise a jour du pointeur apres reallocation --- */
  pp[7] = malloc (sizeof (** pp));
  pp[7] = 7 - i;
 
 
 
  for (i = 0; i < 8; i++)
    printf("(*pp)[%i] : %p\n", i, &(*pp)[i]);
 
 
  printf("\n");
  printf("%i\n", sizeof(*pp));
 
  /*
   * NE PAS OUBLIER LA LIBERATION DE LA MEMOIRE !!
   */
 
  return EXIT_SUCCESS;
}

De plus, n'oublies pas la libération de la mémoire et surtout, n'oublies pas de tester tes retours de malloc etc...

[fearyourself]

C'est quoi ce code???

Est-ce que vous le tester avant de dire qu'il marche?

Ceci, à la limite, je comprends pourquoi on peut passer à côté:

Code :

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

1
2
3
 
pp[i] = malloc(sizeof(int));
(*pp)[i] = 7 - i;

Mais celui là?

Code :

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

1
2
3
 
pp[i] = malloc (sizeof (** pp));
pp[i] = 7 - i;

Cela ne choque personne?

Déjà, où sont les tests du retour de malloc?

Lorsqu'on écrit du code réponse, on doit tout de même faire attention à ce qu'on fait. Je sais que tout le monde se trompe, je serais le premier à le dire (surtout le lundi ) mais les gens vont copier-coller et appliquer ce genre de code...

L'instruction correcte est:

Code :

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

1
2
 
*(pp[i]) = 7 - i;

Jc

[Trunks]

Tu as commis une petite erreur dans le code corrigé, tu as initialisé un pointeur par un int (pp[i] = 7 - i. J'ai corrigé le problème en supprimant les parenthèses (*pp[i] = 7 - i et maintenant ça marche.

Merci pour l'idée du pointeur temporaire, je n'y avais pas pensé.

Code qui fonctionne :

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
#include <stdlib.h>
#include <stdio.h>
 
int main()
{
  int ** pp       = NULL;
  int ** pp_temp  = NULL;
  int    i        = 0;
 
 
  pp = malloc (7 * sizeof (int *));
 
  for (i = 0; i < 7; i++)
  {
    pp[i] = malloc (sizeof (int));
    *pp[i] = i;
    printf("*pp[%i] : %i\n", i, *pp[i]);
  }
 
 
  pp_temp = realloc (pp, 8 * sizeof (** pp));
 
  if (! pp_temp)
  {
     /* Liberation de la memoire et fermeture du programme a faire. */
     /* ... */
  }
 
  pp = pp_temp;
  pp[7] = malloc (sizeof (int));
  *pp[7] = i;
 
 
 
  for (i = 0; i < 8; i++)
    printf("*pp[%i] : %i\n", i, *pp[i]);
 
  /* Libérer la mémoire ... */
 
  return 0;
}

[Trunks]

C'est quoi ce code???

L'instruction correcte est:

Code :

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

1
2
 
*(pp[i]) = 7 - i;

Merci, je l'ai remarqué juste apres

[Franck.H]

Ha oups, c'est vrai j'ai fait une petite boulette, j'ai même pas fait attention à cette erreur ca m'apprendra à corriger un peu trop vite, mille excuses

[Emmanuel Delahaye]

J'ai fait un exemple plus simple si vous voulez tester :

Ah ! Voilà ce qui s'appelle "réduire le code au minimum compilable montrant le probléme". C'est bien.

Pour le code, tu utilises des syntaxes trop complexes et non maitrisées (parenthèses mal placées). Il faut rester simple. D'autre part, il faut vérifier les allocations, utiliser realloc() correctement, libérer...

http://emmanuel-delahaye.developpez....tes.htm#malloc
http://emmanuel-delahaye.developpez....es.htm#realloc

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
#include <stdlib.h>
#include <stdio.h>
 
int main()
{
   int n = 7;
   int **pp = malloc(n * sizeof * pp);
 
   if (pp != NULL)
   {
      /* allocation */
      {
         int i;
         for (i = 0; i < n; i++)
         {
            pp[i] = malloc(sizeof * pp[i]);
         }
      }
 
      /* remplissage */
      {
         int i;
         for (i = 0; i < n; i++)
         {
            *pp[i] = n - i;
         }
      }
 
      /* affichage */
      {
         int i;
         for (i = 0; i < n; i++)
         {
            printf("pp[%d]=%p *pp[%d]=%d\n", i, pp[i], i, *pp[i]);
         }
         printf("\n");
      }
 
      /* tentative d'agrandissement */
      {
         void* tmp = realloc (pp, (n + 1) * sizeof * pp);
 
         if (tmp != NULL)
         {
            /* confirmation */
            n++;
            pp = tmp;
            pp[n - 1] = malloc(sizeof(int));
            *pp[n - 1] = 0;
 
            /* affichage */
            {
               int i;
               for (i = 0; i < n; i++)
               {
                  printf("pp[%d]=%p *pp[%d]=%d\n", i, pp[i], i, *pp[i]);
               }
               printf("\n");
            }
            /* liberation */
            {
               int i;
               for (i = 0; i < n; i++)
               {
                  free (pp[i]), pp[i] = NULL;
               }
            }
         }
      }
      free (pp), pp = NULL;
   }
 
   return 0;
}

Voilà du code prêt à être 'modularisé' en fonctions.

[Trunks]

Merci beaucoup