Programme très court : erreur de segmentation

Version imprimable

Bonsoir,

J'ai une erreur de segmentation dans le programme suivant :

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
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <signal.h>
#include <sys/wait.h>
 
typedef struct scapteur {
  pid_t num;
  unsigned int total;
  unsigned char termine;
} *Capteur;
 
Capteur nouv_capteur(void){
  Capteur c = (Capteur)malloc(sizeof(struct scapteur));
  c->num = getpid();
  c->total = 0;
  c->termine = 0;
  return c;
}
 
int main(int argc, char **argv){
  Capteur *capteurs;
  Capteur c;
  *capteurs = nouv_capteur();
  return EXIT_SUCCESS;
}

Je bloque dessus depuis pas mal de temps, sans savoir d'où vient l'erreur (peut-être suis-je fatigué !)...quelqu'un peut me dire où est l'erreur ?

Merci !

je crois que tu inverses partout pointeur sur la structure et structure..

Moi je ferais :

Code:

1
2
3
4
5
6
 
typedef struct scapteur {
  pid_t num;
  unsigned int total;
  unsigned char termine;
} Capteur;

Puis :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
Capteur *nouv_capteur(void){
  Capteur *c = (Capteur *)malloc(sizeof(struct Capteur));
  if ( c != NULL )
   {
     c->num = getpid();
     c->total = 0;
     c->termine = 0;
   }
  return c;
}

Et enfin :

Code:

1
2
3
4
5
6
7
 
int main(int argc, char **argv){
  Capteur *capteurs=NULL;
 
  capteurs = nouv_capteur();
  return EXIT_SUCCESS;
}

Je dirais meme plus

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void nouv_capteur(Capteur *c){
  if(c == NULL)
  {
     c = malloc(sizeof(struct Capteur));
  }
  if ( c != NULL )
   {
     c->num = getpid();
     c->total = 0;
     c->termine = 0;
   }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
int main(int argc, char **argv){
  Capteur *capteurs=NULL;
 
  nouv_capteur(capteurs);
  if(capteurs != NULL)
  {
     [...]
     free(capteurs), capteurs = NULL;
  }
  return EXIT_SUCCESS;
}

14/05/2007, 10h29
reptils

pour souviron34 ton dernier bloc contient une erreure, nouv_capteur renvoi un pointeur, donc il faut:

Code:

capteurs = nouv_capteur();

(pas de * devant capteur).

Ensuite Skyrunner ton code ne marchera pas !!! tu passes un pointeur que tu veux modifier à l'intérieur d'un e fonction, résultat tu alloues effectivement un capteur mais en sortie de fonction ton pointeur est inchangé. Pour cela il faut passer l'adresse du pointeur.

Citation:

Envoyé par Skyrunner

Je dirais meme plus

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void nouv_capteur(Capteur *c){
  if(c == NULL)
  {
     c = malloc(sizeof(struct Capteur));
  }
  if ( c != NULL )
   {
     c->num = getpid();
     c->total = 0;
     c->termine = 0;
   }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
int main(int argc, char **argv){
  Capteur *capteurs=NULL;
 
  nouv_capteur(capteurs);
  if(capteurs != NULL)
  {
     [...]
     free(capteurs), capteurs = NULL;
  }
  return EXIT_SUCCESS;
}

Ca ne marche pas ça. le test capteurs != NULL ne passera jamais. ;)

Je préconise toujours de laisser à l'utilisateur le choix d'utiliser malloc ou non avec Capteur, en utilisant sous la forme :

Code:

1
2
3
4
5
6
 
Capteur c;
 
capteurInit(&c);
 
capteurDelete(&c); //ce qui en fait ne fera rien puisque ça n'alloue pas de mémoire dans la structure

L'utilisateur pourra également utiliser malloc :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Capteur * c = malloc(sizeof(capteur));
if(c==NULL)
{
 fprintf(stderr, "Bad allocation");
 exit(EXIT_FAILURE);
}
 
capteurInit(c);
 
capteurDelete(c);
 
free(c);

14/05/2007, 10h50
Skyounet

Oupsss désolé erreur de ma part.

Exact il faut passer un pointeur de pointeur.

Citation:

Envoyé par millie

Ca ne marche pas ça. le test capteurs != NULL ne passera jamais. ;)

Là par contre je suis pas d'accord.

Je repost un code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void nouv_capteur(Capteur **c){ if(*c == NULL) { *c = malloc(sizeof(struct Capteur)); } if ( *c != NULL ) { *c->num = getpid(); *c->total = 0; *c->termine = 0; } }

14/05/2007, 11h40
millie

Citation:

Envoyé par Skyrunner

Là par contre je suis pas d'accord.

Je parlais du premier code que tu as envoyé. Pas du deuxième que tu as posté après moi ;)
14/05/2007, 11h40
reptils

perso pour se dispenser de réfléchir à ces histoires de pointeur de pointeur je préconise un renvoi de pointeur comme décrit par souviron34

Code:

Capteur *c=new_capteur();

plus simple et plus sur...

Citation:

Envoyé par Skyrunner

Là par contre je suis pas d'accord.

Je repost un code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void nouv_capteur(Capteur **c){
  if(*c == NULL)
  {
     *c = malloc(sizeof(struct Capteur));
  }
  if ( *c != NULL )
   {
     *c->num = getpid();
     *c->total = 0;
     *c->termine = 0;
   }
}

Je suis d'avis avec millie. Etant donné que beaucoup de programmeur n'initialisent pas leur pointeurs à NULL lors de leur déclaration, ton code risque de crasher.
J'aurais donc fais comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void nouv_capteur(Capteur **c)
{
    *c = malloc(sizeof(struct Capteur));
 
    if ( *c != NULL )
    {
        *c->num = getpid();
        *c->total = 0;
        *c->termine = 0;
    }
    else
    {
        /* Traitement erreur malloc */
    }
}

Mais sinon, je préfère la méthode classique qui est :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
Capteur *nouv_capteur(void)
{
    Capteur *c = malloc(sizeof *c);
 
    if ( c != NULL )
    {
        c->num = getpid();
        c->total = 0;
        c->termine = 0;
    }
 
    return c;
}

14/05/2007, 11h50
Darwiz
Code:

1 2 3 4 5 6 int main(int argc, char **argv){ Capteur *capteurs; Capteur c; *capteurs = nouv_capteur(); return EXIT_SUCCESS; }
Pour répondre directement à ta question ton erreur de segmentation viens de ce morceau de code.

Capteur *capteurs; n'est pas initialisé.

*capteurs = nouv_capteur(); Tu tentes d'accéder à qq chose pointé alors que tu n'as rien initialisé.

Sinon niveau conception voir plus haut ce sera peut être plus approprié. Ajoute un malloc et ça devrait marcher.

Capteur *capteurs = malloc (n*sizeof(Capteur));
14/05/2007, 12h03
Skyounet

@crocodilex

Il est vrai que si le pointeur n'est pas initialisé à NULL bah ça marche pas :aie:.

Bon ok l'autre méthode est mieux :P
14/05/2007, 12h23
souviron34

Citation:

Envoyé par reptils

pour souviron34 ton dernier bloc contient une erreure, nouv_capteur renvoi un pointeur, donc il faut:

Code:

capteurs = nouv_capteur();

(pas de * devant capteur).

Exact désolé :oops: vu l'heure je devais commencer à m'endormir...

J'ai corrigé dans le post..
14/05/2007, 14h37
Emmanuel Delahaye

Citation:

Envoyé par reptils

perso pour se dispenser de réfléchir à ces histoires de pointeur de pointeur je préconise un renvoi de pointeur comme décrit par souviron34

Code:

Capteur *c=new_capteur();

plus simple et plus sur...

+1

Je ne comprends pas qu'on veuille faire autrement...

Citation:
Envoyé par crocodilex
Mais sinon, je préfère la méthode classique qui est :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 Capteur *nouv_capteur(void) { Capteur *c = malloc(sizeof *c); if ( c != NULL ) { c->num = getpid(); c->total = 0; c->termine = 0; } return c; }
Ah, enfin du vrai C simple et clair !

14/05/2007, 14h44
millie
Citation:

Envoyé par Emmanuel Delahaye

Je ne comprends pas qu'on veuille faire autrement...

Je ne sais pas si tu avais lu mon message précédent pù je dirais qu'on pouvait laisser le choix à l'utilisateur de faire un malloc ou non sur une variable de type Capteur en prénant une syntaxe comme ça :
Code:

1 2 3 4 5 6 Capteur c; capteurInit(&c); capteurDelete(&c); //ce qui en fait ne fera rien puisque ça n'alloue pas de mémoire dans la structure
L'utilisateur pourra également utiliser malloc :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 Capteur * c = malloc(sizeof(capteur)); if(c==NULL) { fprintf(stderr, "Bad allocation"); exit(EXIT_FAILURE); } capteurInit(c); capteurDelete(c); free(c);
C'est en général ce que je fais. Ca permet d'utiliser malloc que si on le souhaite (évidemment, dans d'autres structures, capteurInit pourra faire des malloc, mais ça sera caché.
14/05/2007, 14h59
Emmanuel Delahaye
Citation:

Envoyé par millie

C'est en général ce que je fais. Ca permet d'utiliser malloc que si on le souhaite (évidemment, dans d'autres structures, capteurInit pourra faire des malloc, mais ça sera caché.

Dans ce cas, j'ai 2 syntaxes séparées :

statique :

Code:

xxx_init (struct xxx *this);

dynamique :
Code:

1 2 3 struct xxx *xxx_create (void); xxx_delete (struct xxx *this);
Et ca s'utilise comme ça :

statique :
Code:

1 2 3 struct xxx x; xxx_init (&x);
dynamique :
Code:

1 2 3 4 5 6 7 8 9 10 struct xxx *px = xxx_create (); if (px != NULL) { /* ... */ xxx_delate (px), px = NULL; } assert (px == NULL);