IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Problème de compilation séparée


Sujet :

C

  1. #1
    Membre du Club
    Inscrit en
    Août 2006
    Messages
    36
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 36
    Points : 40
    Points
    40
    Par défaut Problème de compilation séparée
    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 : 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
    #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 : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    #ifndef CARDS_H
    #define CARDS_H
    ... mes prototypes ...
    #endif
    Début du cards.c :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include "cards.h"
    Erreur persistante de compilation :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

  2. #2
    Expert éminent sénior
    Avatar de Skyounet
    Homme Profil pro
    Software Engineer
    Inscrit en
    Mars 2005
    Messages
    6 380
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Software Engineer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2005
    Messages : 6 380
    Points : 13 380
    Points
    13 380
    Par défaut
    Ben là on a besoin du code de main.c et cards.c parce que apparemment tu définie 2 fois quelque chose.
    Introduction à Silverlight 4 (new) ; Localisation d'une application Silverlight (new) ;
    Mon espace perso[/B]

    La connaissance s’acquiert par l’expérience, tout le reste n’est que de l’information. Albert Einstein[/SIZE]

  3. #3
    Membre du Club
    Inscrit en
    Août 2006
    Messages
    36
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 36
    Points : 40
    Points
    40
    Par défaut
    main.c
    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
    #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 : 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
    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 : 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
    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

  4. #4
    Membre du Club
    Inscrit en
    Août 2006
    Messages
    36
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 36
    Points : 40
    Points
    40
    Par défaut
    résolu : thanks to gullradriell

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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

  5. #5
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par Kryptonaute
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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" } ;
    Pas de Wi-Fi à la maison : CPL

  6. #6
    Membre éprouvé
    Avatar de Freed0
    Profil pro
    Étudiant
    Inscrit en
    Mars 2005
    Messages
    635
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2005
    Messages : 635
    Points : 953
    Points
    953
    Par défaut
    Citation Envoyé par Emmanuel Delahaye
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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

  7. #7
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    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...
    Pas de Wi-Fi à la maison : CPL

  8. #8
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    Mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : Mars 2006
    Messages : 2 635
    Points : 4 062
    Points
    4 062
    Par défaut
    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?
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

  9. #9
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    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.
    Pas de Wi-Fi à la maison : CPL

  10. #10
    Membre du Club
    Inscrit en
    Août 2006
    Messages
    36
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 36
    Points : 40
    Points
    40
    Par défaut
    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..?

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

  11. #11
    Candidat au Club
    Profil pro
    Inscrit en
    Février 2003
    Messages
    2
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2003
    Messages : 2
    Points : 2
    Points
    2
    Par défaut 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 : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    int MaFonctionQuiVeutLeTableau( Pointeur *MonPointeur, char TableauCouleures[4][10], char TableauNom[4][10] )

    main.c
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

    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.
    Peu de temps avant sa disparition, j'avais rencontré un internaute en quete du nombre exacte de possibilité de bug de Windows... Je ne l'ai jamais revu. Alors faites comme moi, parfois , avec Microsoft, il faut se forcer a croire a la magie...

  12. #12
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    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.
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
       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())
    Pas de Wi-Fi à la maison : CPL

  13. #13
    Candidat au Club
    Profil pro
    Inscrit en
    Février 2003
    Messages
    2
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2003
    Messages : 2
    Points : 2
    Points
    2
    Par défaut 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 ) ?
    Peu de temps avant sa disparition, j'avais rencontré un internaute en quete du nombre exacte de possibilité de bug de Windows... Je ne l'ai jamais revu. Alors faites comme moi, parfois , avec Microsoft, il faut se forcer a croire a la magie...

  14. #14
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    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'.

    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.
    Pas de Wi-Fi à la maison : CPL

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Problème pour la compilation séparée
    Par mylha dans le forum Débuter
    Réponses: 2
    Dernier message: 29/03/2011, 16h44
  2. Problème de compilation séparée
    Par vincent.mbg dans le forum C
    Réponses: 5
    Dernier message: 14/06/2010, 10h40
  3. Problème simple de compilation séparée
    Par chrisdayton dans le forum Débuter
    Réponses: 7
    Dernier message: 03/12/2009, 07h50
  4. Problème de compilation séparée
    Par orfix dans le forum C
    Réponses: 9
    Dernier message: 25/06/2007, 11h07
  5. Réponses: 1
    Dernier message: 27/05/2002, 01h44

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo