segmentation fault

Version imprimable

segmentation fault

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:

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

08/11/2005, 12h03
salseropom
Bon je pense que j'ai trouvé l'erreur :

Il faut que je remplace
Code:

1 2 Tableau * t2=NULL;
par
Code:

1 2 Tableau * t2=alloc_Tableau(3,0.0);//NULL;
et la fonction assigne_val devient alors
Code:

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.

Code:

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:

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); ....

Re: segmentation fault

Citation:

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:

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

Re-bonjour, merci de vos réoponses

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

Citation:

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:

1 2 void assigne_val(Tableau * t,double val)
et non
Code:

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:

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:

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

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

Code:

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:

1
2
3
4
 
Tableau vide
 
      5       5       5

en revanche si je fais

Code:

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:

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

08/11/2005, 15h14
Emmanuel Delahaye
Citation:

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:

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()...
08/11/2005, 15h22
salseropom

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