Discussion :

[James_]

Bonjour,

Je viens de lire en long et en large le sujet sur "mot clé extern" et il tombait bien car j'ai un problème similaire lié à la définition, déclaration et initialisation de variables globales.

Situation:
Sous windowsXP, environnement Metrowerks Code Warrior Palm OS
J'ai 9 fichiers.h relatifs à 9 fichiers.c
Dans ces 9 fichiers.h il y a un fichier.h que j'ai nommé "globale.h" et lié respectivement au fichier "globale.c".
Le fichier "globale.h" contient actuellement:
- des définition de structures (d'une 20taine de paramètres),
- des prototypes de fonctions (avec le mot clé extern),
- des déclarations de variables globales (avec le mot clé extern).
Ce fichier "globale.h" est pratiquement inclus (instruction #include) dans tous les fichiers.c
Le fichier "globale.c" contient actuellement:
- des déclarations de toutes les variables globales identifiées par le mot clé "extern" relatif au fichier "globale.h",
- des variables d'initialisations de ces variables globales.

La compilation: aucun message d'erreur, ni d'avertissement.

Lorsque je lance mon application, certaine variables globales sont modifiées suivant le fichier.c où des fonctions leurs font appels.

Apparemment mes fonctions globales ne sont pas modifiées partout pareille.

Exemple de 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
17
18
19
20
21
 
 // fichier globale.h
   #ifndef  _GLOBALE_H
    #define _GLOBALE_H
 
   typedef struct
   {
      char    name[16];
      ulong   delay;
      ushort baud;
   } _COM;
 
   extern _COM Com;
 
// Prototypes
   extern int CopyCom(_COM *dest, _COM *src);
 
   extern void Aff(void);
 
 
   #endif

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
 
 // fichier globale.c
    #include <stdlib.h>
    #include <stdio.h>
    ...
    #include "globale.h"
 
    _COM Com,
             DefaultCom = {
                                   "NoName\0",
                                   100000L,
                                   9600
                                };
 
    void Aff(void)
    {
        cprintf("\nCom.delay=%lu\0", Com.delay);
    }

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
 
 // fichier FctCom.c
    #include <stdlib.h>
    #include <stdio.h>
    ...
    #include "FctCom.h"
    #include "globale.h"
 
    int CopyCom(_COM *dest, _COM *src)
    {
        strcpy(dest->name, src->name);
        dest->delay         = src->delay;
        dest->baud          = src->baud;
 
        return(1);
    }
    ...

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
 
 // fichier Application.c
    #include <stdlib.h>
    #include <stdio.h>
    ...
    #include "globale.h"
 
    int main(int argc, char **argv)
    {
        argc = 0;
        argv = NULL;
 
        Aff();
        CopyCom(&Com, &DefaultCom);
        Aff();
 
        return(0); 
    }

Le résultat est que je n'arrive pas à afficher
Com.delay=100000 mais plutôt une valeur différente.

La taille de mes structures est bcp plus grande et mon programme aussi.

Je voudrai savoir quelle méthode vous me conseillez pour donc copier dans un structure des valeurs par défaut, (un peu comme un constructeur...) et pq je n'obtient pas les bonnes valeurs dans ma structure Com qd mon DefaultCom est placé en globale.c par contre s'il est placé en Application.c là ça fonctionne.

[Médinoc]

Je ne vois pas la déclaration extern de DefaultCom...

[souviron34]

pourquoi définis tu ton Com en extern dans globales et pas dans le fichier Application ??

[souviron34]

et je rajouterais, si tu fais comme ça, moi je ferais dans globale.C une méthode SetDefault(_Com *com)

[James_]

Je ne vois pas la déclaration extern de DefaultCom...

Oups j'ai oublié en copiant mon source ici mais dans mon prog il y est:

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
 
 
 // fichier globale.h
   #ifndef  _GLOBALE_H
    #define _GLOBALE_H
 
   typedef struct
   {
      char    name[16];
      ulong   delay;
      ushort baud;
   } _COM;
 
   extern _COM Com, 
                     DefaultCom;         // <-- ICI
 
// Prototypes
   extern int CopyCom(_COM *dest, _COM *src);
 
   extern void Aff(void);
 
 
   #endif

pourquoi définis tu ton Com en extern dans globales et pas dans le fichier Application ??

Je comprends pas? mon Com est défini en extern dans mon fichier globale.h je ne vois pas (ou je ne sais pas) pourquoi je devrais le définir dans application.c sachant qu'application.c contient l'instruction "#include "globale.h""

et je rajouterais, si tu fais comme ça, moi je ferais dans globale.C une méthode SetDefault(_Com *com)

Ok je suis partant. Mais de toute façon je dois garder ma fonction (pas méthode car pas en C++) CopyCom(_COM*, _COM*);
Le fait de passer en paramètre un "DefaultCom" me semble sympa mais par contre je ne vois pourquoi suivant le fichier.c où DefaultCom est initialisé, celà fonctionne ou pas.

[souviron34]

ben ton defaultCom est pas dans le globale.h ...

[Emmanuel Delahaye]

ben ton defaultCom est pas dans le globale.h ...

Il a posté une nouvelle version...

[souviron34]

D'ailleurs je viens de 'apercevoir encore d'autre chose..Dans le name tu mets \0 .... TOUT FAUX... ça te donneras exactement ce que tu as écrit...

Moi ( mais c'est mon avis et je le partage ) j'organiserais comme ça :

globale.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
 
// fichier globale.h
   #ifndef  _GLOBALE_H
    #define _GLOBALE_H
 
   typedef struct
   {
      char    name[16];
      ulong   delay;
      ushort baud;
   } _COM;
 
 
// Prototypes
   extern int CopyCom(_COM *dest, _COM *src);
 
   extern void Aff(_COM *AAfficher );
 
 
   #endif

Globale.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
 
 // fichier globale.c
    #include <stdlib.h>
    #include <stdio.h>
    ...
    #include "globale.h"
 
 
    void Aff( _Com MyCom)
    {
        cprintf("\nCom.delay=%lu\0", MyCom->delay);
    }
 
    void SetDefaut ( _Com MyCom )
    {
       strcpy ( MyCom->name, "NoName" );
       MyCom->baud = 9600 ;
       MyCom->delay = 100000L ;
    }

Et enfin Application :

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
 
// fichier Application.c
    #include <stdlib.h>
    #include <stdio.h>
    ...
    #include "globale.h"
 
    _Com Com, DefautCom ;
 
    int main(int argc, char **argv)
    {
        argc = 0;
        argv = NULL;
 
        SetDefaut (&DefautCom);
 
        Aff(&DefautCom);
 
        CopyCom(&Com, &DefaultCom);
 
        Aff(&Com);
 
        return(0); 
    }

[EDIT]

Et même je ferais un globaleStruct.h que j'incluerais dans globale.h, et je n'incluerais pas globale.h dans globale.c, mais uniquement globaleStruct..

[/EDIT].

[James_]

D'ailleurs je viens de 'apercevoir encore d'autre chose..Dans le name tu mets \0 .... TOUT FAUX... ça te donneras exactement ce que tu as écrit...

Je ne vois pas pourquoi j'ai tout faux? Une chaîne de caractères se termine par un \0, c'est une sécurité bien utile parfois...

Pourquoi dois-je déclarer "_Com Com, DefautCom ;" dans mon fichier "Application.c", où la vraie question est dans quels fichiers.c faut-il déclarer les variables globales?
Ma structure _Com est utilisée dans d'autres fichiers.c, pourquoi dois-je la déplacer dans "Application.c" plutôt que de la laisser dans "globale.c" puisque "Application.c" ou "globale.c" contiennent tous les deux l'instruction "#include "globale.h"" qui contient la ligne "extern _COM Com, DefaultCom;" ?

[souviron34]

quand c'est entre guillements c'est ajouté automatiquement....

Là comme c'est à l'intérieur des guillements tu rajoutes le caractère '\' et le caractère '0' ..

[Emmanuel Delahaye]

Bonjour,

Je viens de lire en long et en large le sujet sur "mot clé extern" et il tombait bien car j'ai un problème similaire lié à la définition, déclaration et initialisation de variables globales.
Le résultat est que je n'arrive pas à afficher
Com.delay=100000 mais plutôt une valeur différente.

Le principal problème de ton code est qu'il est horriblement mal organisé...

Il y a des principes de nommage, de découpage et de sectionnage du code à respecter, même si ils ne sont issus que de la pratique et du bon sens.

Je te conseille de lire ceci.

http://emmanuel-delahaye.developpez.com/codage.htm

Voici comment je réorganiserais ton code en fonction de ces critères.

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
 
#ifndef H_ED_TYPES_20070302161837
#define H_ED_TYPES_20070302161837
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/* macros ============================================================== */
/* constants =========================================================== */
/* types =============================================================== */
   typedef unsigned long int ulong;
   typedef unsigned short int ushort;
 
/* structures ========================================================== */
/* entry points ======================================================== */
/* public variables ==================================================== */
/* inline public functions  ============================================ */
 
#ifdef __cplusplus
}
#endif
 
#endif                          /* guard */
 
/* Guards added by GUARD (c) ED 2000-2005 Jan 17 2005 Ver. 1.7 */

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
 
#ifndef H_ED_COM_20070302161856
#define H_ED_COM_20070302161856
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#include "types.h"
 
/* macros ============================================================== */
/* constants =========================================================== */
/* types =============================================================== */
/* structures ========================================================== */
 
   typedef struct
   {
      char name[16];
      ulong delay;
      ushort baud;
   }
   com_s;
 
/* internal public functions =========================================== */
/* entry points ======================================================== */
 
   int com_copy (com_s * dest, com_s * src);
 
   void com_aff (void);
 
/* public variables ==================================================== */
 
   extern com_s com_g_Com, com_g_Default;
 
/* inline public functions  ============================================ */
 
#ifdef __cplusplus
}
#endif
 
#endif                          /* guard */
 
/* Guards added by GUARD (c) ED 2000-2005 Jan 17 2005 Ver. 1.7 */

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
 
 // com.c
#include "com.h"
 
#include <string.h>
#include <stdio.h>
 
/* macros ============================================================== */
/* constants =========================================================== */
/* types =============================================================== */
/* structures ========================================================== */
/* private variables =================================================== */
/* private functions =================================================== */
 
/* entry points ======================================================== */
 
int com_copy (com_s * dest, com_s * src)
{
   strcpy (dest->name, src->name);
   dest->delay = src->delay;
   dest->baud = src->baud;
 
   return 1;
}
 
void com_aff (void)
{
   printf ("\nCom.delay=%lu", com_g_Com.delay);
}
 
/* public variables ==================================================== */
 
com_s com_g_Com;
com_s  com_g_Default =
{
   "NoName",
   100000L,
   9600
};

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 // main.c
#include <stdio.h>
#include "com.h"
 
int main (void)
{
   com_aff ();
   com_copy (&com_g_Com, &com_g_Default);
   com_aff ();
 
   return 0;
}

Automatiquement, les problèmes évoqués n'existent plus.

NOTA : je n'ai pas modifié la conception. Je rappelle que les globales sont à éviter. Je conseille une approche plus 'OO'...

http://emmanuel-delahaye.developpez.com/tad.htm

[James_]

quand c'est entre guillements c'est ajouté automatiquement....

Là comme c'est à l'intérieur des guillements tu rajoutes le caractère '\' et le caractère '0' ..

Non pas avec mon compilateur, il remplace "\0" par 0 et non par '\' et '0'.

Enfin quoiqu'il en soit, j'ai changé comme vous l'avez supposé la fct Aff(_COM*); mais ça ne change rien.
En résumé, si je place mon

Code :

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

1
2
3
4
5
6
 
DefaultCom = {
                                   "NoName\0",
                                   100000L,
                                   9600
                   };

dans différent fichiers.c, je n'obtiens pas le même résultat et franchement est-ce un bug du C?

[souviron34]

quant à l'autre question, moi pour limiter les dégats, si tu tiens à faire comme ça :

dans le globale.h je mettrais extern Com, DefaultCom.
encore une fois je ferais un globalStruct qui contiendrais les structures, que j'incluerais dans globale.c et dans globale.h
je n'incluerais pas globale.h dans globale.c
et dans globale.c je mettrais tes variables globales..

Comme on l'a amplement dit dans l'autre sujet, et visiblement c'est une question d'opinion et de taille des logiciels, mais en général :

Moi je structure toujours le code comme ceci :

• un fichier de fonctions (ex. globale.c )
  contenant éventuellement des variables globales statiques.
  Si ces variables ont une utlité à l'externe, je fais des fonctions (méthodes pour ceux attirés par l'objet) GetObjet ( *Ptr )
  
• un fichier struct.h dans lequel je mets la définition des structures et des constantes (ERROR, etc..) dont je me sers dans ce fichier de fonctions.
  
• un fichier .h incluant les structs et les fonctions publiques du fichier de fonctions. (ex. globale.h)
  
• Enfin les autres fichiers de l'application, qui si il se servent des fonctions incluent ce fichier .h..

[stephl]

Non pas avec mon compilateur, il remplace "\0" par 0 et non par '\' et '0'.

'\0' est un seul caractère (celui ayant pour valeur numérique 0).

[souviron34]

je sais bien ça, stephl, mais normalement quand tu fais

"chaine\0" tu a les caractères c h a i n e \ 0 dans la chaîne parce que c'est entre double guillemets..

[Médinoc]

En plus clair et moins confus:
Si tu fais "chaine\0", tu as deux caractères nuls à la fin de la chaîne, au lieu d'un.

PS: souviron34, tu es complètement dans le décor, là...

[stephl]

je sais bien ça, stephl, mais normalement quand tu fais

"chaine\0" tu a les caractères c h a i n e \ 0 dans la chaîne parce que c'est entre double guillemets..

Je ne m'adressais pas à vous si vous relisez mon post. Juste une chose: avec votre exemple, ce qui est contenu dans la chaîne ne serait pas plutôt: c h a i n e \0 \0

[Médinoc]

stephl : Oui, c'est bien ça.

[souviron34]

En plus clair et moins confus:
Si tu fais "chaine\0", tu as deux caractères nuls à la fin de la chaîne, au lieu d'un.

PS: souviron34, tu es complètement dans le décor, là...

FAUX .. Fais un printf ( chaine) ....

Et pour l'autre post pareil.....

[souviron34]

si tu déclares une variable :

Code :

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

1
2
 
char toto[] = "TOTO"

et que tu fasses printf ou strlen() tu trouveras 4 et TOTO..

Si tu lui mets "TOTO\0" tu trouveras 6 et TOTO\0