structure en parametre de fonction

Version imprimable

Bonjour je pense avoir quelques problemes avec les structures
Code:

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:

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

14/03/2007, 10h50
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)

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

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
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

Citation:

Envoyé par sone47

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:

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:

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:

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:

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

Citation:
Envoyé par sone47
Bonjour je pense avoir quelques problemes avec les structures
Code:

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:

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:

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; }

ok merci donc

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
 
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

14/03/2007, 10h55
fearyourself

Citation:

Envoyé par salseropom

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 8O

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

Jc
14/03/2007, 10h58
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:

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

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:

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:

1 2 equa1.y = 0 equa2.y = 11
Si tu utilise des pointeurs (variable en entrée sortie), alors :
Code:

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:

1 2 equa1.y = 11 equa2->y = 11
Ce qui surement plus ce que tu recherches.

Code:

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"

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

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.

salut, avec un typedef tu fais

Code:

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

sans typedef tu fais

Code:

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

14/03/2007, 12h28
salseropom

Citation:

Envoyé par fearyourself

Wow, un malloc pour un exemple aussi simple 8O

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

Jc

oui...:marteau:

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:

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:

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

14/03/2007, 13h35
Médinoc

Le typedef de structure devrait être dans func.h...
14/03/2007, 13h41
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:

1 2 parameters * equap=&equa1;
'parameters' : illegal use of this type as an expression
14/03/2007, 13h46
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
14/03/2007, 13h51
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)

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:

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:

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; }

14/03/2007, 13h58
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)
14/03/2007, 14h08
sone47
d'acord merci beaucoup.
J'ai un dernier probleme pour assigné des valeurs dans la fonctions:
Code:

1 2 3 4 5 6 void Calcul(s_equap) { ... s_equap->a[0]=x; /*erreur: left of '->a' must point to struct/union */ }
puis apres j'ai mis

Code:

*(s_equap)->a[0]=x;

pour specifier le a[0] de ce que pointe s_equap
mais meme erreur.

C'est le même problème, passe un pointeur comme argument...:marteau:
Code:

1 2 3 4 5 6 void Calcul(s_equap* pEquap) { ... pEquap->a[0]=x; /*erreur: left of '->a' must point to struct/union */ }

oui c'sest bien un pointeur;

Code:

1
2
3
4
5
6
7
8
 
/*var.h*/
typedef struct {
			   float a[N];
			   float b[N];
}parameters;
extern parameters s_equa1;
extern parameters * s_equap;

Code:

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

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
/*main*/
#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"
{
  s_equa1.a[0]=0;
  s_equa1.b[0]=0;	
  s_equap=&s_equa1;						
  Calcul(s_equap);

Code:

1
2
3
4
5
6
7
 
/*func.c*/
void CalculCoeffs(s_equap)
{
  ...
  s_equap->a[0]=x;
}

14/03/2007, 14h23
DaffyDuck
Dans ce cas faudrait peut être donner un type à ta variable passée en paramètre...
Autre chose, ne donne pas de nom de variables globales aux variables locales.
s_equap est une variable globale.
Code:

1 2 3 4 5 6 void CalculCoeffs(parametres* pDest) { ... pDest->a[0]=x; }
14/03/2007, 14h35
sone47

Ca a marché mais cela m'a perdu.
Ma structure est "parameters" donc j'ai une structure de type parameters

Je créé une structure "s_equap" donc:
nom -> "s_equa"
type -> "parameters"

Je créé un pointeur vers structure (peut on dire vers "parameters"?)
nom -> "s_equap"
type -> "pointeur vers 'parameters' "

dans une fonction sans struct:
void calcul(float * p)

ici
void calcul(parameters * s_equap)

donc en fait il manquait de spécifié le type est ce bon?

ce que je comprend mal c'est en suivant la hierarchie:

structure->parameters->equa
" * -> equap

equa est quoi, une structure de type parametre un parametre de type strucure?
14/03/2007, 15h19
DaffyDuck

C'est en fait que tout est mélangé dans ton programme. Quand je parle de paramètres, c'est de paramètres de fonctions C (ou procédures, mais c'est un autre débat).
tu as créé un type parameters
tu as créé une variable de type parameters (s_equa)
tu as créé un pointeur vers un parameters (s_equap)

Ton GROS problème est que tu passes une variable globale (en l'occurrence s_equap) en paramètre local d'une fonction.
14/03/2007, 15h21
DaffyDuck

Citation:

Envoyé par sone47

void calcul(parameters * s_equap)

donc en fait il manquait de spécifié le type est ce bon?

Oui mais cela ne suffit pas, il faut déclarer ta fonction calcul avec un autre nom de variable en paramètre

par exemple

void calcul(parameters * s_equap_local)
14/03/2007, 15h35
sone47

Oui je viens de remarquer.
Merci beaucoup, c'est du au fait que je declare mes variables dans un autre fichier je n'avais pas fait attention qu'elles étaient en global du coup cela fonctionnait quand meme dans la fonction.
Desormais j'ai changé le nom du parametre de la fonction et dedans je travaille avec cette variable locale.
En tout cas merci elles m'auront bien destructurées le cerveau ces structures!!
14/03/2007, 15h42
sone47

Mais n'y a t il pas une methode pour alleger visuellement le programme car le mien avec les structures est assez lourd alors qu'il n'y en a qu'une, tout ces "s_equap_loc->..." je me demande si en faisant voir mon prog a quelqu'un il va s'y retrouver. Faut il juste prendre l'habitude?
Dans la pratique on utilise des structures jusqu'a un certain nombre de para ou c'est selon le besoin?
14/03/2007, 15h54
souviron34

En général c'est selon le besoin, mais par contre si il y a beaucoup de paramètres, c'est que la conception n'est peut-être pas forcément bien terminée.

Il peut y avoir des structures englobant d'autres structures, afin de mieux cerner les paramètres.

Pour reprendre un exemple courant ici :

Pour un annuaire, on peut définir une structure abonné, avec nom, adresse, numéro, et une structure ville contenant par exemple une carte, et une liste de structures abonnés.
14/03/2007, 16h05
sone47

Oui et je pense qu'avec l'habitude on doit plus facilement se repérer.
En tout cas merci de toute l'aide apportée vraiment.
14/03/2007, 16h05
DaffyDuck
C'est comme partout, c'est selon le besoin. Quant à utiliser des s_equap-> partout, ça ne pose aucun problème de lecture. Ca devient pénible quand tu as des pointeurs vers des structures imbriquées. Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 typedef struct{ float diametre; float largueur; }tRoue; typedef struct{ tRoue* roueAvant; tRoue* roueArrière; tCadre* cadre; }tVelo;
dans ce cas, si tu as une variable monVelo et pMonVelo un pointeur vers monVelo, pour accéder au diamètre de la roue avant, ca donne
pMonVelo->roueAvant->diametre
Suivant ta structure de données, ca peut donner des trucs longs. Ils peuvent cependant être raccourcis avec un petit #define
Là par exemple, si on fait
#define maRoueAvant pMonVelo->roueAvant
tu accèdes à son diamètre en faisant
maRoueAvant->diametre
En fait tu as tout un panel de choix, sans forcément passer par des pointeurs, pour structurer ton code. La première partie du codage (qui est la dernière partie de la conception) consiste justement en le choix de ta structure de donnée.
15/03/2007, 13h24
diogene

Citation:

c'est du au fait que je declare mes variables dans un autre fichier je n'avais pas fait attention qu'elles étaient en global du coup cela fonctionnait quand meme dans la fonction.

Supprime les variables globales! Ce sont des pestes vicieuses qui semble au début simplifier l'écriture d'un programme mais qui te font payer le prix fort à la fin.
15/03/2007, 16h16
Emmanuel Delahaye

Citation:

Envoyé par sone47

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 ?

http://emmanuel-delahaye.developpez....difie_variable
15/03/2007, 17h27
Emmanuel Delahaye
Citation:
Envoyé par sone47

Code:

1 2 3 4 5 typedef struct s_parameters{ float a[N]; float b[N]; } ;

me donne une erreur sur mon pointeur "undeclared identifier"
Il faut réouvrir ton livre de C de temps en temps.

Une structure se définit avec le mot clé struct et un tag :
Code:

1 2 3 4 5 6 struct parameters { float a[N]; float b[N]; };
On peut aussi créer un alias séparé :
Code:

1 2 typedef struct parameters parameters_s;
Enfin, on peut combiner la création de l'alias avec la définition de la structure :
Code:

1 2 3 4 5 6 7 typedef struct parameters { float a[N]; float b[N]; } parameters_s;
Dans ce cas, on peut ommettre le tag qui, ici, n'est pas utile.
Code:

1 2 3 4 5 6 7 typedef struct { float a[N]; float b[N]; } parameters_s;

Fuseau horaire GMT +2. Il est actuellement 02h29.