Arguments, pointeurs...

Version imprimable

17/12/2003, 18h02
exorus

Arguments, pointeurs...

Voila je suis toujours sur mon programme de gestion d'aeroport pour ceux qui ont pu le voir.

Et j'ai un pb important, je m'explique:

dans main(), j'ai un menu qui appel des fonction.
- la fonctions open(...), celle qui ouvre un fichier texte en prenant des evenements(avion qui decolle qui aterrissent..), cette fonction appel deux autres fonctions, ajout_A(...) et afficher_A(..) ( de meme pour decollage)

Le pb qui se pose c'est que quand je suis dans main mais pointeurs, pa et pd qui pointe sur les liste chaine de tt mes avions aterissage et decollage n'existe pas.

Ils sont creer dans open(), en argument ds ajout_A(..) et ajout_D(..) et afficher_A(..) et afficher_D(..).

Comment pourrais je faire pr appeller ma fonction afficher_A(pa) et afficher_D(pd) dans main?

Solution: je pensais au lieu de creer pa et pd dans open les creer dans main et les passer en arguments a open mais ca me permet bien compliquer, ils vont se ballader de fonctions en fonctions d'abord main, puis open, puis ajout puis afficher, puis revenir dans main pour refaire afficher.

c complexe je ne sais pas si je me suis bien exprimé, posez moi des questions si vs comprenez pas.
17/12/2003, 18h10
hellbilly

Tu les declares dans main et tu les passes en arguments de open comme ca la création des listes reste dans open.

ba ca a pas l'air de marcher, c ca le pb j'ai plein d'erreur.

Voici les prototypes de mes fonctions:

Code:

1
2
3
4
5
6
7
8
 
extern int Ajout_A(int tps, int tps_restant, char id[4+1], vol_A** pa);
extern void afficher_a(vol_A *pa);
 
extern int Ajout_D(int date, char id[4+1], vol_D** pd);
extern void afficher_d(vol_D *pa);
 
extern int Open(char *commande, vol_A** pa, vol_D** pd);

17/12/2003, 18h29
hellbilly

dans le main :
vol_A *pa;
vol_D *pd;

et tu appelles Open(commande, &pa, &pd);

Sinon c'est quoi les erreurs ?
17/12/2003, 19h56
exorus
j'ai essaye mais non ca marche pas,

les erreurs sont dans open.h, open.c, et main.c.

j'en ai bcp sur cette ligne, dans open.h:
Code:

1 2 extern int Open(char *commande, vol_A** pa, vol_D** pd);
j'ai essaye **, * mais rien n'a faire. voila qq unes des erreurs:
syntax error : missing ')' before '*'
'vol_A' : name in formal parameter list illegal
syntax error : identifier 'vol_D'
...

et puis j'en ai dans d'autres fichiers mais yen a 50 donc je vais pas toutes les citer.

mon code

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
		/*	Open.c	*/
 
#include "Open.h"
 
int Open(char *commande, vol_A** pa, vol_D** pd)
{
	int OK=0;
	char file_name[15+1];
	FILE * fichier;
	char ligne_fichier[132+1]; //correspond à pour un temps donnés à maximum 10 evenements
	int tps, date, carbu, coeff, tps_restant;
	char id[4+1];
	char *ptr2;
	char ad;
	int a;
 
 
 
 
 
 
	/* transformation de commande(="open fichier.txt") en file_name (="fichier.txt")*/
 
    char const *ptr1 = strstr (commande, "open"); 
 
 
	ptr1 = strchr (ptr1, ' '); 
 
	while (*ptr1 == ' ') 
	{ 
		ptr1++; 
	} 
	strcpy (file_name, ptr1); 
 
	system("cls");
	printf("\t\t<<<<<<<<<< OPEN >>>>>>>>>>\n\n");
 
 
	/*	ouverture du fichier	*/
 
	fichier = fopen (file_name, "r");
	if (fichier == NULL )
	{
		printf("Le fichier n%cexiste pas\n",39);/* fichier inexistant */
		fichier=fopen(file_name,"w");
		printf("Un fichier vide a %ct%c cr%c%c\n",130,130,130,130);
		fclose(fichier); 
		OK=0;
	}
	else 
	{
		/* fichier existant chargement des donnés*/
 
		printf("Chargement du fichier: %s\n\n", file_name);
 
	   while (fgets (ligne_fichier, sizeof ligne_fichier, fichier) != NULL) 
	   { 
		 /*  traitement de la ligne lue. */ 
 
		   	ptr2= &ligne_fichier[0];
			sscanf(ligne_fichier, "%2d", &tps);
			printf("\nt= %d:", tps);
			ptr2 = strstr (ligne_fichier, " ");
			ptr2++;
 
			do
			{
 
				if (strncmp(ptr2,"D",1)==0)
				{
					sscanf(ptr2,"%c-----%2d%4s", &ad, &date, id);
 
					printf("\t Vol %s dec %c t=%d\n", id, 133, date);
 
					ptr2=ptr2+13;
 
					//appel de fonction ajout decollage
					a=Ajout_D(date, id, &pd);	//?? test valeur
 
 
 
				}
				else if (strncmp(ptr2,"A",1)==0)
				{
					sscanf(ptr2,"%c%3d%2d__%4s", &ad, &carbu, &coeff, id);
 
					printf("\t Vol %s arr carb %d (coeff %d)\n", id, carbu, coeff);
 
					ptr2=ptr2+13;
 
					tps_restant=carbu/coeff;
 
					//appel de fonction ajout d'aterrissage
					a=Ajout_A(tps, tps_restant, id, &pa);	//?? test valeur
 
				}
				else
				{
					ptr2++;
				}
 
			}while (strncmp(ptr2,"\0",1)!=0);
 
 
 
	   }
 
	printf("\n\n");
	OK=1;
	}
	afficher_a(pa);
	printf("\n\n");
	afficher_d(pd);
 
 
 
	return OK;
 
}

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
		/*	Ajout_A.c	*/
 
#include "Ajout_A.h"
 
int Ajout_A(int tps, int tps_restant, char id[4+1], vol_A** pa)
{
 
	vol_A* courant;
	vol_A* prec;
	vol_A* nouv;
 
	int inser=0;
 
	nouv= (vol_A*)malloc(sizeof(vol_A));
 
	strcpy(nouv->id,id);
	nouv->tps=tps;
	nouv->tps_restant=tps_restant;
 
	if ((*pa) == NULL)
	{
		(*pa)=nouv;		
		nouv->suiv=NULL;
	}
	else
	{
		if ((*pa)->tps>tps)
		{
			nouv->suiv=*pa;
			*pa=nouv;
		}
		else
		{
			prec=*pa;
			courant=(*pa)->suiv;
			while ((courant!=0)&&(!inser))
			{
				if (tps<courant->tps)
				{
					inser=1;
					prec->suiv=nouv;
					nouv->suiv=courant;
				}
				else
				{
					prec=courant;
					courant=courant->suiv;
				}
			}
			if(!inser)
			{
				prec->suiv=nouv;
				nouv->suiv=0;
			}
		}
	}
 
	return 0;
}
 
void afficher_a(vol_A *pa)
{
	vol_A *cour;
	cour = pa;
 
	while(cour!=NULL)
	{
		printf("\t Vol %s arr a t=%d pendant %d->", cour->id, cour->tps, cour->tps_restant);
		cour=cour->suiv;
	}
 
	printf("\n");
 
}

17/12/2003, 20h02
gl

Citation:

Envoyé par exorus

j'ai essaye **, * mais rien n'a faire. voila qq unes des erreurs:
syntax error : missing ')' before '*'
'vol_A' : name in formal parameter list illegal
syntax error : identifier 'vol_D'
...

vol_A et vol_D ne sont pas connu a ce moment, met leur definition avant le prototype de la fonction

J'ai plus qu'une vingtaine d'erreur mais bon c'est tjs pas ca?

la fonction open est defini comment? vol_A* pa, vol_A** pa ou vol_A pa?

mes erreurs st pr la pluspart dans open.h
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 /* Open.h */ #ifndef DEF_OPEN #define DEF_OPEN #include <stdio.h> //fichier entête requis pour FILE #include <string.h> //fichier entête requis pour strstr() #include <windows.h> //fichier entête pour system() ici --->extern int Open(char *commande, vol_A* pa, vol_D* pd); #include "Ajout_A.h" #include "Ajout_D.h" #endif
c'est presque les meme que ta l'heure

17/12/2003, 20h25
gl

Citation:

Envoyé par exorus

J'ai plus qu'une vingtaine d'erreur mais bon c'est tjs pas ca?

la fonction open est defini comment? vol_A* pa, vol_A** pa ou vol_A pa?

La fonction Open (entre parenthese le nom n'est pas terrible car elle correspond a une fonction existante en C, a la difference de casse pres, ce n'et pas tres lisible) apelle, si j'ai tout suivi, les fonctions Ajout_D et Ajout_A qui modifie le pointeur, pour que la modification remonte jusqu'au main, il faut donc passer un pointeur sur cette donnee, donc je mettrais vol_A** pa.

Par contre dans les appel de Ajout_D et Ajout_A, il ne faut plus passer &pa et &pd mais pa et pd seulement vu que tu as deja un pointeur sur ton pointeur.
17/12/2003, 20h31
Emmanuel Delahaye
Citation:
Envoyé par exorus

dans open.h:

Code:

1 2 extern int Open(char *commande, vol_A** pa, vol_D** pd);

j'ai essaye **, * mais rien n'a faire. voila qq unes des erreurs:
syntax error : missing ')' before '*'
'vol_A' : name in formal parameter list illegal
syntax error : identifier 'vol_D'
Comment sont définis 'vol_A' et 'vol_D' ?
17/12/2003, 20h41
exorus

pas moyen ca veut tjs pas, ca me gave ce projet....
je simplifie en utilisant juste les atterrissage, ca doit etre pareil pr dec.

dans main.c:

je definis mon pointeur: vol_A* pa= NULL;
la structure vol_A defini en tt premier dans main.h
j'appelle la fonction open(commande, vol_A* pa)

dans open.c:

prototypes open(char *commande, vol_A** pa)
appel ajout(data...., &pa);
appel afficher_a(pa);

dans ajout.c:

prototypes ajout(int data...., vol_A** pa)
prototypes afficher(vol_A* pa);

en esperant tavoir eclairer

voila la definitions de la structure que etait avant dans ajout_A.h:

Code:

1
2
3
4
5
6
7
8
9
typedef struct vol_A vol_A;
struct vol_A
{
	int tps;			//temps où l'avion arrive a l'aeroport en approche = horloge
	int tps_restant;	//nombre de t qui lui reste avant panne d'essence
	char id[4+1];		//numero du vol
	vol_A (*suiv);
 
};

17/12/2003, 20h47
hellbilly

Si tu as Open(?, vol_A **pa) comme prototype et vol_A *pa de déclarer dans le main alors tu appelles Open comme ca : Open(?, &pa)
17/12/2003, 21h02
exorus
bon finallement j'ai plus que 5 warning: qui sont dans open.c

'struct vol_A *' differs in levels of indirection from 'struct vol_A ** '
'afficher_a' : different types for formal and actual parameter 1
'function' : 'struct vol_D *' differs in levels of indirection from 'struct vol_D ** '
warning C4024: 'afficher_d' : different types for formal and actual parameter 1

voila c ca et c'est tjs sur la ligne:
Code:

1 2 3 4 afficher_a(pa); printf("\n\n"); afficher_d(pd);
sachant que le prototypes de cette fonction est:

Code:

extern void afficher_a(vol_A *pa);

J'ai toujours du mal avec ces pointeurs, faire la difference entre **, *, & ,&*... je ne sais jamais lequel mettre c'est toujours plus ou moins au pif
17/12/2003, 21h21
exorus

c bon g tt resolu, il fallait que j'appelle mes fonctions ac (*pa) dans open pr afficher.

mais bon c'est encore fait au pif si qqun avait un bon site ou si on pouvait mexpliquer clairement la difference car je suis perdu ac les pointeurs.

Ca va pr les trucs simples, genre & designe l'adresse d'un pointeurs, * le contenue, mais apres...

Citation:

Envoyé par exorus

dans main.c:

je definis mon pointeur: vol_A* pa= NULL;
la structure vol_A defini en tt premier dans main.h

Alors "main.h" doit être inclus dans "open.h" pour que la définition des structures soit visibles des prototypes de "open.h" qui utilisent ces définitions. Le principe est simple : définir avant d'utiliser.

Citation:

Envoyé par exorus

j'appelle la fonction open(commande, vol_A* pa)

dans open.c:

prototypes open(char *commande, vol_A** pa)
appel ajout(data...., &pa);
appel afficher_a(pa);

dans ajout.c:

prototypes ajout(int data...., vol_A** pa)
prototypes afficher(vol_A* pa);

en esperant tavoir eclairer

Un peu de théorie sur la compilation séparée.

Le principe est de découper le projet en plusieurs fichiers sources. Le but n'est pas de faire des fichiers plus petits (!), mais plutôt d'organiser le code en blocs fonctionnels. C'est le résultat de la phase 2 d'un projet (conception détaillée).

L'exemple le plus simple de découpage repose sur 3 fichiers :

Un fichier de définition (.c)
Un fichier d'interface (.h)
Un fichier d'utilisation (.c)

Admettons que l'on ait une serie de fonctions de traitement, par exemple :
Code:

1 2 3 4 create() delete() add() remove()
autour d'un objet quelconque appelé xxx.

On définit l'objet sous la forme d'une structure (le contenu réel dépend de l'application):
Code:

1 2 3 4 5 typedef struct { int dummy; } xxx_s;
ensuite, on définit les interface des fonctions (prototypes) :
Code:

1 2 3 4 xxx_s *xxx_create(void); int xxx_delete(xxx_s *); int xxx_add(xxx_s *); int xxx_remove(xxx_s *);
Maintenant, on peut écrire le fichier d'interface (dit fichier d'entête). Afin d'en simplifier l'utilisation, on munit ce fichier d'une protection contre les inclusions multiples :
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 #ifndef H_XXX #define H_XXX /* xxx.h */ /* constantes */ /* types */ typedef struct { int dummy; } xxx_s; /* prototypes */ xxx_s *xxx_create(void); void xxx_delete(xxx_s *); int xxx_add(xxx_s *); int xxx_remove(xxx_s *); /* variables */ #endif /* guard */
Ensuite, on peut écrire le fichier de définition. On inclus le fichier d'interface pour bénéficier de la définition de la structure, et en plus pour s'assurer de la cohérence entre le prototype et la définition de la fonction:
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 /* xxx.c */ #include "xxx.h" /* constantes privees */ /* types prives */ /* donnees prives */ /* fonctions privees */ /* fonctions publiques */ xxx_s *xxx_create(void) { } void xxx_delete(xxx_s *this) { } int xxx_add(xxx_s *this) { } int xxx_remove(xxx_s *this) { } /* variables publiques */
Enfin, on peut écrire un fichier d'application (ou de test) qui met en oeuvre les fonctions:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 /* main.c */ #include "xxx.h" int main (void) { xxx_s *p = xxx_create (); if (p != NULL) { int err; err = xxx_add (p); if (!err) { xxx_remove (p); } xxx_delete (p); } return 0; }
Dans le fichier de définition des fonctions, il manque un entete par fonction qui précise:
- Le nom de la fonction
- Le role de la fonction
- Le ou les interfaces d'entrée
- L'interface de sortie
Code:

1 2 3 4 5 6 7 8 9 10 11 /* --------------------------------------------------------------------- xxx_create() --------------------------------------------------------------------- creation d'un objet xxx --------------------------------------------------------------------- I: O: adresse de l'objet cree ou NULL en cas d'erreur --------------------------------------------------------------------- */ xxx_s *xxx_create(void) { }
Ceci constitue le squelette de tout module. On remarque l'absence d'accentuées afin d'éviter les problèmes de compatibilité entre les différents éditeurs ou systèmes. Dans le même esprit, je n'utilise pas de tabulations, mais 3 espaces. D'autre part, j'utilise aussi un indenteur (GNUIndent 1.9.1) pour garantir une présentation homogène à mon code.