Problème de compilation séparée

Version imprimable

Bonjour,
bon voila je commence à m'arracher les cheveux :(

Mon projet de code se compose de 3 fichiers principaux pour l'instant

main.c
cards.c
cards.h

main.c :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <stdio.h> #include <stdlib.h> #include <time.h> #include "cards.h" int main(void) { struct cardgame *newgame ; struct player *newplayer ; Init_Sorted_CardGame(newgame) ; Set_Shuffled_CardGame(newgame) ; Deal_To_Player_Cards(newgame,newplayer,5); system("pause") ; return 0 ; }
Début du cards.h :
Code:

1 2 3 4 5 #ifndef CARDS_H #define CARDS_H ... mes prototypes ... #endif
Début du cards.c :
Code:

1 2 3 4 5 #include <stdio.h> #include <stdlib.h> #include <time.h> #include "cards.h"
Erreur persistante de compilation :
Code:

1 2 3 4 5 6 Linking console executable: D:\blackjack\blackjack.exe .objs\tmp\cards.o:cards.c:(.data+0x0): multiple definition of `ColorTable' .objs\tmp\main.o:main.c:(.data+0x0): first defined here .objs\tmp\cards.o:cards.c:(.data+0x40): multiple definition of `ValueTable' .objs\tmp\main.o:main.c:(.data+0x40): first defined here collect2: ld returned 1 exit status
Je pige vraiment pas.. mon code marchait pourtant bien avant que je rajoute de nouvelles fonctions proprement..

Merci pour l'aide.

14/05/2007, 20h44
Skyounet

Ben là on a besoin du code de main.c et cards.c parce que apparemment tu définie 2 fois quelque chose.

main.c

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "cards.h"
 
 
 On_Malloc_Error(){
	printf("Malloc error !\n");
	system("pause");
	exit(0);
}
 
 
int main(void)
{
	struct cardgame *newgame ;
	struct player *newplayer ;
	Init_Sorted_CardGame(newgame) ;
	Set_Shuffled_CardGame(newgame) ;
	Deal_To_Player_Cards(newgame,newplayer,5);
	system("pause") ;
	return 0 ;
 
}

cards.c :

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "cards.h"
 
/**
*\brief Free the memory allocated for a CardLinkList struct
*\param struct CardLinkedListEntryPoints* EntryPoints EntryPoints to the double linked list to be freed.
*/
 
void CardLinkedList_Clear(struct CardLinkedListEntryPoints* EntryPoints){
 
    struct CardLinkedList* tmptofree ;
    struct CardLinkedList* tmpbrowse ;
 
    // initialisation of tmpbrowse with the pointer towards the first element of the double linked list to free
 
    tmpbrowse = EntryPoints->first ;
 
    // We loop as long as we're not at the last element of the d l l (double linked list)
 
    while(tmpbrowse != NULL){
 
        //init of tmptofree with the pointer to the current item of the doublelinkedlist
 
        tmptofree = tmpbrowse;
 
        // init tmpbrowse with the pointer to the next value
 
        tmpbrowse = tmpbrowse->next ;
 
        // We free the current element
 
        free(tmptofree) ;
        }
 
        // clean init of EntryPoint struct
 
        EntryPoints->first = NULL;
        EntryPoints->last = NULL;
 
}
 
 
 
/**
*\brief initialize a doublelinked list
*\param struct CardLinkedListEntryPoints* EntryPoints ; struct containing pointers towards first and last element.
*/
void Init_CardLinkedList(struct CardLinkedListEntryPoints* EntryPoints){
	EntryPoints->first = NULL;
	EntryPoints->last  = NULL;
}
 
/**
*\brief CardLinkedList_Set_Top_Card insert a card at the beginning of a double linked struct containing cards
*\param struct card CardToAdd The card to insert
*\param struct CardLinkedListEntryPoints* EntryPoints struct containing entry points for double linked struct containing cards
*/
 
 
void CardLinkedList_Set_Top_Card(struct card CardToAdd,struct CardLinkedListEntryPoints* EntryPoints){
 
	//Memory allocation for item to be inserted ; return a pointer to the item
 
	struct CardLinkedList* NewItem = malloc(sizeof(struct CardLinkedList));
 
	//Test if memory allocation was a success
 
	if (NewItem == NULL) On_Malloc_Error() ;
 
	// Initialisation of the newitem with the card given in parameters
 
	strcpy(NewItem->current.color,CardToAdd.color);
	strcpy(NewItem->current.value,CardToAdd.value);
 
	// We insert this new item in top position so we link it to the old first
 
	NewItem->next = EntryPoints->first;
 
	// newitem is the first one , NULL indicate that there's no item before this one
 
	NewItem->prev = NULL;
 
	// Update of entrypoints structs ; the first item pointed is now our new item
 
	EntryPoints->first = NewItem;
 
}
 
/**
*\brief CardLinkedList_Set_Last_Card insert a card at the end of a double linked struct containing cards
*\param struct card CardToAdd The card to insert
*\param struct CardLinkedListEntryPoints* EntryPoints struct containing entry points for double linked struct containing cards
*/
 
void CardLinkedList_Set_Last_Card(struct card CardToAdd, struct CardLinkedListEntryPoints* EntryPoints){
 
 
	//Memory allocation for item to be inserted ; return a pointer to the item
 
	struct CardLinkedList* NewItem = malloc(sizeof(struct CardLinkedList));
 
	//Test if memory allocation was a success
 
	if (NewItem == NULL) On_Malloc_Error() ;
 
	// Initialisation of the newitem with the card given in parameters
 
	strcpy(NewItem->current.color,CardToAdd.color);
	strcpy(NewItem->current.value,CardToAdd.value);
 
	//NewItem is the last card,  Null indicate that there's no item after
	NewItem->next = NULL;
 
	//We link the new last item with the old last one
 
	NewItem->prev = EntryPoints->last;
 
	//Update of the entrypoint struct to indicate last item is pointed by newitem pointer
 
	EntryPoints->last = NewItem;
}
 
 
/**
*\brief count number of cards element in d l l EntryPoints
*\param struct CardLinkedListEntryPoints* EntryPoints
*\return int count number of elements
*/
 
 
int CardLinkedList_Count_Elements(struct CardLinkedListEntryPoints* EntryPoints){
 
    int count = 0;
 
    struct CardLinkedList *tmp;
 
    tmp = EntryPoints->first;
 
    while(tmp != NULL){
 
        count++;
 
        tmp = tmp->next;
    }
 
    return count ;
}
 
 
 
/**
*\brief init a struct cardgame with sorted card struct
*\param struct cardgame newgame
*/
 
void Init_Sorted_CardGame(struct cardgame * newgame){
	int i,j,k ;
	i = 0;
	char TempValue[10];
	char TempColor[6];
	for(j=0;j<4;j++)
				{
					for(k=0;k<13;k++)
						{
							strcpy( newgame->CardTable[i].color, ColorTable[j]);
							strcpy( newgame->CardTable[i].value , ValueTable[k]);
							i++;
						}
				}
}
 
/**
*\ Permute randomly all the cards structs in cardgame struct
*\param struct cardgame ShuffledGame : game to shuffle
*\return struct cardgame ShuffledGame
*/
 
void Set_Shuffled_CardGame(struct cardgame * ShuffledGame){
	int i;
	struct card temp ;
	srand(time(NULL)) ;
	for(i=0;i<52;i++){
		int alea = Generate_Rand(0,51);
		printf("%d \n",alea) ;
		temp = ShuffledGame->CardTable[i];
		ShuffledGame->CardTable[i] = ShuffledGame->CardTable[alea];
		ShuffledGame->CardTable[alea] = temp;
		//printf("i:%d %s \n",i,ShuffledGame->CardTable[i].value);
		}
}
 
/**
*\brief Give a card to one player ie fill player hand substructure with card from cardgame
*\param struct gamecard gamecard game to deal with
*\param struct player *player player to deal to
*\param int nb_card number of card to deal
*/
 
void Deal_To_Player_Cards(struct cardgame *cardgame ,struct player *player, int nb_card){
 
	// Init player's hand (rem : separate function todo?..)
 
	Init_CardLinkedList(player->hand);
 
	int i;
	for(i=0;i<nb_card;i++){
 
		// We test if player has an empty hand,  cuz of chained list different functions
 
		if (player->hand->first == NULL){
 
			// If player has an empty hand -> initialisation of CardLinkedList struct with current card to be dealt (gamecard.position)
 
			CardLinkedList_Set_Top_Card(cardgame->CardTable[cardgame->position],player->hand);
 
			// one card has been dealt -> update of the game position
 
			cardgame->position = cardgame->position++;
			}
			// Hand of player is not empty -> we browse CardLinkedList and set last card
			else{
                    CardLinkedList_Set_Last_Card(cardgame->CardTable[cardgame->position],player->hand);
 
                    cardgame->position = cardgame->position++;
			}
 
	}
}

cards.h :

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
 
#ifndef CARDS_H
#define CARDS_H
 
 
char ColorTable[4][10] = {"spade", "clubs", "heart", "diamond"} ;
 
char ValueTable[13][6] = { "A" , "two", "three", "four", "five", "six", "seven", "eight", "nine", "T", "J", "Q", "K" } ;
 
struct card
{
	char value[10];
	char color[8];
} ;
 
struct cardgame
{
	struct card CardTable[52] ;
	int Id;
	int position;
} ;
 
struct player
{
	char name[20];
	int wage;
	int bet;
	struct CardLinkedListEntryPoints* hand;
};
 
/**
*\struct CardChainedList : Linked list of card struct
*/
 
struct CardLinkedList
{
	struct card current;
	struct CardLinkedList* next;
	struct CardLinkedList* prev;
};
 
struct CardLinkedListEntryPoints
{
	struct CardLinkedList *first;
	struct CardLinkedList *last;
};
 
 
 
/**
*\brief initialize a doublelinked list
*\param struct CardLinkedListEntryPoints* EntryPoints ; struct containing pointers towards first and last element.
*/
void Init_CardLinkedList(struct CardLinkedListEntryPoints* EntryPoints);
 
/**
*\brief CardLinkedList_Set_Top_Card insert a card at the beginning of a double linked struct containing cards
*\param struct card CardToAdd The card to insert
*\param struct CardLinkedListEntryPoints* EntryPoints struct containing entry points for double linked struct containing cards
*/
 
 
void CardLinkedList_Set_Top_Card(struct card CardToAdd,struct CardLinkedListEntryPoints* EntryPoints);
 
/**
*\brief CardLinkedList_Set_Last_Card insert a card at the end of a double linked struct containing cards
*\param struct card CardToAdd The card to insert
*\param struct CardLinkedListEntryPoints* EntryPoints struct containing entry points for double linked struct containing cards
*/
 
void CardLinkedList_Set_Last_Card(struct card CardToAdd,struct CardLinkedListEntryPoints* EntryPoints);
 
 
/**
*\brief count number of cards element in d l l EntryPoints
*\param struct CardLinkedListEntryPoints* EntryPoints
*\return int count number of elements
*/
 
int CardLinkedList_Count_Elements(struct CardLinkedListEntryPoints* EntryPoints);
 
 
/**
*\brief Free the memory allocated for a CardLinkList struct
*\param struct CardLinkedListEntryPoints* EntryPoints EntryPoints to the double linked list to be freed.
*/
 
void CardLinkedList_Clear(struct CardLinkedListEntryPoints* EntryPoints);
 
/**
*\brief init a struct cardgame with sorted card(  A, 2 ,3,etc..)  struct
*\param struct cardgame newgame
*/
 
void Init_Sorted_CardGame(struct cardgame * newgame);
 
/**
*\ Permute randomly all the cards structs in cardgame struct
*\param struct cardgame ShuffledGame : game to shuffle
*\return struct cardgame ShuffledGame
*/
 
void Set_Shuffled_CardGame(struct cardgame * ShuffledGame);
 
/**
*\brief Give a card to one player ie fill player hand substructure with card from cardgame
*\param struct gamecard gamecard game to deal with
*\param struct player *player player to deal to
*\param int nb_card number of card to deal
*/
 
void Deal_To_Player_Cards(struct cardgame *cardgame ,struct player *player, int nb_card);
 
#endif

Merci pour le coup de main :D

résolu : thanks to gullradriell
Code:

1 2 3 static char ColorTable[4][10] = {"spade", "clubs", "heart", "diamond"} ; static char ValueTable[13][6] = { "A" , "two", "three", "four", "five", "six", "seven", "eight", "nine", "T", "J", "Q", "K" } ;
Mettre STATIC devant une déclaration de variable dans un header
-> Dumbass je suis parfois

Citation:

Envoyé par Kryptonaute

Code:

1
2
3
static char ColorTable[4][10] = {"spade", "clubs", "heart", "diamond"} ;
static char ValueTable[13][6] = { "A" , "two", "three", "four", "five", "six", "seven", "eight", "nine", "T", "J", "Q", "K" } ;

Mettre STATIC devant une déclaration de variable dans un header
-> Dumbass je suis parfois

Bah, non. Très mauvaise solution bouffeuse de mémoire...

Ce sont des invariants (lectures seule) ? Alors :

Code:

1
2
3
4
5
6
7
8
9
 
/* texts.h */
#ifndef H_TEXTS
#define H_TEXTS
 
extern char const *const ColorTable[4];
extern char const *const ValueTable[13];
 
#endif

Code:

1
2
3
4
5
 
/* texts.c */
#include "texts.h"
char const *const ColorTable[] = {"spade", "clubs", "heart", "diamond"} ;
char const* const ValueTable[] = { "A" , "two", "three", "four", "five", "six", "seven", "eight", "nine", "T", "J", "Q", "K" } ;

14/05/2007, 23h56
Freed0
Citation:
Envoyé par Emmanuel Delahaye

Code:

1 2 3 ... char const *const ColorTable[] = {"spade", "clubs", "heart", "diamond"} ; ...
Tiens j'ai jamais rencontré ce type de variable. Tu peux m'expliquer pourquoi on y met 2 const ?

Merci :)
15/05/2007, 00h14
Emmanuel Delahaye

Citation:

Envoyé par Freed0

Tiens j'ai jamais rencontré ce type de variable. Tu peux m'expliquer pourquoi on y met 2 const ?

Merci :)

Un pour le tableau de pointeurs, l'autre pour les chaines pointées.

Vieux réflexe de programmeur pour l'embarqué. Tout en PROM, pas de mémoire image...
15/05/2007, 00h32
Pragmateek

Citation:

Un pour le tableau de pointeurs, l'autre pour les chaines pointées.

Ne serait-ce pas plutôt un pour les pointeurs contenus dans le tableau et l'autre pour les "char" pointés par ces pointeurs?
D'ailleurs un tableau en C n'est-il pas forcément constant?
15/05/2007, 08h53
Emmanuel Delahaye

Citation:

Envoyé par seriousme

Ne serait-ce pas plutôt un pour les pointeurs contenus dans le tableau et l'autre pour les "char" pointés par ces pointeurs?
D'ailleurs un tableau en C n'est-il pas forcément constant?

Oui. Disons que pour simplifier abusivement, j'ai assimilé tableau et contenu du tableau.
15/05/2007, 13h16
Kryptonaute

Citation:

Mettre STATIC devant une déclaration de variable dans un header
-> Dumbass je suis parfois

Bah, non. Très mauvaise solution bouffeuse de mémoire...

Je comprends la différence de portée, mais la différence d'allocation mémoire..?

Citation:

Vieux réflexe de programmeur pour l'embarqué. Tout en PROM, pas de mémoire image...

peux tu m'en dire plus ... ça a l'air optimisé comme manière de programmer :idea:
merci.

Pas tout à fait vrai !

Bon alors: j'ai dit static parce que son tableau fait quelques octets seulement et que de toute manière tout les .o sont recompilés à chaque fois.

La différence d'allocation vient du fait que chaque fois qu'un fichier inclut ton .c il se crée une variable ColorTable qui lui est propre.

Ensuite: le const * est inutile, le const tout court lui peut servir (il empêchera la variable d'être modifiée dans le code)

Ensuite: si vous voulez que cela soit efficace il lui faut définir une macro EXTERN, afin de simplifier le code.

EDIT:
Personnellement, j'essayerais de me passer de cette variable globale.

Une méthode ?

exemple:
Je supprime tout déclaration des deux tableaux de char partout ou elles sont, je la crée dans le main.c , je rajoute un argument a la fonction qui en a besoin pour lui passer le tableau ( ce qui pourrait permettre de passer aussi bien un tableau qui parle français qu'un autre qui parle anglais, ou encore d'initialiser le tableau au démarrage en allant chercher l'information dans un fichier texte)

card.c
Code:

1 2 int MaFonctionQuiVeutLeTableau( Pointeur *MonPointeur, char TableauCouleures[4][10], char TableauNom[4][10] )
main.c
Code:

1 2 3 4 5 6 7 8 9 10 #include card.h char ColorTable[ 4 ] [ 10 ] = { " .............. " }; char ValueTable[ 4 ] [ 10 ] = { " .............. " }; int main( int argc, char *argv[]) { MaFonctionQuiVeutLeTableau( MonPointeur, ColorTable , ValueTable ) }
EDIT:

Ce const *const char est vraiment incompréhensible, j'aimerais comprendre pourquoi il y aurait besoin d'avoir un pointeur sur chaque caractère du tableau ainsi créé. ( En l'occurrence 4x10 dans ce cas la )

EDIT:

Ne pas tenir compte de ma précédente remarque, j'ai relus le thread et j'ai vu votre message en réponse à serisousme.

Citation:

D'ailleurs un tableau en C n'est-il pas forcément constant?

La taille oui, le contenu non. D'où l'utilité d'un const pour préserver le contenu.

15/05/2007, 18h10
Emmanuel Delahaye

Citation:

Envoyé par Kryptonaute

Je comprends la différence de portée, mais la différence d'allocation mémoire..?

Si tu définis une variable 'static' dans un header, elle est instanciée à chaque inclusion. C'est pas ce que j'appelle de l'optimisation...

Regle d'or : pas de définition de variable (ni de fonction, sauf macro et inline) dans un header.

Citation:

peux tu m'en dire plus ... ça a l'air optimisé comme manière de programmer

En effet.

Quand on définit une variable initialisée, la plupart des implémentations crée une zone dans le code (un segment, genre 'init'), qui contient l'image des valeurs que l'on voir attribuer aux variables initialisées.

Celle-ci sont donc regroupées dans un segment unique (genre 'initvars'), placé en mémoire modifiable (RAM) d'un format identique au segment des valeurs d'initialisations.

Quand le code démarre, le segment 'init' (PROM) est recopié rapidement dans le segment 'initvars' (RAM) par le code de démarrage (startup), celui la même, qui finit par appeler :

Code:

exit (main (argc, argv));

ce qui constitue le point d'entrée de toute application C.

Si il s'agit de variables ne devant pas être modifiées, il y a peu d'intérêt d'occuper à la fois une zone en PROM et une zone en RAM.

C'est pourquoi, les variables définie 'const' (lecture seules) sont directement codées en PROM dans un segment spécial (genre 'const').

Nota : je n'ai rien inventé, c'est ce que font la plupart des compilateurs avec les chaines de caractères. Celle-ci, et pour les mêmes raisons, sont regroupées dans un segment (genre 'strings'), qui est placé soir en PROM (embarqué), soit, le plus souvent, en zone mémoire (RAM) à lecture seule (hébergé).

A l'époque (années 95), j'avais mené une étude sur différents compilateurs/linkers et de leur 'mapping', qui a démontré l'efficacité du qualificateur 'const', notamment en embarqué. (0 octets en RAM, autres que les variables globales C, genre errno, ou les statiques internes de certaines fonctions de bibliothèques, comme strtok())
16/05/2007, 09h18
GullRaDriel

Des précisions sur le 'const'

Emmanuel Delahaye:

J'ai trouvé votre explication sur le const bien fournie et détaillée, cependant je me pose à présent quelques questions ;-)

1) Peut on avoir des chiffres provenant de votre étude ? Je suis intéressé !
2) Est-ce que le compilateur n'optimise pas cela lui même, ne le fait t' il pas tout seul lorsque l'on passe -oX ( ou X vaut 1,2,3 ) ?
16/05/2007, 11h08
Emmanuel Delahaye

Citation:

Envoyé par GullRaDriel

J'ai trouvé votre explication sur le const bien fournie et détaillée, cependant je me pose à présent quelques questions ;-)

1) Peut on avoir des chiffres provenant de votre étude ? Je suis intéressé !

Malheureusement, entre les déménagements, un incendie et des crashes de disques, cette étude (très informelle) a, à ma connaissance, été perdue... Mais j'ai donné des éléments pour la mener. Il suffit de savoir lire un 'mapping'.

Citation:

2) Est-ce que le compilateur n'optimise pas cela lui même, ne le fait t' il pas tout seul lorsque l'on passe -oX ( ou X vaut 1,2,3 ) ?

Pas à ma connaissance. De plus, ça dépendrait du compilateur.