segmentation fault 11

**exe2bin** · 10/03/2018, 09h51

Bonjour à tous ;
voici 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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include "carte.h"
#include "fonctions.h"
 
/* La première carte de chaque table sert de compteur de carte dans
   la couleur via son élément 'rang' */
struct Carte trefle[14];
struct Carte coeur[14];
struct Carte pique[14];
struct Carte carreau[14];
struct Carte suites[12];
struct Carte groups[12];
struct Carte nulles[12];
struct Carte donne[12]={{0,10,' ',0},{1,7,'P',0},{2,5,'P',0},{3,6,'P',0},{4,7,'C',0},{5,5,'C',0},
    {6,7,'K',0},{7,8,'K',0},{8,10,'K',0},{9,7,'T',0},{10,12,'C',0},{11,0,' ',0}};
struct Carte **brelanCarre[] = {NULL,NULL,NULL};
struct Carte bestHand[12];
 
int defaultBest=500,nbMains;
int totaux[14];// comptabilisation des brelans et carrés
 
int main(void) {
 
    while(1) {
        setMain_1(0);
        return 0;
    }
}
int checkEntry(int r,char c) {
    if((getColor(c))[r].rang == 0) return 0;
    else return 1;
}
void setMain_1(int level) {
    fprintf(stdout,"\nentre dans setMain() ...");
    nouvelleMain(level);
    setGroup(carreau,trefle,coeur,pique);
    setSuite(coeur);
    setSuite(trefle);
    setSuite(carreau);
    setSuite(pique);
    setNulle(coeur,carreau,trefle,pique);
    fprintf(stdout,"\nsort de setMain().");
}
void nouvelleMain(int level) {
  int i;
 
    fprintf(stdout,"\nentre dans nouvelleMain() ...");
    for(i=0;i<12;i++) {
        suites[i].rang=0;suites[i].color=' ';suites[i].used=0;
        if(groups[i].used == level) {//on efface les carte du niveau uniquement
            groups[i].rang=0;
            groups[i].color=' ';
            groups[i].used=0;
        }
        nulles[i].rang=0;nulles[i].color=' ';nulles[i].used=0;
    }
  for(i=1;i<=donne[0].rang;i++) {
    if(((donne+i)->used > 0) && ((donne+i)->used < level)) continue;
    (donne + i)->used = 0;
    rangeCarte(donne+i);
    totaux[(donne+i)->rang] += 1;
  }
    fprintf(stdout,"\nsort de nouvelleMain().");
}
void rangeCarte(struct Carte *c) {
    fprintf(stdout,"\nentre dans rangeCarte() ...");
    assert(c != NULL);
    copy(c,getColor(c->color));
    fprintf(stdout,"\nsort de rangeCarte().");
}
struct Carte * getColor(char c) {
    fprintf(stdout,"\nentre dans getColor() ...");
    switch(c) {
        case 'P' :
        fprintf(stdout,"\nsort de getColor().");
        return pique;
        case 'C' :
        fprintf(stdout,"\nsort de getColor().");
        return coeur;
        case 'K' :
        fprintf(stdout,"\nsort de getColor().");
        return carreau;
        case 'T' :
        fprintf(stdout,"\nsort de getColor().");
        return trefle;
        default :
        fprintf(stderr,"bad color '%c' !!",c);
        exit(EXIT_FAILURE);
    }
}
int evalLowCost(void) {
  int i,valeur=0;
 
  for(i=nulles[0].rang;i>0;i--) {
    if(nulles[i].rang > 9) valeur += 10;
    else valeur += nulles[i].rang;
  }
  return valeur;
}
void setGroup(struct Carte *t1,struct Carte *t2,struct Carte *t3,struct Carte *t4) {
    int i,count=0;
 
    fprintf(stdout,"\nentre dans setGroups() ...");
    for(i=1;i<14;i++) {
        if(totaux[i] == 3) {
            if((t1+i)->rang) {
                //(t1+i)->used = 2;
                totaux[i]--;t1->rang--;
                copyKill(t1+i,groups);
            }
            if((t2+i)->rang) {
                //(t2+i)->used = 2;
                totaux[i]--;t2->rang--;
                copyKill(t2+i,groups);
            }
            if((t3+i)->rang) {
                //(t3+i)->used = 2;
                totaux[i]--;t3->rang--;
                copyKill(t3+i,groups);
            }
            if((t4+i)->rang) {
                //(t4+i)->used = 2;
                totaux[i]--;t4->rang--;
                copyKill(t4+i,groups);
            }
        }
        else if(totaux[i] == 4) {
            assert(count < 2);// Impossible de posséder plus de 2 carrés parmi 10 cartes
            brelanCarre[count] = carreAnalysis(i);
            count++;
        }
    }
    if(count) traiterCarre(0);
    fprintf(stdout,"\nsort de setGroups().");
}

Le programme compile sans erreur.
Le code de setMain_1() s'exécute ainsi que celui de nouvelleMain() ,puis rangeCarte() getColor() et copy() 10 fois ; alors l'exécution sort de
nouvelleMain() comme l'attestent les fprintf() disséminés dans les fonctions. Ensuite, le programme s'arrête et s'affiche un : Segmentation fault: 11
Est ce qu'on peut m'expliquer ce qu'il se passe exactement ...

**jlliagre** · 10/03/2018, 11h59

Il manque les fichiers .h

**exe2bin** · 10/03/2018, 13h33

Envoyé par jlliagre

Il manque les fichiers .h

ok les voici :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#ifndef CARTE_H
#define CARTE_H
struct Carte {
    int place;
    int rang;
    char color;
    int used;
};
#endif

et

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
 
#ifndef fonctions_h
#define fonctions_h
 
void setSuite(struct Carte *);
void setGroup(struct Carte *,struct Carte *,struct Carte *,struct Carte *);
void setNulle(struct Carte *,struct Carte *,struct Carte *,struct Carte *);
void copy(struct Carte *,struct Carte *);
struct Carte **carreAnalysis(int);
struct Carte * getColor(char);
int checkEntry(int,char);
void rangeCarte(struct Carte *);
void setMain_1(int);
void setMain_2(int);
void nouvelleMain(int);
void copyKill(struct Carte *,struct Carte *);
void traiterCarre(int);
void afficheMain(void);
int evalLowCost(void);
 
#endif /* fonctions_h */

**jlliagre** · 10/03/2018, 15h39

Il manque encore beaucoup de code source:

Code :

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

1
2
3
4
5
6
7
8
9
# gcc -Wall a.c
Symbole                 première référence
 non défini                        dans le fichier
copy                                /var/tmp//cc8laEaV.o
copyKill                            /var/tmp//cc8laEaV.o
traiterCarre                        /var/tmp//cc8laEaV.o
setNulle                            /var/tmp//cc8laEaV.o
setSuite                            /var/tmp//cc8laEaV.o
carreAnalysis                       /var/tmp//cc8laEaV.o

**exe2bin** · 10/03/2018, 15h55

Envoyé par jlliagre

Il manque encore beaucoup de code source:

je crois que ce n'est pas important en ce qui concerne le problème ?!

**jlliagre** · 10/03/2018, 20h03

Envoyé par exe2bin

je crois que ce n'est pas important en ce qui concerne le problème ?!

Qu'est-ce qui te fais penser que ça n'a pas d'importance pour identifier le problème ? Tu as des infos que tu n'a pas communiqué ? Tu connais sa cause du SEGFAULT ?

**Sve@r** · 10/03/2018, 17h06

Envoyé par exe2bin

Est ce qu'on peut m'expliquer ce qu'il se passe exactement ...

Bonjour

Tu as un comportement indéterminé. En bref tu as une instruction syntaxiquement correcte (donc ça compile sans erreur) mais qui exécute une action illégale ou impossible. Le plus souvent c'est quand on tape dans un pointé non alloué (on tape alors n'importe où dans la mémoire). Cela produit alors un "comportement indéterminé" donc par définition non prévisible (même si statistiquement on a généralement un gros plantage comme celui que tu as).
Et quand je vois struct Carte **brelanCarre[] = {NULL,NULL,NULL}; (un truc en 3D) je me dis que peut-être c'est de ce côté qu'il faudrait investiguer...

Envoyé par exe2bin

je crois que ce n'est pas important en ce qui concerne le problème ?!

Ben si un peu quand-même. Parce que si on n'arrive pas à compiler, on n'arrivera pas à reproduire le comportement.

**exe2bin** · 11/03/2018, 00h58

Envoyé par Sve@r

Bonjour

Tu as un comportement indéterminé. En bref tu as une instruction syntaxiquement correcte (donc ça compile sans erreur) mais qui exécute une action illégale ou impossible. Le plus souvent c'est quand on tape dans un pointé non alloué (on tape alors n'importe où dans la mémoire). Cela produit alors un "comportement indéterminé" donc par définition non prévisible (même si statistiquement on a généralement un gros plantage comme celui que tu as).
Et quand je vois struct Carte **brelanCarre[] = {NULL,NULL,NULL}; (un truc en 3D) je me dis que peut-être c'est de ce côté qu'il faudrait investiguer...

Ben si un peu quand-même. Parce que si on n'arrive pas à compiler, on n'arrivera pas à reproduire le comportement.

Je suis entièrement d'accord là-dessus mais comment expliquer le comportement que tu décris alors même qu'aucune allocation mémoire n'a
lieu avant le plantage du programme puisque celui-ci n'arrive pas jusqu'à la fonction setGroup() ,fonction qui n'est pas encore celle qui alloue
la mémoire ???

**Sve@r** · 11/03/2018, 09h45

Envoyé par exe2bin

Je suis entièrement d'accord là-dessus mais comment expliquer le comportement que tu décris alors même qu'aucune allocation mémoire n'a
lieu avant le plantage du programme puisque celui-ci n'arrive pas jusqu'à la fonction setGroup() ,fonction qui n'est pas encore celle qui alloue
la mémoire ???

Ce comportement ne se produit pas qu'à l'allocation. Il peut aussi se produire quand par exemple tu as un tableau de n éléments et que tu vas adresser l'élément [-x] (improbable ? Pas forcément si tu utilises un indice signé et que l'incrément le bascule dans la plage des négatifs) ou bien l'élément [x] avec x >= n.

Prenons par exemple cette petite partie de code

Code c :

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

1
2
3
4
5
6
for(i=1;i<=donne[0].rang;i++) {
    if(((donne+i)->used > 0) && ((donne+i)->used < level)) continue;
    (donne + i)->used = 0;
    rangeCarte(donne+i);
    totaux[(donne+i)->rang] += 1;
  }

Tu as un "i" qui va de 1 à "rang" (inclus) et tu l'utilises ensuite comme indice de "donne" (parce que (donne + i)->used ce n'est rien d'autre que donne[i].used en moins lisible et pas plus rapide). Là moi je m'interroge... Un indice de tableau qui commence à 1 ? Qui va jusqu'à une certaine limite mais qui inclus cette limite ??? Ca ressemble fort à un int tab[10]; for (i=1; i <= 10; i++) tab[i]=... typique de l'erreur de débutant et qui conduit au comportement indéterminé.

Je ne dis pas que l'erreur est là (ce n'est pas à moi de vérifier ton code) mais c'est ce genre de cas qu'il faut vérifier.

PS: pourquoi (donne + i)->used n'est pas plus rapide que donne[i].used ? Parce que dans les deux cas l'opération est la même. Certes on dit que passer par un pointeur est plus rapide que passer par un indice... mais c'est à la condition d'avoir un pointeur déjà à la bonne position. Comme par exemple

Code c :

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

1
2
3
4
5
6
for(i=1, pt=donne;i<=donne[0].rang;i++, pt++) {
    if((pt->used > 0) && (pt->used < level)) continue;
    pt->used = 0;
    rangeCarte(pt);
    totaux[pt->rang] += 1;
  }

Là effectivement ça a du sens. Parce que la valeur "donne + i" calculée 5 fois dans ton code n'est calculée qu'une fois dans le mien.

**exe2bin** · 11/03/2018, 13h55

Tout d'abord merci de répondre; tout cela est certain . Au début de la conception je voulais ne faire appel qu'aux tableaux mais l'analyse des carrés
ainsi que des brelans afférent imposant un certains nombre de combinaison ma convaincu d'utiliser la récursivité associée aux pointeurs de pointeurs
de carte ....
Cela dit, dans le cas qui me préoccupe, je vise en premier lieu à faire fonctionner le programme avant d'essayer de le rendre plus performant; en ce
qui concerne la boucle, elle ne peut engendrer d'indice <0 ni même >11 (car c'est la valeur du dernier indice du tableau donne) étant donné que
donne[0].rang = 10 comme tu pourras le constater (codé en dur dans la définition du tableau). I prend effectivement la valeur 1 initiale car l'indice
zéro est réservé au comptage des cartes de la main (10 ou 11).

**jlliagre** · 11/03/2018, 15h17

Plutôt que d'essayer de démontrer qu'il n'y a pas de problèmes dans ton code, envoie les fichiers qui manquent pour que l'on puisse reproduire l'erreur. Ce sera plus productif...

segmentation fault 11

C

Vue hybride

Discussions similaires

Partager

Partager