Discussion :

[latitude38]

SAlut à tous,

J'utilise depuis plusieurs mois un code en 32 bits, (qui marchait) et en passant en 64 bits, voici que soudainement il me fait des erreurs de segmentation jamais rencontrées.

Le genre d'erreur est celui-ci :

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
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
struct COORD {
  double centre[4];
  double size[4];   
   } ;
  struct All_variables {
        struct COORD *eco;
  };
 
  struct COORD *eco;
  eco = (struct COORD *) malloc((10)*sizeof(struct COORD));
  struct All_variables *E;
 
  E->eco[0].size[1]=0.3;
 
  fprintf(stderr,"ecosize=%e \n", E->eco[0].size[1]);
 
    return 0;
}

J'ai une erreur de segmentation à la ligne 'E->eco[0].size[1]=0.3;' comment appeler ce chiffre ?

Merci de votre aide,

L.

[quetzacoatl]

Bonjour, votre pointeur E n'est pas initialiser, il ne pointe à priori sur rien

[LittleWhite]

Bonjour,

Je suis d'accord avec quetzacoatl, sauf que le pointeur ne pointe pas sur "rien", mais plutot sur n'importe quoi (effectivement, il peut avoir pris n'importe qu'elle valeur, mais surtout pas la bonne). Un pointeur qui pointe sur rien, pour moi, correspond plus à un pointeur qui pointe sur NULL (ce qui fait que le programme serait toujours faux, ...)
Du coup, le programme corriger devrait plus ressembler à ceci (j'ai corriger en passant, une fuite de mémoire):

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
 
struct COORD *eco;
eco = (struct COORD *) malloc((10)*sizeof(struct COORD));
struct All_variables E; // un pointeur sur All_variables, c'est de l'embêtement en plus (et cela demandera un malloc en plus)
E.eco = eco; // On remplit notre E (donc on évite l'erreur de segmentation)
 
  E.eco[0].size[1]=0.3;
 fprintf(stderr,"ecosize=%e \n", E->eco[0].size[1]);
 
// Tutut ! On oublie quelque chose là !
// Et oui, il faut libéré la mémoire que nous avons allouer nous même
free (E.eco);
 
    return 0;
}

[latitude38]

Bonjour et merci Little white,

J'ai repris votre réponse en simplifiant mon pb et voila que cela marche (je garde un pointeur *E et pas E tout court, car ceci est utilisé par tout le programme et je ne peux le changer ):

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
 
#include <stdio.h>
#include <stdlib.h>
 
int main() 
{
struct COORD {
     double centre[4];
     double size[4];
};
struct All_variables {
     struct COORD* eco;
};
 
struct COORD *ECO;
ECO=(struct COORD*)malloc((10)*sizeof(struct COORD));
// **
struct All_variables *E;
 
E->eco=ECO;                           //*
E->eco[0].size[1]=0.3;              //*
 
fprintf(stderr,"ecosize=%e \n",E->eco[0].size[1]);
 
free (E->eco);
 
return 0;
}

Cependant, je n'ai pas vraiment compris ce que tu faisais en faisant E->eco=ECO :
Tu attribue l'adresse de ECO à E->eco c'est ca ? A cause de l'allocation de mémoire ?Mais pourquoi ce n'est pas la même chose d'allouer directement la mémoire à E->eco comme je l'avais écris au début :

Code :

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

1
2
 
E->eco==(struct COORD*)malloc((10)*sizeof(struct COORD));

Autre petite question : pourquoi lorsque je fais la définition et l'allocation de mémoire de 'ECO' après la définition de '*E', j'ai à nouveau une erreur de segmentation ? (lignes //* à la place //**)



Merci encore de toutes ces réponses,

L.

[LittleWhite]

Cependant, je n'ai pas vraiment compris ce que tu faisais en faisant E->eco=ECO :
Tu attribue l'adresse de ECO à E->eco c'est ca ? A cause de l'allocation de mémoire ?Mais pourquoi ce n'est pas la même chose d'allouer directement la mémoire à E->eco comme je l'avais écris au début :

Code :

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

1
2
 
E->eco==(struct COORD*)malloc((10)*sizeof(struct COORD));

Non ce n'est pas ce que vous aviez fait. (Voir votre post au dessus)

[QUOTE=latitude38;5715644]Autre petite question : pourquoi lorsque je fais la définition et l'allocation de mémoire de 'ECO' après la définition de '*E', j'ai à nouveau une erreur de segmentation ? (lignes //* à la place //**)[QUOTE]
Parce que vous avez mis '==' à la place de '=' ici:

Code :

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

1
2
E->eco==(struct COORD*)malloc((10)*sizeof(struct COORD));

Il faut savoir que '==' est un opérateur d'égalité (comparaison pour savoir si deux valeurs sont identique) et non d'affectation.
De plus, votre compilateur remarque ce genre de choses (en affichant des messages d'attention (warnings))

[quetzacoatl]

Encore une fois vous déclarer un pointeur de structure:

struct All_variables *E;

puis, alors que ce pointeur n'est pas initialisé, vous faites comme si il pointait sur une structure:

E->eco=ECO;

le pointeur E ne pointe pas forcément sur une zone mémoire qui est capable de stocker une structure All_variables

Alors si vous avez absolument besoin des pointeurs dans votre programme faites :

Code :

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

1
2
3
struct All_variables *E=malloc(sizeof(struct All_variables));
 
E->eco=ECO;

Si votre pointeur est seulement là pour que les fonctions auxquelles vous le passez modifient la valeur pointée, vous pouvez déclarer une variable de type "struct All_variables" puis passer aux fonctions l'adresse de cet objet avec l'opérateur &

[latitude38]

Bonjour,

désolée des coquilles....
Si je veux coder cela :

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
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
struct COORD {
  double centre[4];
  double size[4];
   } ;
  struct All_variables {
        struct COORD* eco;
  };
  struct All_variables *E;
 
E->eco= (struct COORD *) malloc((10)*sizeof(struct COORD));
 
  E->eco[0].size[1]=0.3;
 
  fprintf(stderr,"ecosize=%e \n", E->eco[0].size[1]);
 
  free (E->eco);
 
    return 0;
}

J'ai une erreur de segmentation sur E->eco= (struct COORD *) malloc((10)*sizeof(struct COORD));

Votre modification LittleWhite, en écrivant

Code :

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

1
2
3
4
  struct COORD *ECO;
  ECO = (struct COORD *) malloc((10)*sizeof(struct COORD));
  struct All_variables *E;
  E->eco=ECO ;

me permet de résoudre cette erreur de segmentation, et ca marche !
Cependant ce que je disait est que je ne comprenais pas pourquoi on pouvait allouer de la mémoire pour ECO et pas pour E->eco, qui sont à priori du même type (pointeur vers une structure).

Je vais maintenant essayer ta solution quetzacoatl :

En codant :

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
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
struct COORD {
  double centre[4];
  double size[4];
   } ;
  struct All_variables {
        struct COORD* eco;
  };
 
struct All_variables *E=malloc(sizeof(struct All_variables));
 
  E->eco[0].size[1]=0.3;
 
  fprintf(stderr,"ecosize=%e \n", E->eco[0].size[1]);
 
  free (E->eco);
 
    return 0;
}

J'ai toujours une erreur de segmentation. Le problème je crois est que dans ce cas je n'alloue nul part de mémoire pour *eco. Il suffirait que je rajoute une alloc pour E->eco :

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
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
struct COORD {
  double centre[4];
  double size[4];
   } ;
  struct All_variables {
        struct COORD* eco;
  };
 
 struct All_variables *E=malloc(sizeof(struct All_variables));
 E->eco = (struct COORD *) malloc((10)*sizeof(struct COORD));
 
  E->eco[0].size[1]=0.3;
 
  fprintf(stderr,"ecosize=%e \n", E->eco[0].size[1]);
 
  free (E->eco);
 
    return 0;
}

La, ca marche !! Et ca semble assez logique et carré.

[LittleWhite]

Je tiens a bien precise, que pour chaque malloc (ou calloc) d'utilise, il lui faut un free() correspondant (sinon fuite de memoire).
C'est aussi pour cela que l'on evitera de passer par des pointeurs (car si on n'utilise pas de pointeur, la memoire est allooue statiquement, et est desalloue par l'ordinateur a la fin du bloc logique (souvent, a l'accolade fermante) (ce qui n'est pas le cas pour les pointeurs))

[latitude38]

Oui,
bien sur je dois libérer la mémoire en fin.

Merci de l'aide.