[C] Unsigned enums?

[Darkvater]

Aanschouw onderstaand wonderbaarlijke code:

code:

#include <stdio.h>

typedef enum moo {
  STRANGE = 6,
  CHARMING = 7
} moo;

struct oof {
  moo surface:3;
  int baz:5;
} x;

int main(void)
{
  x.surface = CHARMING;
  printf("%d\n", x.surface);
}

Als ik deze run op mijn MSVC compiler is x.surface -1. Als ik het op gcc compileer, is x.surface gewoon 7. Is er ook maar enig mogelijkheid om die bitstuffed waarde unsigned aan surface toe te kennen dat werkt in MSVC? Ik heb 3 bits, 7 moet zeker lukken (6 is -2, en pas bij 3 gaat het goed..ik ben dus 1 bit kwijt aan signedness )

[NMe]

Typecasten naar unsigned werkt niet?

[Darkvater]

NMe84 schreef op donderdag 18 november 2004 @ 23:15:
Typecasten naar unsigned werkt niet?

Bedoel je zoiets als
"STRANGE = 6U,",
"STRANGE = (unsigned char)6," of
"x.surface = (unsigned)CHARMING;"
werken niet

Hoe ik het nu op MSVC heb opgelost kan je hieronder zien, maar dit wil ik helemaal niet. Moet ik nou MS gaan bashen

code:

typedef unsigned char moo;
enum moo {
  STRANGE = 6,
  CHARMING = 7
};

[ Voor 32% gewijzigd door Darkvater op 18-11-2004 23:32 ]

[farlane]

Misschien door de default chars unsigned te maken ? (=compiler optie)

Volgens mij frot de compiler het in de kleinste eenheid waar het nog in past.

[Darkvater]

farlane schreef op donderdag 18 november 2004 @ 23:33:
Misschien door de default chars unsigned te maken ? (=compiler optie)

Volgens mij frot de compiler het in de kleinste eenheid waar het nog in past.

/J (Default char Type Is unsigned)

Gedaan; maar zonder resultaat.

[Soultaker]

Ik gebruik ze niet zo vaak, maar ik dacht dat het teken van een bitfield implementatie-afhankelijk is. (Ook als je bijvoorbeeld een "int" declareert, die normaal gesproken zijn signed zou zijn.) Probeer dus eens "unsigned moo" in je declaratie te zetten?

[Macros]

Is het heel erg belangrijk dat je 2 'ints' in 1 byte stopt? Anders vind ik dat je het jezelf erg moeilijk maakt, maar ja, wie ben ik

[Macros]

Soultaker schreef op donderdag 18 november 2004 @ 23:42:
Ik gebruik ze niet zo vaak, maar ik dacht dat het teken van een bitfield implementatie-afhankelijk is. (Ook als je bijvoorbeeld een "int" declareert, die normaal gesproken zijn signed zou zijn.) Probeer dus eens "unsigned moo" in je declaratie te zetten?

Je kan geen modifiers bij een typedef toevoegen...

[Darkvater]

Macros schreef op donderdag 18 november 2004 @ 23:42:
Is het heel erg belangrijk dat je 2 'ints' in 1 byte stopt? Anders vind ik dat je het jezelf erg moeilijk maakt, maar ja, wie ben ik

Jah, het moet . Ik zou het liever ook niet doen hoor

Dus MS flamen maar?

[Soultaker]

Alleen MS flamen als de C standaard zegt dat dat ding unsigned moet zijn. Ik denk dat het implementatie-afhankelijk is, en dan is de keuze van MS net zo geldig als van GNU.

Overigens snap ik niet waarom je dat veld niet gewoon unsigned definieert. Types gebruiken in bitfields is sowieso een beetje raar, omdat je het type beperkt tot een vast aantal bits. Zeg dan direct "unsigned : 3" dan geef je tenminste aan dat het een unsigned 3-bits waarde is.

[ Voor 3% gewijzigd door Soultaker op 18-11-2004 23:54 ]

[Macros]

Misschien moet je in je struct ipv een enum een unsigned char declareren. Dat heb je minder type safety, maar ja, met 3 bits kan je ook niet zoveel

[NMe]

En anders heb je altijd nog 's werelds vieste oplossing:

C++:

#ifdef __MSVCPP
    var = ~var + 1;
#endif

Lelijk, doch effectief.

[.oisyn]

Macros schreef op donderdag 18 november 2004 @ 23:42:
Is het heel erg belangrijk dat je 2 'ints' in 1 byte stopt? Anders vind ik dat je het jezelf erg moeilijk maakt, maar ja, wie ben ik

sterker nog, sizeof (oof) == sizeof (int)
(onder MSVC++ dan)

[ Voor 4% gewijzigd door .oisyn op 19-11-2004 11:08 ]

[farlane]

Waarom maak je geen set/get functies die een enum accepteren en de bits setten/getten met een paar AND masks ?

[Darkvater]

farlane schreef op vrijdag 19 november 2004 @ 11:20:
Waarom maak je geen set/get functies die een enum accepteren en de bits setten/getten met een paar AND masks ?

Ik heb die ~var+1 geprobeerd, maar de waarde is dan gewoon -7 (als charming 7 is), en er wordt -1 toegekend aan de waarde. Over wat farlane zegt, het heel idee was om de heele bits-dingen door de compiler zelf te laten doen..maar ik denk dat het dan inderdaad iets anders moet worden helaas; zoals get/set.

[Soultaker]

Dan kun je beter gewoon dat bitfield als unsigned declareren. Lijkt me stukken makkelijker, en in C boeit het toch niets of variabele een enum of een int of een bitfield is. Sowieso is het de vraag of een enum het juiste type is om te gebruiken, als de feitelijke waarde van belang is; dan zou je toch al meer naar een int moeten neigen.

[ Voor 34% gewijzigd door Soultaker op 19-11-2004 17:38 ]

[Zoijar]

Ik lees wel dit:

The bug is that gcc makes "an enum type be of type unsigned int (or maybe
unsigned char) rather than signed int as it should be according to K&R 2nd
edition section A8.4 pages 214-215."

Blijkbaar heeft MS het dus goed, en GCC fout? Ik heb geen C standaard hier; maar staat daarin dat een enum signed moet zijn?

[Zoijar]

Oh ik vind trouwens net een MSVC7 compliance bug: (is wel C++, geen C)

C++:

#include <stdio.h>


enum BOOL { f=0, t=1 };
  struct A {
          BOOL b:1;
  };
  A a;

  void foo() {
          a.b = t;
          if (a.b == t)           // shall yield true
           { printf("Compiler ok!\n"); }
          else {
              printf("Compiler bugs!\n");
          }
  }

  int main(void) {
    foo();
    return 0;
  }

MSVC output hier "Compiler bugs!".

code:

4 If the value true or false is stored into a bit-field of type bool  of
  any  size (including a one bit bit-field), the original bool value and
  the value of the bit-field shall compare equal.  If the  value  of  an
  enumerator is stored into a bit-field of the same enumeration type and
  the number of bits in the bit-field is large enough to  hold  all  the

  values of that enumeration type, the original enumerator value and the
  value of the bit-field shall compare equal.  [Example:
  enum BOOL { f=0, t=1 };
  struct A {
          BOOL b:1;
  };
  A a;
  void f() {
          a.b = t;
          if (a.b == t)           // shall yield true
          { /* ... */ }
  }
   --end example]

[Verwijderd]

Volgens mij is een enum signed dus is het gedrag van het eerste stukje code verklaarbaar. Soultaker heeft goede argumenten: als je met bitfields werkt, werk dan met bitfields van primitieven zoals unsigned char of int, dan weet je a) de signedness en b) de size(of) zeker.
^{(Die sizeof(struct oof) lijkt mij ook wel eens interessant om te weten.)}

edit: verklaarbaar maar niet volgens de standaard dus
edit2: Verdorie, ik mis posts? Don't mind me, my browsercache is borked.

[ Voor 18% gewijzigd door Verwijderd op 19-11-2004 18:09 ]

[MSalters]

7.1.5.2 zegt implementation-defined

[Zoijar]

MSalters schreef op zaterdag 20 november 2004 @ 00:35:
7.1.5.2 zegt implementation-defined

Weet jij of 9.6.4 veranderd sinds de 1997 working paper? Volgens mij is dat namelijk een onbekende VC compiler 'bug' die ik net postte?

[MSalters]

N1638, April draft zegt ook hetzelfde

If the value true or false is stored into a bit-field of type bool of any size (including a one bit bit-field), the original bool value and the value of the bit-field shall compare equal. If the value of an enumerator is stored into a bit-field of the same enumeration type and the number of bits in the bit-field is large enough to hold all the values of that enumeration type, the original enumerator value and the value of the bit-field shall compare equal. [Example:

C++:

enum BOOL { f=0, t=1 };
struct A {
BOOL b:1;
};
A a;
void f() {
a.b = t;
if (a.b == t) // shall yield true
{ /* ... */ }
} 

—end example]

offtopic:
Nee, de nieuwe standaard is niet color coded

[Darkvater]

MSVC bug dus (bij mij is het fals). Iig bedankt voor de zeer hulpvolle en deskundige hulp van iedereen \o/