Salut,
 
Voilà, j'ai une 'union' de plusieurs 'struct' avec des champs de bits. Un truc du genre :
 

Quand je déclare une variable de type T_Blabla que j'utilise en 'extern', j'ai constamment des erreurs au link (redéclaration de la-dite variable avec un type différent). Rien à voir donc. D'autant plus que, si je fais une union avec une seule structure et une variable de type int par exemple, ça marche. Comme ceci :
 

Le problème n'intervient que si je fais un extern. C'est quoi qui cloche ? Pas d'extern sur une union de plusieurs struct ? C'est mon IDE qui à cheri (National Instrument LabWindows/CVI)
 
MERCI.
 

non, t'as une union avec des déclarations à l'intérieur, mais rien d'autre.
 
 
Bref tu déclares rien du tout

Je traduis la réponse de Taz: tu viens de déclarer un type et non une variable; extern indique une variable/fonction bref un truc référençable une fois compilé en fichier objet. Un type ça ne produit pas de code.
Solution: tu places ton typedef dans un .h et tu l'inclus où t'en as besoin.

ben tu traduis mal
 
 
quand tu fais une union
 
tu fais
 
union X
{
  T1 a;
  T2 b;
};
 
 
 
or là dans ton union, tu ne déclares que T1 et T2, mais tu ne déclares pas de membre de type T1 et T2 (en gros pas de a ni de b);
 
 
donc tu gardes tout comme ça, sauf que tu écris  
 
struct Y { ... } y;
 
d'un coup, tu déclares ta structure Y et tu en crées une (y)
 
apres MonUnion.y.a

typedef union  
{  
   struct  
   {  
      int a : 10;  
      int b : 12;  
      int c : 10;  
   } Toto;
 
   struct  
   {  
      int d : 10;  
      int e : 15;  
      int f : 7;  
   } Titi;  
   struct  
   {  
      int g : 7;  
      int h : 8;  
      int i : 17;  
   } Tata;  
} T_Blabla;
 
edit : en fait j'aurais pas fais comme ca  

par exemple, avec des types anonymes. Mais comme dit, définir de part et d'autres les structures parait plus clair. Mais tout ça est tout à fait valide

C vrai j'avais pas lu son post en fait. Mea culpa.

Je ne sais pas si j'ai bien compris la réponse de Taz, toujours est-il que je déclare une variable de ce type et que je l'initialise sans pb. Avant union, j'ai écris "typedef". Donc oui, je déclare que dalle, mais parès je fais ça :
 

 
Cette ligne de code fctione nickel. Tous les champs de maVariable sont accessibles et je peux exploiter cette union de structures sans pb. J'ai un prg qui tourne avec ça sans problème. Par exemple, faire :
 

marche nickel. Quand je suis l'évolution de mes variables dans le debbug, ça marche aussi.  
Le problème vient seulement quand je fais de maVariable une variable globale utilisée en extern. Là, ça plante. Quand je ne l'utilise pas en extern tout est bien dans le meilleur des mondes. Donc en, clair :

Nickel

Grosse daube
 
PS : par contre pas besoin d'écrire maVariable.Toto.a, on écrit direct maVariable.a
 
 

ce qu'il faut comprendre c'est que
 
struct Foo
{
...
};
 
ca declare juste un type struct Foo, pour declarer une variable de ce type tu aurais du faire par exemple
 
struct Foo
{
...
} variable;
 
ou struct {... } variable; ...

tu fais quoi avec ton NULL là ? je vois de pointeur nulle part ?
 
 
le problème il n'est pas externe, il est juste que ta déclaration de type ne déclare rien du tout

Mais je ne veux pas déclarer une variable du type struct Foo puisque je fais une union. C'est une variable du type de l'union que je déclare.

Non, là tu déclares un type union, tu n'instancies pas de variables nulle part. Et c'est bien ça le problème. Quand tu fais de la composition, il faut déclarer des membres, pas seulement leur type.

Oui le NULL, tu le remplaces par 0.
T_Blabla maVariable = {0};
 
Je ne décare pas un type, j'en définis un. Et bien sûr que ce type existe puisque j'arrive à déclarer une variable de ce type. Soit je ne comprends là où tu veux en venir, soit c'est moi qui me fait mal comprendre  

J'ai une réponse de retard

teclare tes unions comme  des struct !

Oui je déclare un type union. On est d'accord et j'instancie une variable de ce type en faisant
T_Blabla maVariable = {0};

t'y est pas la

tu instancies et tu initialises, c'est clair pourtant !

 
T_Blabla maVariable = {0};
 
C'est quoi ça alors ? J'instancie une variable de type T_Blabla et j'initialise l'ensemble à la valeur 0. SI c'est pas ça quer tu veux dire peut-être qu'un exemple de correction à apporter sera plus facile pour comprendre...

struct Tata  
   {  
      int g : 7;  
      int h : 8;  
      int i : 17;  
   };  
 
et ca c'est quoi ?

non, c'est pas du tout ce que je veux dire.

Taz > je ne sais pas à qui tu réponds. Si c'est à moi, pourrais-tu me donner un petit exemple en partant de ce que j'ai écris pour mettre en relief le truc que tu veux me dire. Merci.
 
cris56 > le "ça" comme tu dis, c'est des champs de bits. C'est un ":", pas un "="...

pas possible
 
struct Tata  
   {  
...
   };  
 
c'est quoi ca !!! ou tu instancie la ?

Qu'est-ce qui n'est pas possible ? Les champ de bits ? Est-ce que tu veux me dire que tu veux instancier des variables de types Toto, Tata et Titi ?

oui !

y a vraiment un truc pas clair dans ta tête, t'as pas les bases.

Taz > bof comme remarque. Faudra juste que tu m'expliques pourquoi ça marche très bien quand c'est pas en extern.
 
cris56 + Taz > peut-être que vous ne voyez pas bien ce que fait une union. T'as pas à déclarer un Toto, un Titi ou un Tata. Quand tu fais :
typedef union
{
    int youpi;
    unsigned int piyou;
} T_Type;
 
T_Type maVar;
 
T'écris direct maVar.youpi = 5; T'avais pas à déclarer d'abord une variable de type int et une autre de type unsigned int au préalable. L'union te sert à "regarder" ta variable selon le pdv d'une struct Toto, d'une struct Tata, etc. Si t'écris maVariable.a = 5; d'emblée c'est vu comme une structure Toto car le champ "a" n'est présent que dans la structure Toto.
 
En clair, quand t'écris T_Blabla maVariable = {0};  c'est comme si tu disais maVariable peut être soit un Toto et tous les champs de Toto sont init à 0, soit un Tata et tous les champs de Tata sont init à 0, soit un Titi etc.

cris56, je te laisse casser l'autre aveugle.

j'en peu plus

Taz > A part insulter les gens, les traiter de blaireau ou que sais-je comme tu l'as déjà fait sur l'autre topic il y a qq temps, tu sers à quoi ? Même pas foutu de me dire pourquoi le code marche avec ça quand je ne l'utlise pas en extern. Le hasard hein ? Par cotnre insulter, même quand tu te trompes (cf. licence BSD sur l'autre thread ou tu nous traite de blaireaux de pirateur), ça tu sais faire. T'excuser quand on te prouve que t'as tort, ça par contre...

parce que la signification de extern.
 
tu rames complet entre déclaration de type et déclaration de variable et tu nous fais un cours alors que depuis le début tu n'écoutes pas ce que cris56 et moi te disons.

- ta un probleme
- on te donne la solution
- tu nous crois pas
- tu nous repproche de ne pas t'aider

cris, je ne t'ai rien reproché, mais j'accepte pas de me faire insulter point barre.
 
Par contre, ni toi ni Taz m'avaient expliqué pourquoi ça fonctionne très bien lorsque c'est pas une var globale. On va dire que c'est le hasard...

parce que tu ne sais pas ce que fais extern, ce qui montre bien que tu ne différencies pas déclaration et allocation.

Et bien si l'erreur vient de là et que tu voulais m'aider, il aurait été plus judicieux de me dire quelle est la subtilité que fait extern et qui entraîne que ça marche lorsque c'est utilisé en "non" extern et que ça marche pas lorsque c'est en extern. C'est ça mon pb et c'est ça que je veux savoir depuis le début. Ca figure même dans le titre du thread.

non, la véritable erreur n'est pas là. Comme dit dans mon premier message, extern ou pas, ta déclaration ne déclare rien du tout.

 
Les gars, calmez vous un peu (même si c'est frustrant, je sais).
Il pose une question simple: "pourquoi ça fonctionne lorsque les variable du type union ne sont pas externes", et personne ne lui répond.
 
Donc on va le faire: ça fonctionne, parce que c'est un bug du compilateur de Labwindows qui a sur-simplifié ton biniou. Avec un "bon" compilateur, tu aurais une tétrachiée de warnings (au moins 5 en fait), et ça ne compilerait probablement pas.  
 
En effet, l'hypothèse de départ que l'on peut faire directement "T_blabla.a" est fausse. Donc, ça marche peut-être dans la même unité de compilation, mais pas lorsqu'il faut effectuer la décoration des types en utilisant un extern...
 
 

Lam's : y a pas de bug de compilateur. Y a juste des gens qui font des déclarations qui ne déclarent rien et utilise extern sans en comprendre le sens.
 
Avec cris56, on débarque, on cherche pas à comprendre, on prends le problème à la base : la déclaration de type est invalide. Maintenant si vous êtes pas capable de comprendre que tant que les problèmes structurels sont pas réglés, ça sert à rien de s'occuper des périphériques ...
 
et ton histoire de décoration des types, c'est n'importe quoi ... toi non plus, tu ne sais pas ce que fait extern ... alors faudrait voir à arrêter de faire la leçon de C ou de manières à tout le monde. Commence par faire ta déclaration d'union correctement. Après si tu veux savoir ce que fait extern, suffit de demander, et pas de nous sortir des fausses définitions.

Ah merci Lam's ! Donc en effet je vais voir si je peux me démerder avec un autre compilo. Car c'est vrai qu'il y avait un truc qui m'intriguait, c'est que lorsque je faisais la même union, mais qu'avec une seule struct dans l'union et des variables de type int (cf. exemple 2 du premier post), ça passait sans pb. Ce n'est que lorsque je faisais une union avec au moins 2 struct que ça plantait en extern. C'est pour ça que ça me paraissait flou. Toi aussi tu utilises LabWindows ?