Discussion :

[sone47]

Bonjour je pense avoir quelques problemes avec les structures

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
 
typedef struct {
	   float a;
	   float b;
	   float x;
	   float y;
} s_parameters;
int main ()
{
  s_parameters equa1;
  equa1.a=8;
  equa1.b=7;
  equa1.x=4;
  calcul(equa1);
  return 0;
}

Code :

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

1
2
3
4
5
6
 
s_parameters calcul(s_parameters equa)
{
  equa.y=equa.x+equa.b;
  return equa;
}

en fait je me perd dans le nom de ma structure si j'utilise typedef, que dois je passer en parametre que dois retourner ma fonction comment dois je affecter les valeurs dans ma fonction?
Est t il mieux de passer une structure ou un pointeur de structure ?
Merci davance

[josse95]

Pour répondre à une de tes questions, il vaut mieux passer l'adresse de ta structure en paramètres que la structure elle-même.

Pour deux raisons:
- même si ce n'est plus trop un problème sur la plupart des systèmes, le passage de la structure en tant que paramètre consomme de la pile. C'est donc plus gourmand en mémoire et moins rapide à l'exécution.
- passer l'adresse de ta structure te permet de modifier la structure d'origine (et non une copie de celle-ci)

[Thierry Chappuis]

Le plus efficace est de passer un pointeur sur ta structure à ta fonction. Ainsi, il vient:

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
typedef struct {
	   float a;
	   float b;
	   float x;
	   float y;
} s_parameters;
 
int calcul(s_parameters *p_equa)
{
  int err = 0;
  if (p_equa != NULL)
  {
    p_equa->y=p_equa->x + p_equa->b;
  }
  else
  {
    err = -1;
  }
  return err;
}
 
int main (void)
{
  s_parameters equa1 = {8, 7, 4};
 
  calcul(&equa1);
  return 0;
}

Thierry

[fearyourself]

en fait je me perd dans le nom de ma structure si j'utilise typedef, que dois je passer en parametre que dois retourner ma fonction comment dois je affecter les valeurs dans ma fonction?

Lorsque tu utilises un typedef comme ceci :

Code :

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

1
2
3
4
5
6
7
 
typedef struct {
	   float a;
	   float b;
	   float x;
	   float y;
} s_parameters;

Tu peux déclarer une variable comme ceci :

Code :

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

1
2
3
 
s_parameters blabla; /* Une variable de type s_parameters */
s_parameters *p_blabla; /* Un pointeur vers une structure s_parameters */

Ensuite l'accés aux éléments dépend si c'est un pointeur ou non...

Code :

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

1
2
3
4
 
blabla.x = 5; /* On utilise le . */
p_blabla = &blabla; /* p_blabla pointe sur blabla maintenant */
p_blabla->y = 4; /* On utilise la -> parce que c'est un pointeur */

Pour une fonction, il vaut mieux passer par pointeur, car passer la structure résulte en une recopie inutile. L'utilisation du mot clé const peut permettre d'assurer que la fonction ne modifiera pas la structure si cela est nécessaire ou simplement voulu.

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
 
int main ()
{
  s_parameters equa1;
  equa1.a=8;
  equa1.b=7;
  equa1.x=4;
  calcul(&equa1);
  return 0;
}
 
void calcul(s_parameters *equa)
{
  if(equa != NULL) {
    equa->y=equa->x+equa->b;
  }
}

Remarque que dans ton code, tu devais récupérer le retour de la fonction calcul pour pouvoir avoir le résultat du calcul... Le fait de passer la structure sans passé par un pointeur provoque une copie superficielle de la structure.

Donc au retour de la fonction, ta structure de départ n'est pas modifié.

Jc

[salseropom]

Bonjour je pense avoir quelques problemes avec les structures

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
 
typedef struct {
	   float a;
	   float b;
	   float x;
	   float y;
} s_parameters;
int main ()
{
  s_parameters equa1;
  equa1.a=8;
  equa1.b=7;
  equa1.x=4;
  calcul(equa1);
  return 0;
}

Code :

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

1
2
3
4
5
6
 
s_parameters calcul(s_parameters equa)
{
  equa.y=equa.x+equa.b;
  return equa;
}

en fait je me perd dans le nom de ma structure si j'utilise typedef, que dois je passer en parametre que dois retourner ma fonction comment dois je affecter les valeurs dans ma fonction?
Est t il mieux de passer une structure ou un pointeur de structure ?
Merci davance

oui, il faut toujours passer en argument non pas une structure mais un pointeur vers cette structure. Si tu passes une structure, tu la recopies et c'est long. Si tu passes un pointeur, tu ne recopies qu'un pointeur

Ton code deviendrait :

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
 
typedef struct {
	   float a;
	   float b;
	   float x;
	   float y;
} s_parameters;
int main (void)
{
  s_parameters * equa1=malloc(sizeof(*equa1));
  if(equa1==NULL)
  {
   fprintf(stderr,"Erreur\n");
   exit(EXIT_FAILURE);
  }
  equa1->a=8;
  equa1->b=7;
  equa1->x=4;
  calcul(equa1);
  free(equa1); equa1=NULL;
  return 0;
}
 
void calcul(s_parameters * equa)
{
  equa->y=equa->x+equa->b;
}

[sone47]

ok merci donc

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
 
typedef struct {
	   float a;
	   float b;
	   float x;
	   float y;
} s_parameters;
int main ()
{
  s_parameters equa1;
  equa1.a=8;
  equa1.b=7;
  equa1.x=4;
  s_parameters *p_equa;
  p_equa = &equa1;
  calcul(p_equa);
  return 0;
}Code :
 
s_parameters *  calcul(s_parameters * equa)
{
  equa->y=equa->x+equa->b;
  return equa;
}

comme ceci?
ps: je ne conmprend les erreurs de nom de parametre du premier prog si quelqu'un peut m'aider
merci

[fearyourself]

oui, il faut toujours passer en argument non pas une structure mais un pointeur vers cette structure. Si tu passes une structure, tu la recopies et c'est long. Si tu passes un pointeur, tu ne recopies qu'un pointeur

Ton code deviendrait :

Wow, un malloc pour un exemple aussi simple

Tu pouvais juste passer le pointeur vers une structure statique non ?

Jc

[sone47]

ok pas besoin de retourner equa.
merci
par contre comment dois je nommer les variables que je modifie dans ma fonction si a et b sont tableaux?

Code :

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

1
2
3
4
5
6
7
8
 
void calcul(s_parameters * p)
{
  for(i=0;i<MAX;i++)
  {
    p->a[i]=0;
  }
}

[mchk0123]

Dans ton cas, pour décider si on doit utiliser des structures ou
pointeurs de structures, il faut se poser la question de savoir si
ta fonction modifie la variable equa passée en argument.
C'est à dire, est-ce que equa est une variable en entrée/sortie
de ta fonction, ou en entrée seule.

Par exemple si tu utilise les structures (variable en entrée seule) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int main () {
  s_parameters equa1, equa2;
 
  equa1.y=0;
 
  equa1.b=7;
  equa1.x=4;
  equa2 = calcul(equa1);
  printf("equa1.y = %d\n", equa1.y);
  printf("equa2.y = %d\n", equa2.y);
  return 0;
}

affichera :

Code :

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

1
2
equa1.y = 0
equa2.y = 11

Si tu utilise des pointeurs (variable en entrée sortie), alors :

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
s_parameters* calcul(s_parameters *equa) {
  equa->y=equa->x+equa->b;
  return equa;
}
 
int main () {
  s_parameters equa1, *equa2;
 
  equa1.y=0;
 
  equa1.b=7;
  equa1.x=4;
  equa2 = calcul(&equa1);
  printf("equa1.y = %d\n", equa1.y);
  printf("equa2->y = %d\n", equa2->y);
  return 0;
}

affichera :

Code :

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

1
2
equa1.y = 11
equa2->y = 11

Ce qui surement plus ce que tu recherches.

[sone47]

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
 
typedef struct s_parameters{
			 float a[N];
			 float b[N];
			 } ;
 
void main(int argc, char* argv[])
{
  struct s_parameters equa1;
  equa1.a[0]=0;
  equa1.a[1]=0;
  s_parameters * p_equa=malloc(sizeof(*equa1));
  if(p_equa==NULL)
  {
   fprintf(stderr,"Erreur\n");
   exit(EXIT_FAILURE);
  }
}

me donne une erreur sur mon pointeur "undeclared identifier"

[sone47]

Je n'arrive pas a saisir la difference de mettre le typedef

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
 
void calcul(s_parameters_equa);
typedef struct {
			   float a[N];
			   float b[N];
} s_parameters;
void main(int argc, char* argv[])
{
  s_parameters equa1;
  equa1.a[0]=0;
  equa1.b[0]=0;
  s_parameters * p_equa=malloc(sizeof(equa1));
  if(equa1==NULL)
  {
   fprintf(stderr,"Erreur\n");
   exit(EXIT_FAILURE);
   calcul(p_equa);
}

et sans le typedef

Ceci me genere des erreurs a l'allocation memoire et les types de ma fonction calcul ne sont pas reconnu je ne comprend pas comment definir en parametre.

[salseropom]

salut, avec un typedef tu fais

Code :

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

1
2
3
4
5
6
7
 
typedef struct
{
  double a,b;
} Toto;
 
void fun(Toto * toto);

sans typedef tu fais

Code :

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

1
2
3
4
5
6
7
 
struct Toto
{
  double a,b;
};
 
void fun(struct Toto * toto);

[salseropom]

Wow, un malloc pour un exemple aussi simple

Tu pouvais juste passer le pointeur vers une structure statique non ?

Jc

oui...

[sone47]

merci.
Malgré cette notation le compilateur me fait remarquer des erreurs.
Mon programme se decompose de 5 fichiers.
un main.c un func.c ou je defini la fonction et un var.c ou je defini les variables.
De plus j'ai un var.h et un func.h ou je definie le prototype de la fonction.

Code :

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

1
2
3
 
/* func.h */
extern void Calcul(parameters * equap);

et j'ai des erreurs de syntaxes que je ne trouve pas sur cette ligne

Dans mon 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
 
#ifdef __cplusplus
#error This source file is not C++ but rather C. Please use a C-compiler
#endif
 
#include<stdlib.h>
#include<math.h>      																													
#include "var.h"
#include "func.h"
 
typedef struct {
			   float a[N];
			   float b[N];
}parameters;
 
 
void main(int argc, char* argv[])
{
  parameters equa1;
  equa1.a[0]=0;
  equa1b[0]=0;
  parameters * equap=malloc(sizeof(equa1)); /* ici erreur:'parameters' : illegal use of this type as an expression */
  if(equap==NULL)
  {
   fprintf(stderr,"Erreur\n");
   exit(EXIT_FAILURE);
  }

[Médinoc]

Le typedef de structure devrait être dans func.h...

[sone47]

Cela m'a enlevé des erreurs mais j'ai toujours un probleme dans mon main quand je defini le pointeur sur ma structure:

Code :

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

1
2
 
 parameters * equap=&equa1;

'parameters' : illegal use of this type as an expression

[sone47]

l'erreur était que j'initialisait ma structure avant de definir le pointeur.
du coup je defini ma struc apres mon pointeur et apres j'init ma structure

[sone47]

Du coup une derniere question : étant donné que je defini ma structure dans mon var.h dois je l'inclure en premier dans mes autres fichiers ou l'ordre n'a peu d'importance (car dans mon func.h je defini ma fonction qui prend en parametre le pointeur sur ma struct)

[DaffyDuck]

Si ca ne te dérange pas de modifier ta valeur d'entrée. Dans ce cas equa1 du main sera modifié par la fonction calcul. Quand tu passes un pointeur en paramètre, tu passes l'adresses de la variable. Donc si tu modifies le contenu de l'adresse, tu modifies la variable. Dans notre cas, la fonction calcul(...) ne modifie que le champ y de la structure pointée en paramètre.

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
 
void calcul(s_parameters *equa) {
  equa->y=equa->x+equa->b;
}
 
int main () {
  s_parameters equa1;
 
  equa1.y=0;
  equa1.b=7;
  equa1.x=4;
 
  calcul(&equa1);
  printf("equa1.y = %d\n", equa1.y); // equa1.y = 11
  return 0;
}

Si tu ne veux pas que la variable d'entrée soit modifiée

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
 
void calcul(s_parameters *equaSrc, s_parameters *equaDest) {
  equaDest->y=equaSrc->x+equaSrc->b;
}
 
int main () {
  s_parameters equa1,equa2;
 
  equa1.y=0;
  equa1.b=7;
  equa1.x=4;
 
  calcul(&equa1,&equa2);
  printf("equa1.y = %d\n", equa1.y); // equa1.y = 0
  printf("equa2.y = %d\n", equa2.y); // equa2.y = 11
  return 0;
}

[diogene]

L'ordre est important. Puisque dans func.h, le prototype utilise la structure, celle-ci doit être connue à ce moment là. Donc avant d'inclure funv.h , on doit inclure var.h (ou func.h doit inclure var.h)