Discussion :

[gbsatti]

Bonsoir, j'explique mon problème :

j'ai définit une table de voiture comme cela:

typedef struct { float prix; Nat imm; .... } svoiture, *voiture

typedef voiture table_voiture[100];

dans le main() je veux déclarer une table de voiture et l'initialiser à vide:

table_voiture *t1=MALLOC(table_voiture);
t1=tablenouv(); où tablenouv() initialise la table à vide.

jusque la tout est ok.

mais seulement j'ai une fonction (en dehors du main()) qui doit utiliser cette table. Or mon compilateur m'indique que la table t1 n'est pas déclaré, et qu'il faut que je la déclare, ce que je vais. Puis nouvelle erreur, il faut l'initialiser à vide sinon gros bug dans mon programme. Hélas la dite fonction est appelée plusieurs fois et cela a pour effet de re vider le tableau à chaque fois que la fonction est appelée, ce qui ne m'arrange pas puisque la table de voiture doit être mise a jour avec la nouvelle quantité de voitures en stock lors d'un achat..

Quelqu'un a une idée pour déclarer cette table dans le main() et que je puisse l'utiliser dans d'autres fonctions sans la re déclarer ?

Merci d'avance pour votre aide !

[astyan42]

Quand tu fais ton malloc n'oublie pas de caster le résultat: si tu regardes le prototype de malloc tu peux te rendre compte qu'il renvoie un void*

une possible amélioration serait donc:

table_voiture* t1= (table_voiture*)malloc(sizeof(table_voiture));

Ensuite, si tu pouvais montrer ton code ca serait plus pratique pour t'aider =)

[gbsatti]

Merci de bien vouloir m'aider

voila a quoi ressemble mon code :

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 main(void)
 
{
table_voiture *t1=MALLOC(table_voiture); /* ps: j'ai un #define MALLOC(t) ((t *)(malloc(sizeof(t))))*/
 
t1=tabnouv();
Voiture a;
a.categorie="BMW"; /*categorie etant une chaine */
a.prix=1300;
a.quantite=100;
t1=adjt(*t1,1,a) /* j'appel adjonction qui prend une tablevoiture , un indice et une voiture et qui rempli le champ si l'indice n'est pas deja utilisé par une autre voiture */
.
.
.
}

ensuite pour le menu j'ai une fonction traite choix:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
Bool traite_choix2(char c)
{
	if(c=='q') return Faux;
	switch(c)
	{
	case 'a' :
		do
		{	
		print_menu_BMW();
		} while(traite_choix_BMW(getch()));
		break;
 
	default : printf("\ ----> commande non reconnue\n");
	}
	return Vrai; 
}
 
 
 
Bool traite_choix_BMW(char c)
{
	if(c=='q') return Faux;
	switch(c)
	{
	default : printf("\ ----> commande non reconnue\n");
	}
	return Vrai;
}
 
void print_menu_BMW(void)
{
Nat i;
/* c'est ici que je suis censé declarer ma table et l'initialiser */
	for (i=0;i<100;i++)
	{
		if (t1[i]->categorie=="BMW")
		{
		printf(" ref : %d ,produit: %s prix : %f , quantite en stock: %f \n",i,t1[i]->nom,t1[i]->prix,t1[i]->quantite);
		}
	}
 
	puts("\n  q  : quitter");
}

Mon problème est donc que si dans print_menu_BMW() j'initialise ma table de voiture, alors à chaque fois que je vais quitter le menu puis revenir dans ce même menu, j'aurai à chaque fois une nouvelle table..

[astyan42]

ben en fait c'est normal, quand tu appelles ta fonction print_menu, elle ne connait jamais le tableau t1, il faudrait que tu le transmette par argument afin de modifier le pointeur... en gros dans ce que tu fais, ( je comprend pas qu'il n'y ait pas d'erreur ou de warning a la compilation d'ailleurs )
c'est que tu fais un test avec quelque chose qui n'existe pas =)

si j'ai bien compris ton problème est que ton programme ne se remémore pas être déjà passé par la fonction ?

[gbsatti]

j'ai essayer de passer la table de voiture t1 en parametre de la fonction printmenu, mais le compilateur me donne comme erreur "t1 is used without being initialised", en gros je dois obligatoirement lui donner l'instruction t1=tablenouv() pour compiler ...

[gl]

Quand tu fais ton malloc n'oublie pas de caster le résultat: si tu regardes le prototype de malloc tu peux te rendre compte qu'il renvoie un void*

Ce cast n'est pas obligatoire (et même assez décrié). Il y a en C conversion implicite de void* vers n'importe quel type de pointeur.

Code :

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

1
2
3
4
5
6
7
 
void main(void)
 
{
table_voiture *t1=MALLOC(table_voiture); /* ps: j'ai un #define MALLOC(t) ((t *)(malloc(sizeof(t))))*/
 
t1=tabnouv();

Sans aller plus loin, deux remarques :

• Les prototypes normalisés de main() sont int main(void) et int main(int argc, char* argv[]), pas void main(void).
• Le retour de tabnouv() écrase l'adresse obtenue du malloc(). Au mieux tu as une fuite mémoire (n'ayant plus le pointeur, tu ne peux plus libérer cette mémoire) et au pire tu as corruption mémoire.

Sinon, plutôt que de poster un bout ou deux de code, peux tu fournir un exemple minimal mais compilable mettant en évidence le problème. Parce que là, à part faire des suppositions sur le code qui manque, difficile d'aider.

[gbsatti]

je ne peux pas poster mon code ici par peur d’être plagié (on est quand même toute une classe hein..)

mais mon problème est simple, je cherche juste à déclarer une table de voiture t1 "une fois pour toute" afin de pouvoir appeler t1 un peu partout dans mon programme sans avoir à la re déclarer à chaque fois...

merci d'avoir essayé en tout cas

bonne nuit

[astyan42]

oui, c'est ce qu'on essaie de t'expliquer, qu'il y a un problème lors de la déclaration de ton pointeur en fait.
Ensuite, soit tu fais transiter ton pointeur par argument dans tes fonctions et tu n'a plus qu'a agir sur ce pointeur
Ou autre solution, souvent déconseillée, déclarer ton t1 en tant que variable globale.
a la rigueur si tu as peur d'être plagié envoie moi un mp avec le code de ton initialisation, je pourrais peut-être te filer un coup de main =)

[Sve@r]

• Les prototypes normalisés de main() sont int main(void) et int main(int argc, char* argv[]), pas void main(void).

On a aussi int main(int argc, char *argv[], char *envp[]) si on doit récupérer son environnement de travail...

table_voiture *t1=MALLOC(table_voiture);
t1=tablenouv(); où tablenouv() initialise la table à vide.

jusque la tout est ok.

Non. Là déjà ça foire. C'est comme si tu écrivais i=5 puis i=0 en disant "ok, j'ai maintenant i qui vaut 5"

Une fonction qui initialise un contenant doit recevoir l'adresse de ce contenant

Code c :

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

1
2
3
4
5
6
7
8
9
table_voiture *t1=malloc(sizeof(table_voiture));  //le cast est en effet plus qu'inutile, il peut masquer un oubli de prototypage
tablenouv(t1);
 
void tablenouv(table_voiture *pt)
{
     pt->...=...
     pt->...=...
    etc
}

Quand à ma remarque générale, si tu dois écrire un projet, essaye de normaliser tes trucs. Les types pourront être t_qqchose. Les structures pourront être struct s_qqchose. Les noms de variable pourront être en rapport avec leur utilité...

mais mon problème est simple, je cherche juste à déclarer une table de voiture t1 "une fois pour toute" afin de pouvoir appeler t1 un peu partout dans mon programme sans avoir à la re déclarer à chaque fois...

Variable globale. La pire des solutions. Si ton prof est un programmeur qui aime ce métier, il ne va pas du tout apprécier. C'est quand-même pas la mort d'embarquer un pointeur dans une fonction quoi !!!

j'ai définit une table de voiture comme cela:

typedef struct { float prix; Nat imm; .... } svoiture, *voiture

typedef voiture table_voiture[100];

Ouh là, plus je lis ton truc plus je remonte des horreurs. Là c'est le meilleur moyen pour te planter. Tu masques les étoiles, tu masques les tableaux. Donc déjà le malloc de tout à l'heure était totalement inutile vu que la taille est fixée à 100. Et dans 10 jours quand tu utiliseras table_voiture, tu ne sauras plus de quoi il est question. Et ton prof, quand il devra te relire...

Tu peux pas rester simple ???

Code c :

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
typedef struct {
     float prix;
     char immat[9];
     ...
} t_voiture;
 
# define NB_VOITURE 100
 
int main()
{
     t_voiture tableau_voiture[NB_VOITURE];  // Comme ça plus de malloc d'une taille fixe ce qui est totalement crétin
     init_tableau_voiture(tableau_voiture);
}
 
void init_tableau_voiture (t_voiture *tab)
{
     t_voiture *pt;
     int i;
     for (i=0, pt=tab; i < NB_VOITURE; i++, pt++)
     {
          pt->prix=0;
          pt->immat[0]=0;
          ...
     }
}

[gbsatti]

Merci pour vos conseil.
Pour ce qui est du MALLOC, c'est vrai que j'ai été naïf d'allouer de la memoire pour un tableau statique.

J'ai résolu mon problème en embarquant le pointeur de la table dans chaque fonction qui l'utilise ! et j'ai tout déclaré dans le main !

merci donc à Sve@r tes conseil m'ont été très utiles.

bonne journée

[gl]

<HS>

On a aussi int main(int argc, char *argv[], char *envp[]) si on doit récupérer son environnement de travail...

Non, il est certes fréquent (enfin tant qu'on reste dans des environnements classiques) mais pas normalisé.

La norme autorise une implémentation à fournir d'autres formes pour main(), comme celle-ci, par contre on perd en portabilité.

</HS>