maudites soient les erreurs de segmentation

**Andrey** · 11/12/2006, 23h47

bonsoir , j'ai un soucis pour un prog sur le parcours , l'affichage et la création d'un arbre

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
#include <stdio.h>
#include <stdlib.h>
 
 
typedef struct arbre {
       int valeur ; 
       struct arbre * gauche;
       struct arbre * droite;
       }arbre;
 
 
arbre * ajouter(int vale,arbre * r){
 
      if (r!=NULL){
                   r=(arbre *)malloc(sizeof(arbre));
                   r->valeur=vale;
                   r->gauche=NULL;
                   r->droite=NULL;
                   return r;
                   }
 
                   else {
                        if ((r->valeur)==vale){
                        return r;
                                            }
                        else {if (vale<(r->valeur)){
                             (r->gauche)=ajouter(vale,r->gauche);
                             }
                             else { if(vale>(r->valeur)){
                                  (r->droite)=ajouter(vale,r->droite);
                                  }
return r;
}
}}
 
}
 
 
 
 
 
 
void afficher(arbre * r){
     if (r!=NULL ){
                 afficher(r->gauche);
                 printf("%d \n",(r->valeur));
                 afficher(r->droite);
                 }
                 }
 
 
 
int main(){
    //test 
    arbre * chene;
    ajouter(7,chene);
    ajouter(5,chene);
    ajouter(2,chene);
    ajouter(6,chene);
    afficher(chene);
return 0;
}

ca compile , jusque là je suis content

, je tape ./prog sous la console et bammm , segmentation fault

quelq'un voit mon erreur ?

**Emmanuel Delahaye** · 12/12/2006, 00h00

Envoyé par Andrey

voici mon code :

Présentation horrible. C'est si difficile que ça de présenter du code lisible ?

ca compile , jusque là je suis content

Tu te contentes de 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
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums2\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c:54: warning: function declaration isn't a prototype
main.c: In function `ajouter':
main.c:37: warning: control reaches end of non-void function
main.c: In function `main':
main.c:56: warning: 'chene' might be used uninitialized in this function
Linking console executable: C:\dev\forums2\console.exe
Process terminated with status 0 (0 minutes, 4 seconds)
0 errors, 3 warnings

Comportement indéfini

, je tape ./prog sous la console et bammm , segmentation fault

C'est un comportement indéfini comme un autre. Estime toi heureux que ton système réagisse correctement. Sous DOS, c'était souvent le reboot de la machine ... si le secteur de boot du disque n'avait pas été endommagé...

Présentation acceptable (ton code non corrigé) :

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
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct arbre
{
   int valeur;
   struct arbre *gauche;
   struct arbre *droite;
}
arbre;
 
arbre *ajouter (int vale, arbre * r)
{
 
   if (r != NULL)
   {
      r = (arbre *) malloc (sizeof (arbre));
      r->valeur = vale;
      r->gauche = NULL;
      r->droite = NULL;
      return r;
   }
 
   else
   {
      if ((r->valeur) == vale)
      {
         return r;
      }
      else
      {
         if (vale < (r->valeur))
         {
            (r->gauche) = ajouter (vale, r->gauche);
         }
         else
         {
            if (vale > (r->valeur))
            {
               (r->droite) = ajouter (vale, r->droite);
            }
            return r;
         }
      }
   }
 
}
 
void afficher (arbre * r)
{
   if (r != NULL)
   {
      afficher (r->gauche);
      printf ("%d \n", (r->valeur));
      afficher (r->droite);
   }
}
 
int main ()
{
   //test
   arbre *chene;
   ajouter (7, chene);
   ajouter (5, chene);
   ajouter (2, chene);
   ajouter (6, chene);
   afficher (chene);
   return 0;
}

A lire au plus vite de A à Z :

http://emmanuel-delahaye.developpez.com/codage.htm

**Andrey** · 12/12/2006, 00h05

ok merci ...

**Andrey** · 12/12/2006, 00h27

svp , je suis dans le caca , le prof m'a dans le collimateur et si je fais pas bien ce tp, jvais encore prendre cher

**Thierry Chappuis** · 12/12/2006, 01h32

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
#include <stdio.h>
#include <stdlib.h>
 
typedef struct arbre
{
   int valeur;
   struct arbre *gauche;
   struct arbre *droite;
}
arbre;
 
arbre *ajouter (int vale, arbre * r)
{
 
   if (r != NULL)
   {
      r = (arbre *) malloc (sizeof (arbre));
      r->valeur = vale;
      r->gauche = NULL;
      r->droite = NULL;
      return r;
   }
 
   else
   {
      if ((r->valeur) == vale)
      {
         return r;
      }
      else
      {
         if (vale < (r->valeur))
         {
            (r->gauche) = ajouter (vale, r->gauche);
         }
         else
         {
            if (vale > (r->valeur))
            {
               (r->droite) = ajouter (vale, r->droite);
            }
            return r;
         }
      }
   }
 
}
 
 
int main ()
{
   //test
   arbre *chene;
   ajouter (7, chene);
   ajouter (5, chene);
   ajouter (2, chene);
   ajouter (6, chene);
   afficher (chene);
   return 0;
}

Suivons l'exécution de ton code depuis le début de la fonction main (qui n'est soit dit en passant pas sous une forme standard: int main(void)).

Début de la fonction main:
1. Déclaration de la variable chene de type pointeur sur arbre (non initialisée = contient n'importe quoi, mais probablement pas NULL)
2. Appel de la fonction ajouter avec les arguments 7 et chene.
(2.a.0 supposont que chene vaut NULL, r est initialisé à NULL. if ((r->valeur) == vale) déréférence r qui vaut NULL -> erreur de segmentation)
2a. r n'est pas NULL, donc le malloc va s'exécuter (il est conseillé de ne pas utiliser de cast avec malloc et de tester la valeur de retour)
2b. initialisations des champs valeur, gauche et droite de r et retour de la valeur de r (valeur de retour qui n'est d'ailleur pas récupérée dans main, là tu obtiens un trou de mémoire, car tu ne récupères pas l'adresse de ton bloc alloué, la valuer de chene étant passé par copie à la fonction ajouter).
3. Appel de la fonction ajouter avec les arguments 5 et chene. Idem qu'en 2. Lan fonction malloc est appelée, initialisation des champs de la structure de r, l'adresse contenue dans r est retournée par la fonction mais pas récupérée dans main. La valeur de chene est inchangée et contient toujours n'importe quoi. 2ème trou de mémoire observé. etc.
4. Lorsque tu appelles ta fonction afficher avec l'argument chene, cette variable n'a toujours pas été inititialisée et contient n'importe quoi. la fonction afficher essaie de déréférencer r->gauche. Il est fort probable que ce déréférencement entraîne une faute de ségmentation.

La conception de la fonction ajouter est à revoir, car c'est là que se situe principalement l'erreur. Fais de ton mieux et poste une nouvelle version de ajouter.

Thierry

**Andrey** · 12/12/2006, 08h19

déja , y a un erreur , j'ai initialisé ( chene=NULL ) avant d'appeler "ajouter" il n'y a plus la fameuse erreur de segmentation , par contre la procedure afficher ne marche pas

**Andrey** · 12/12/2006, 08h20

et aussi dans la fonction ajouter , c'est pas R!=NULL mais R==NULL qu'il faut mettre

**Thierry Chappuis** · 12/12/2006, 08h37

Envoyé par Andrey

et aussi dans la fonction ajouter , c'est pas R!=NULL mais R==NULL qu'il faut mettre

ça, je le sais, je n'ai fait que suivre l'exécution de ton code. Donc, tu initialises ta variable chene à NULL. Un 1er problème évident qui persiste est donc qu'au 1er appel de ajouter(7, chene), tu initialises. donc r avec NULL. N'oublie pas ici que le passage de NULL se fait par copie. r valant NULL, tu alloues ensuite l'espace mémoire pour une structure arbre avec malloc. Comme je l'ai précisé, il n'est pas conseillé de convertir le retour de malloc avec un opérateur de cast. De plus, on doit toujours vérifier que la valeur de retour de malloc n'est pas NULL. Sinon ton initialisation r->valeur risque déréférencer un pointeur NULL (erreur de segmentation). Si tout se passes bien avec malloc, tu initialises proprement ta structure et tu retournes l'adresse de r. Là tu dois absolument récupérer cette adresse dans main:

Code :

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

chene = ajouter(7, chene)

De cette manière, chene pointera sur l'espace mémoire alloué à l'aide de la fonction malloc. Sinon, moyennant correction de ces quelques détails (initialisation de chene à NULL, r != NULL devient r == NULL dans ajouter, et récupération de la valeur de retour dans main), ton code devrait fonctionner (mais je ne l'ai regarder que d'un oeil).

Thierry

**Lunixinclar** · 12/12/2006, 08h58

Beaucoup de questions sont posées sur les forums par des programeurs qui ne veulent pas débugguer leur programme en mettant des printf() un peu partout pour suivre son exécution et l' état des variables.

**Andrey** · 12/12/2006, 09h06

c'est ce que j'ai fait lunixilar , et apparement je ne rentre pas dans la fonction afficher ...

**Thierry Chappuis** · 12/12/2006, 09h12

Envoyé par Andrey

c'est ce que j'ai fait lunixilar , et apparement je ne rentre pas dans la fonction afficher ...

Comment cela tu ne rentres pas dans la fonction ajouter???

Thierry

**Thierry Chappuis** · 12/12/2006, 09h13

C'est simplement que ta variable chene n'est jamais modifiée, car tu ne récupère pas sa valeur de retour.

Thierry

**koala01** · 13/12/2006, 04h32

Salut,

Déjà, quand on veut créer une fonction récursive, l'idéal, c'est de tester... le cas de base...

Le cas de base, c'est quoi

c'est le cas qui fait que ta fonction renvoie 1 (ou, dans le cas qui nous intéresse, un nouveau noeud)...

C'est à dire qu'il faut réfléchir à ce qui sera le cas de base...

Ce n'est pas le fait que r soit différent de NULL (AKA existe), mais bien le fait qu'il soit égal à NULL (AKA n'existe pas)

Il n'y a que si R n'existe pas... qu'il faut allouer et initialiser un nouveau pointer et le renvoyer...

De plus, il semble intéressant de veiller à ce que, quoi qu'il en soit, la le noeud renvoyé soit le noeud que l'on viendra de rajouter...

La raison en est bien simple: l'allocation peut avoir échoué à pour n'importe quel noeud...

Il est donc intéressant de pouvoir vérifier s'il n'est pas NULL

De plus, le principe du SISE (Single In, single exit: une entrée et une sortie) est relativement intéressant ici, parce qu'il permet d'éviter des tests du genre de "if(r->valeur==valeur)"

Voici donc ce que deviendrait 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
49
50
51
52
53
54
55
56
57
58
 
arbre* Ajouter(int val, arbre* in)
{
    /* nous aurons besoin d'un noeud temporaire, que l'on initialise à NULL */
    arbre *travail=NULL;
    /* le test du cas de base: ici, c'est le fait que le noeud passé en
       parametre vaut NULL*/
    if(in==NULL)
    {
        /* pour le débuggage */
        printf("tentative d'allocation pour le noeud %d",val);
        /* nous sommes sur une feuille de l'arbre, il faut effectuer
             l'allocation dynamique */
         /* nous avons un pointeur de travail, profitons-en ;) */
        travail=malloc(sizeof(arbre));
        /* qui dit allocation dynamique, dit vérification qu'elle s'est bien
            déroulée */
        if(travail!=NULL)
        {
         /* pour le débuggage */
            printf("... ok, on initialise\n");
             /* si c'est le cas, on l'initialise correctement */
             travail->valeur=val;
             travail->gauche=NULL;
             travail->droite=NULL;
        }
         /* pour le débuggage */
         else
         {
              printf("...NOT ok :'(\n",val);
         }
    }
    else
    {
        /* si on n'est pas dans le cas de base, il faut choisir si on veut
           aller à gauche ou à droite */
        if(in->valeur < val)
        {
             /* j'ai dit que l'idéal était de renvoyer le dernier élément
                 alloué on récupère donc l'appel récursif sur notre
                 pointeur de travail*/
             travail= Ajouter(val,in->gauche);
             /* Mais peut etre que le noeud fraichement alloué doit venir
                  juste apres celui sur lequel on se trouve... */
             if(in->gauche==NULL)
                 in->gauche=travail;
        }
        /* Si c'est pas à gauche, c'est peut etre à droite :P */
        if(in->valeur > val)
        {
            travail=Ajouter(val, in->droite);
            if(in->droite==NULL)
                in->droite=travail;
        }
    }
    /* on renvoie le résultat à la fonction appelante */
   return travai;
}

N'oublions pas, que, si on fait des allocations dynamiques, il faut veiller à libérer correctement la mémoire...

Il faut donc penser à faire une fonction de libération... tant qu'à faire, autant qu'elle soit récursive

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
 
void Liberer(arbre *in)
{
    /* il faut d'abord libérer les noeuds enfants ... S'il y en a*/
    if(in->gauche!=NULL)
        Liberer(in->gauche);
    if(in->droite!=NULL)
        Liberer(in->droite);
    /* qu'ils aient valu NULL ou non, maintenant, on peut forcer les enfants
        à NULL (pure habitude) */
    in->gauche=NULL;
    in->droite=NULL;
    /* et on peut libérer notre noeud */
    free(in);
}

Comme j'ai décidé que les valeurs plus petites allaient à gauche, la fonction d'affichage devient

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void Afficher(arbre* in)
{
    /* on ne peut appeler Affiche sur les enfants que s'ils ne valent pas NULL
     */
    /* on affiche d'abord les plus petits (s'il y en a)*/
    if(in->droite!=NULL)
        Afficher(in->droite);
    /* puis celui sur lequel on se trouve */
    printf("%d\n",in->valeur);
    /* et enfin, les plus grands (s'il y en a) */
    if(in->gauche!=NULL)
        Afficher(in->gauche);
}

Maintenant, il ne nous reste plus qu'à créer la fonction main...Sois attentif au fait qu'elle renvoie de toutes manières un entier de réussite ou d'échec

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
 
int main()
{
    /* il nous faut la racine de l'abre... que l'on initialise, comme tous les
       pointeurs, à NULL */
     arbre *chene=NULL;
    /* Comme on récupère le dernier noeud alloué, il vaut mieux le récupérer
      dans un pointeur de travail */
     arbre *travail=NULL;
    /* Création de la racine */
    chene=Ajouter(7,chene);
    /* si ca avait échoué */
    if(chene==NULL)
    {
         printf("Echec de l'allocation de la racine... abandon");
         return EXIT_FAILURE;
    }
    /* insertion des noeuds suivants... avec chaque fois la vérification */
    travail=Ajouter(5,chene);
    if(travail==NULL)
    {
         printf("Echec de l'allocation du noeud... abandon");
         /* N'oubions pas de vider correctement ce qui existe déjà */
         Liberer(chene);
         return EXIT_FAILURE;
    }
    travail=Ajouter(2,chene);
    if(travail==NULL)
    {
         printf("Echec de l'allocation du noeud... abandon");
         /* N'oubions pas de vider correctement ce qui existe déjà */
         Liberer(chene);
         return EXIT_FAILURE;
    }
    travail=Ajouter(6,chene);
    if(travail==NULL)
    {
         printf("Echec de l'allocation du noeud... abandon");
         /* N'oubions pas de vider correctement ce qui existe déjà */
         Liberer(chene);
         return EXIT_FAILURE;
    }
    /* si on arrive ici, c'est que tout s'est bien passé...
        on peut les afficher */
    Afficher(chene);
    /* on n'oublie pas de libérer correctement le tout avant de quitter */
    Liberer(chene);
    /* on renvoie la valeur de réussite */
    return 0; /*aurait pu etre return EXIT_SUCCESS */
}

NOTA: Si tu regardes attentivement le code, il y a plus de lignes de commentaires que de lignes de code à réellement parler...

Si je me suis amusé à les mettre, c'est pour que tu saches à chaque moment le pourquoi du comment de l'instruction qui suit... afin que tu comprenne le principe

Le gros risque de la récursivité est d'entrer dans une fonction dont on ne sortira plus, et le gros risque de l'allocation dynamique, c'est qu'elle peut échouer...

Seule une logique très stricte de vérification et de réflexion est en mesure de te permettre d'aborder ces deux problèmes sereinement...

Le code final est peut etre plus encombrant que ton code de départ, certes, mais il sera beaucoup plus robuste à l'usage

**zooro** · 13/12/2006, 09h22

Envoyé par koala01

Le code final est peut etre plus encombrant que ton code de départ, certes, mais il sera beaucoup plus robuste à l'usage

... A condition de ne pas oublier de vérifier que in n'est pas NULL, avant d'essayer de faire in->valeur (en particulier dans les fonctions Liberer et Afficher).

**Faiche** · 13/12/2006, 10h17

Bon, voila les trucs de bases pour le débug d'un seg fault :

Si tu compiles avec gcc, tu ajoutes l'option -g (pour debug) et une fois le programme compilé, tu le lances avec gdb (gdb ton_programme, puis run) et il te montre exactement la ligne où s'est produit le seg fault, et tu peux regarder quelles sont les valeurs des champs.

De plus sous unix/linux, il est TRES vivement conseillé de linker ton programme avec la bibliothèque Electric Fence et de lancer ton programm avec MALLOC_OPTIONS=J

Enfin, si tu es sous linux, il est de bon ton de passer ton programme dans valgrind histoire d'éviter les fuites de mémoire.

(je t'enjoins a chercher sur le site ou sur google l'explication de tous les outils que tu ne maitrises pas)

Si tu compiles avec visual, normalement lancer le programme en mode debug, ça devrait pas être trop compliqué non plus.

voila voila

**koala01** · 13/12/2006, 10h26

Envoyé par zooro

... A condition de ne pas oublier de vérifier que in n'est pas NULL, avant d'essayer de faire in->valeur (en particulier dans les fonctions Liberer et Afficher).

Tu remarquera que ca a été fait... vu qu'on ne passe dans la récursivité que, justement, si gauche ou droite n'est pas nul

Et ca rentre, justement, dans cette "politique de stricte vérification des pointeurs" dont je parle

**zooro** · 13/12/2006, 11h08

Envoyé par koala01

Tu remarquera que ca a été fait... vu qu'on ne passe dans la récursivité que, justement, si gauche ou droite n'est pas nul

Dans Ajouter, c'est fait, oui.
Mais dans Liberer et Afficher,

Code :

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

1
2
3
4
5
void Liberer(arbre *in)
{
    /* il faut d'abord libérer les noeuds enfants ... S'il y en a*/
    if(in->gauche!=NULL)
...

j'aurais ajouté le test au début des fonctions, juste histoire d'être sûr qu'il n'y aura pas de soucis si j'appelle Liberer sur un arbre NULL...

Code :

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

1
2
3
4
5
6
7
8
void Liberer(arbre *in)
{
    if (in == NULL) 
        return;
 
    /* il faut d'abord libérer les noeuds enfants ... S'il y en a*/
    if(in->gauche!=NULL)
...

**koala01** · 13/12/2006, 11h55

Envoyé par zooro

Dans Ajouter, c'est fait, oui.
Mais dans Liberer et Afficher,

j'aurais ajouté le test au début des fonctions, juste histoire d'être sûr qu'il n'y aura pas de soucis si j'appelle Liberer sur un arbre NULL...

Code :

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

1
2
3
4
5
6
7
8
void Liberer(arbre *in)
{
    if (in == NULL) 
        return;
 
    /* il faut d'abord libérer les noeuds enfants ... S'il y en a*/
    if(in->gauche!=NULL)
...

A vrai dire, ce test n'a, à mon gout, pas sa place dans la fonction Liberer...

Selon moi, la fonction Liberer n'a pas à s'inquiéter de savoir s'il est opportun de travailler ou non...

C'est en amont que cette vérification doit etre faite... Bien sur, on peut en discuter... mais mon avis semble se tenir, non

Par contre, le test aura sa place dans la fonction appelante sous une forme proche de

Code :

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

1
2
3
 
if(chene!=NULL)
    Liberer(chene);

Mais, comme on sort sur une erreur si la création de la racine a échoué dans l'exemple que je donne pour main, il n'y a plus de raison, apres, de vérifier que chene ne soit pas NULL, vu que, si sa création échoue, on ne va de toutes manières pas plus loin...

Ici, les insertions sont codées "en dur", mais, en espérant que l'utilisateur ne sera pas distrait lors de l'encodage (surtout parce que j'ai pas envie de commencer avec fgets

), la fonction main pourrait devenir ceci:

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
 
int main()
{
    /* la racine de l'arbre */
    arbre* chene=NULL;
    /* le noeud de travail temporaire */
    arbre* travail=NULL;
    /* la valeur introduite par l'utilisateur */
    int valeur;
    do
    {
         /*récupération (pas du tout sécurisée ici) des valeurs auprès
            de l'utilisateur */
         printf("veuillez introduire une valeur  (0 pour terminer):");
         scanf("%d",&valeur);
         /* on "zape" l'introduction du 0 (qui est la marque de fin) */
         if(valeur!=0)
            travail=Ajouter(valeur,chene);
         /* l'ajout a foiré */
         if(travail==NULL)
         {
              /* on l'indique à l'utilisateur */
              printf("un problème d'allcoation est survenu... vidange de l'arbre\n");
             /* on teste ICI si on a déjà la racine */
             if(chene!=NULL)
                 Liberer(chene);/* libération correcte de la mémoire */
             return EXIT_FAILURE;/* on sort sur une erreur */
         }
         /* c'est peut etre la racine qu'on vient de rajouter */
         if(chene==NULL)
             chene=travail;
    }while(valeur!=0);
    /* avant affichage, on teste si on a au moins la racine
        "des fois" que l'utilisateur aurait directement introduit 0 */
    if(chene!=NULL)
        Afficher(chene);
    /* et on fait pareil avant la vidange finale (pour la meme raison) */
    if(chene!=NULL)
        Liberer(chene);
    return EXIT_SUCCESS;
}

Au passage, tu remarqueras que j'ai suivi exactement la meme logique pour Afficher...

Elle ne s'occupe que de l'affichage du noeud et de ses enfants, sans s'occuper de savoir s'il est opportun de le faire (y a pas non plus de test if(in==NULL)

)

Mais les remarques faites pour Liberer sont évidemment valables pour Afficher...

**koala01** · 13/12/2006, 12h20

Je vais etre plus précis dans ma déclaration

c'est en amont que cette vérification doit etre faite

Le test de savoir si le noeud actuel existe (et non pas le noeud gauche ou le noeud droite), et en dehors de la fonction Ajouter (qui en a besoin pour travailler correctement, vu que c'est le cas de base) ne sert que dans un seul cas particulier qui est le fait qu'on soit à la racine de l'arbre...

Le fait de vouloir le vérifier directement dans les fonctions Afficher et Libérer va faire que, pour tester un cas particulier qui n'arrivera qu'une seule fois, on effectuera le test sur chaque noeud... avec la perte de temps que cela représente (ce n'est guere plus que quelques fréquence d'horloge processeur, mais quand meme...)

Si, sur une dizaine de noeuds, la perte sera minime... qu'en sera-t-il si on a un arbre équilibré et complet sur 30 ou 40 niveaux

Ce "simple test", ces quelques fréquences d'horloges perdues à chaque fois, se transformeront en de (tres) longues secondes... si pas en minutes, et ce, d'autant plus que le role d'Afficher et de Liberer est... de parcourrir la totalité de l'arbre (ce n'est pas le cas pour Ajouter)

C'est la raison pour laquelle il est largement préférable de le sortir de ces fonctions, et de ne l'exécuter qu'une seule fois en amont: dans la fonction appelante...

**zooro** · 13/12/2006, 22h13

Envoyé par koala01

Je vais etre plus précis dans ma déclaration
(...)
C'est la raison pour laquelle il est largement préférable de le sortir de ces fonctions, et de ne l'exécuter qu'une seule fois en amont: dans la fonction appelante...

Bon, je m'incline devant tes arguments

maudites soient les erreurs de segmentation

C

Discussions similaires

Partager

Partager