segmentation fault

**salseropom** · 08/11/2005, 11h58

Bonjour, j'ai un segmentation fault, mais je ne vois pas du tout où est l'erreur. Je vous envoie mon programme (4 petites fonctions toutes simples + le main).

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
 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
 
typedef struct t_tab
{
    int dim; // dimension du tableau
    double * data;
} Tableau;
 
Tableau * alloc_Tableau(unsigned int dim_,double val)
{
// alloue un espace memoire pour creer le tableau t et l'initialise a val
    assert(dim_>=0);
 
    Tableau * t=malloc(sizeof(Tableau));
    assert(t!=NULL);
 
    if(dim_==0) // si dim_==0 on considere que le tableau est vide
    {
	t->dim=0;
	t->data=NULL;
    }
    else
    {
	t->dim=dim_;
	t->data=malloc(dim_*sizeof(double));
	assert(t->data!=NULL);
	int i;
	for(i=0;i<dim_;i++)
	    t->data[i]=val;
    }
    return t;
}
 
void free_Tableau(Tableau * t)
{
    t->dim=0;
// libere la memoire
    if(t->data!=NULL)
    {
	free(t->data);
	t->data=NULL;
    }
    free(t);
    t=NULL;
    return ;
}
 
void affiche_Tableau(Tableau * t)
{
    if(t->data==NULL)
	printf("\nTableau vide\n");
    else
    {
	int i;
	for(i=0;i<t->dim;i++)
	    printf("%7.10g\t",t->data[i]);
	printf("\n");
    }
    printf("\n");
    return;
}
 
void assigne_val(Tableau * t,const double val)
{
// met toutes les composantes du tableau à la valeur val
    t=alloc_Tableau(3,0.0);
    int i;
    for(i=0;i<3;i++)
	t->data[i]=val;
 
    return;
}
 
int main()
{
    Tableau * t=alloc_Tableau(3,5);
    affiche_Tableau(t);
    free_Tableau(t); // jusque là j'obtiens bien comme sortie : 5 5 5
 
    Tableau * t2=NULL;
    assigne_val(t2,5); 
    affiche_Tableau(t2); // segmentation fault ici
    free_Tableau(t2);
 
    return 0;
}

si je fais affiche_Tableau(t) dans la fonction assigne_val, le tableau est bien affiché. L'erreur est donc dans le renvoie du tableau t (qui est en fait modifié)

Je suis sûr que l'erreur est toute bête mais je sèche...

Merci

**salseropom** · 08/11/2005, 12h03

Bon je pense que j'ai trouvé l'erreur :

Il faut que je remplace

Code :

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

1
2
 
Tableau * t2=NULL;

par

Code :

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

1
2
 
Tableau * t2=alloc_Tableau(3,0.0);//NULL;

et la fonction assigne_val devient alors

Code :

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

1
2
3
4
5
6
7
8
void assigne_val(Tableau * t,const double val)
{
    int i;
    for(i=0;i<3;i++)
	t->data[i]=val;
 
    return;
}

et là ca marche.

Peut-être qu'il y a plus astucieux.

**diogene** · 08/11/2005, 12h58

Code :

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

1
2
3
4
5
6
7
8
9
10
void assigne_val(Tableau * t,const double val) 
{ 
// met toutes les composantes du tableau à la valeur val 
    t=alloc_Tableau(3,0.0); 
    int i; 
    for(i=0;i<3;i++) 
   t->data[i]=val; 
 
    return; 
}

t est une variable locale, initialisée à l'appel de la fonction et sa valeur est immédiatement écrasée par alloc_Tableau . Cette fonction ne modifie RIEN dans la fonction d'appel et dans tous les cas, pas le t2 de main

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Tableau *  assigne_val(const double val) 
{ 
   Tableau * t=alloc_Tableau(3,0.0); 
    int i; 
    for(i=0;i<3;i++)  t->data[i]=val; 
    return t; 
}
int main()
{
....
    Tableau * t2=assigne_val(5);
....

**Emmanuel Delahaye** · 08/11/2005, 13h39

Envoyé par salseropom

Bonjour, j'ai un segmentation fault, mais je ne vois pas du tout où est l'erreur. Je vous envoie mon programme (4 petites fonctions toutes simples + le main).
<...>
si je fais affiche_Tableau(t) dans la fonction assigne_val, le tableau est bien affiché. L'erreur est donc dans le renvoie du tableau t (qui est en fait modifié)

Je suis sûr que l'erreur est toute bête mais je sèche...

C'est pas mal comme code. Attention, assert() sert à vérifier la conception, pas l'exécution. En mode 'livraison'(NDEBUG défini), assert() n'est pas compilé.

Je ferais comme ça (erreur corrigée, code renforcé).

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
 
#include<stdio.h>
#include<stdlib.h>
 
typedef struct t_tab
{
   /* dimension du tableau */
   size_t dim;
   double *data;
}
Tableau;
 
static Tableau *alloc_Tableau (size_t dim_)
{
/* alloue un espace memoire pour creer
   le tableau t et l'initialise a val */
   Tableau *t = malloc (sizeof *t);
 
   if (t != NULL)
   {
      /* si dim_==0 on considere que le tableau est vide */
      if (dim_ == 0)
      {
         t->dim = 0;
         t->data = NULL;
      }
      else
      {
         t->dim = dim_;
         t->data = malloc (dim_ * sizeof (double));
 
         if (t->data != NULL)
         {
            size_t i;
            for (i = 0; i < dim_; i++)
            {
               t->data[i] = 0;
            }
         }
         else
         {
            free (t), t = NULL;
         }
      }
   }
   return t;
}
 
static void free_Tableau (Tableau * t)
{
   if (t != NULL)
   {
      t->dim = 0;
/* libere la memoire */
      if (t->data != NULL)
      {
         free (t->data);
         t->data = NULL;
      }
      free (t);
   }
}
 
static void affiche_Tableau (Tableau const *t)
{
   if (t != NULL)
   {
      if (t->data == NULL)
      {
         printf ("\nTableau vide\n");
      }
      else
      {
         size_t i;
 
         for (i = 0; i < t->dim; i++)
         {
            printf ("%7.10g\t", t->data[i]);
         }
         printf ("\n");
      }
      printf ("\n");
   }
}
 
static void assigne_val (Tableau * t, const double val)
{
   if (t != NULL)
   {
/* met toutes les composantes du tableau à la valeur val */
      size_t i;
 
      for (i = 0; i < t->dim; i++)
      {
         t->data[i] = val;
      }
   }
}
 
int main (void)
{
   {
      Tableau *t = alloc_Tableau (3);
 
      if (t != NULL)
      {
         affiche_Tableau (t);
         free_Tableau (t);
      }
   }
 
   {
      Tableau *t = alloc_Tableau (4);
 
      if (t != NULL)
      {
         assigne_val (t, 5.0);
         affiche_Tableau (t);
 
         free_Tableau (t);
      }
   }
   return 0;
}

Il est possible de faire mieux selon ces principes :

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

**salseropom** · 08/11/2005, 14h17

Re-bonjour, merci de vos réoponses

J'avoue que je ne comprends pas très bien ce que m'a dit dogene :

t est une variable locale, initialisée à l'appel de la fonction et sa valeur est immédiatement écrasée par alloc_Tableau . Cette fonction ne modifie RIEN dans la fonction d'appel et dans tous les cas, pas le t2 de main

Je croyais pourtant que t allait être modifé car je passe mon argument pas pointeur et non par valeur. J'ai écrit

Code :

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

1
2
 
void assigne_val(Tableau * t,double val)

et non

Code :

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

1
2
 
void assigne_val(Tableau t,double val)

Dans ce précédent cas je comprends tout à fait que t ne soit pas modifié (passage par valeur, si j'ai bien compris)

Emmanuel Delahaye, je comprends votre code. Mais j'ai maintenant une autre question : je ne connais pas d'avance la taille de mon Tableau qui sort de ma fonction assigne_val (dans mon prgm assigne_val correspond à une fonction d'initialisation. L'utilisateur rentre la taille du Tableau et la fonction assigne_val me renvoie un Tableau. j'ai simplifié mon pb, mais si je comprends comment faire sur cet exemple très stupide, je saurais résoudre mon pb qui est dans le même genre).
Donc, comment modifié votre main sans toucher à la fonction assigne_val ?

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
 
static void assigne_val (Tableau * t, const double val)
{
   if (t != NULL)
   {
/* met toutes les composantes du tableau à la valeur val */
      size_t i;
 
ici l'utilisateur rentre la variable dimension
const unsigne short dimension =5; // valeur saisie par l'utilisateur
t=alloc_Tableau(dimension);
 
      for (i = 0; i < dimension; i++)
      {
         t->data[i] = val;
      }
   }
}

Mais dans le main, que dois écrire pour déclarer mon Tableau

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int main()
{
Tableau * t2=??? // dois-je faire un tableau vide ?
assigne_val(t2,5);
affiche_Tableau(t2);
free_Tableau(t2);
 
return 0;
}

J'espère que j'ai été clair.

Merci encore

**salseropom** · 08/11/2005, 14h35

Re, j'ai trouvé ma solution mais je suis incapable de me l'expliquer. Si je fais

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
 
void assigne_val(Tableau * t,const double val)
{
    free(t);
    const unsigned short dimension=3;
    t=alloc_Tableau(dimension,0.0);
    int i;
    for(i=0;i<3;i++)
	t->data[i]=val;
 
    return;
}
 
int main()
{
    Tableau * t2=alloc_Tableau(0,2.0);
    affiche_Tableau(t2);
    assigne_val(t2,5); 
    affiche_Tableau(t2);
    free_Tableau(t2);
 
    return 0;
}

j'obtiens en sortie :

Code :

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

1
2
3
4
 
Tableau vide
 
      5       5       5

en revanche si je fais

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
 
void assigne_val(Tableau * t,const double val)
{
    const unsigned short dimension=3;
    t=alloc_Tableau(dimension,0.0);
    int i;
    for(i=0;i<3;i++)
	t->data[i]=val;
 
    return;
}
 
int main()
{
    Tableau * t2=alloc_Tableau(0,2.0);
    affiche_Tableau(t2);
    assigne_val(t2,5); 
    affiche_Tableau(t2);
    free_Tableau(t2);
 
    return 0;
}

j'obtiens en sortie :

Code :

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

1
2
3
 
Tableau vide
Tableau vide

ce qui veut dire que t2 n'est pas modifié.
Je suis un peu perdu...

Merci de vos réponse en tous cas

**Emmanuel Delahaye** · 08/11/2005, 15h14

Envoyé par salseropom

Mais j'ai maintenant une autre question : je ne connais pas d'avance la taille de mon Tableau qui sort de ma fonction assigne_val (dans mon prgm assigne_val correspond à une fonction d'initialisation.

Ben si. La taille du tableau a été déterminée au moment de sa création par la fonction alloc_Tableau() à laquelle on passe la taille.

Code :

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

1
2
3
4
 
- saisir la taille : fgets() + strtoul()
- appeler la création : alloc_Tableau()
etc.

Je ne vois pas où est le problème. Il est d'usage que chaque fonction ne fasse qu'une action, mais quelle le fasse bien.

C'est ce que j'ai essayé de faire dans mon code.

- La création met le tableau à 0.
- Ensuite, on a une autre fonction qui rempli le tableau avec une valeur déterminée. Plutôt que 'assigne_Tableau() qui est peu clair, on pourrait l'appeler remplis_Tableau()...

**salseropom** · 08/11/2005, 15h22

Re,
je vais mieux lire vos pages web Emmanuel Delahaye. Je comprends un peu mieux mes fautes.
Merci de votre patience.

segmentation fault

C

Discussions similaires

Partager

Partager