init typedef , structure , bitfield c code

[bitsetzer (Gast)]

#include <stdio.h>
#include <stdlib.h>


typedef struct bitfields3 {
  unsigned char a : 1;
  unsigned char b : 1;
  unsigned char c : 1;
} bitfields3_t;


typedef struct bitfields8 {
  unsigned char a : 1;
  unsigned char b : 1;
  unsigned char c : 1;

        // TEST
  unsigned char d : 1;
  unsigned char e : 1;
  unsigned char f : 1;
  unsigned char g : 1;
  unsigned char h : 1;
} bitfields8_t;


void main ( void ) {

bitfields3_t mask3;
bitfields8_t mask8;


mask3.a = 1;
mask3.b = 0;
mask3.c = 0;


mask8.a = 1;
mask8.b = 0;
mask8.c = 0;
mask8.d = 0;
mask8.e = 0;
mask8.f = 0;
mask8.g = 0;
mask8.h = 0;


printf("Mask3: %d a:%d  b:%d  c:%d\n", mask3, mask3.a, mask3.b, mask3.c);
printf("Mask8: %d a:%d  b:%d  c:%d\n", mask8, mask8.a, mask8.b, mask8.c);

mask3.a = 0;
mask3.b = 0;
mask3.c = 1;


mask8.a = 0;
mask8.b = 0;
mask8.c = 1;
mask8.d = 0;
mask8.e = 0;
mask8.f = 0;
mask8.g = 0;
mask8.h = 0;

printf("Mask3: %d a:%d  b:%d  c:%d\n", mask3, mask3.a, mask3.b, mask3.c);
printf("Mask8: %d a:%d  b:%d  c:%d\n", mask8, mask8.a, mask8.b, mask8.c);


// test sizeof struct:
printf ("Groesse struct  (3) : %d\n", sizeof(struct bitfields3) );
printf ("Groesse struct  (8) : %d\n", sizeof(struct bitfields8) );

// test sizeof type
printf ("Groesse typedef (3) : %d\n", sizeof(bitfields3_t) );
printf ("Groesse typedef (8) : %d\n", sizeof(bitfields8_t) );

}

sizeof stimmt bei struct und type (1)

Wo liegt aber mein Denkfehler für die vorgesehene Wert Ausgabe?

Ich möchte gerne bei bitfields3 (3 BIT) 1 0 0 bzw 0 0 1
die Ausgabe mit Format %d   4 bzw 1 haben


Frage:
Wie initialisiere ich das 3 bit struct bzw den 3 bit type mit 0?


ein Versuch, ein weiteres struct / type anzulegen und auch die 
restlichen 5 bits zu initialisieren belegen, bringt nicht das gewünschte 
Ergebnis:

Ich hätte erwartet bei bitfields8 (8 BIT)
1 0 0 0 0 0 0 0 bzw 0 0 0 0 0 0 0 1

die Ausgabe mit Format %d   128 bzw 1 haben


Der Versuch dient mir auch zu verstehen, wie die Bits zu setzen sind
für LSB und MSB.

Danke schon mal für die Erklärung was ich falsch mache und für einen 
Tip.

[Rufus Τ. F. (rufus)]

bitsetzer schrieb:
> Ich möchte gerne bei bitfields3 (3 BIT) 1 0 0 bzw 0 0 1 die Ausgabe mit
> Format %d   4 bzw 1 haben

Du möchtest, daß die einzelnen Bits im Bitfeld in den Wert eines Bits 
innerhalb eines Bytes/ints/wasauchimmer übersetzt werden?

Das kannst Du -- mit Portabilitätsproblemen -- durch Gebrauch einer 
union mit einem int erreichen,

d.h.

typedef union
{
  int wert;
  {
    int a:1;
    int b:1;
    int c:1;
  };
} meinkram_t;

meinram_t meinkram;

meinkram.a = 0;
meinkram.b = 0;
meinkram.c = 1;

printf("meinkram %d", meinkram.wert);

... irgendwie will mir aber der der Sinn des ganzen nicht so recht 
einfallen.

[bitsetzer (Gast)]

Rufus Τ. F. schrieb:

> bitsetzer schrieb:
>> Ich möchte gerne bei bitfields3 (3 BIT) 1 0 0 bzw 0 0 1 die Ausgabe mit
>> Format %d   4 bzw 1 haben
>
> Du möchtest, daß die einzelnen Bits im Bitfeld in den Wert eines Bits
> innerhalb eines Bytes/ints/wasauchimmer übersetzt werden?

Ja - ausreichen würde mir erstmal Bytes ( char ) .

>
> Das kannst Du -- mit Portabilitätsproblemen -- durch Gebrauch einer
> union mit einem int erreichen,
>
> d.h.
> typedef union
> {
>   int wert;
>   {
>     int a:1;
>     int b:1;
>     int c:1;
>   };
> } meinkram_t;
>
> meinram_t meinkram;
>
> meinkram.a = 0;
> meinkram.b = 0;
> meinkram.c = 1;
>
> printf("meinkram %d", meinkram.wert);
>

übersetzt er jetzt nicht auf anhieb, aber ich denke ich kann dir folgen, 
was du meinst.

meinkram.wert ändere ich mal zu meinkram
oder muss ich meinkram.wert noch definieren?


> ... irgendwie will mir aber der der Sinn des ganzen nicht so recht
> einfallen.

Spiele mit dem Bitsetzen rum.
Wenn ein Type nur 3 bit hat, wie initialiesiere ich den mit 0 ?

[bitsetzer (Gast)]

µc.c:91:9: error: 'meinkram_t' has no member named 'a'
 meinkram.a = 0;
         ^
µc.c:92:9: error: 'meinkram_t' has no member named 'b'
 meinkram.b = 0;
         ^
µc.c:93:9: error: 'meinkram_t' has no member named 'c'
 meinkram.c = 1;

typedef union
{
  int wert;
  {
    int a:1;
    int b:1;
    int c:1;
  };
} meinkram_t;

meinkram_t meinkram;

meinkram.a = 0;
meinkram.b = 0;
meinkram.c = 1;

// vorerst kommentiert
// printf("meinkram %d", meinkram.wert);

[Klaus Skibowski (Gast)]

typedef union
{
  int wert; <-- probier es mal ohne das ;
  {

[bitsetzer (Gast)]

Klaus Skibowski schrieb:
> typedef union
> {
>   int wert; <-- probier es mal ohne das ;
>   {

typedef union
{
  int wert
  {
    int a:1;
    int b:1;
    int c:1;
  } ;

} meinkram_t;

 meinkram_t meinkram;

//  meinkram.wert.a = 0;
//  meinkram.wert.b = 0;
//  meinkram.wert.c = 1;

// printf("meinkram %d", meinkram.wert);

µc.c:102:3: error: expected ':', ',', ';', '}' or '__attribute__' before 
'{' token
   {
   ^

[Rufus Τ. F. (rufus)]

Ich habe das ganze nicht durch einen Compiler gejagt, und dabei 
offensichtlich etwas übersehen.

typedef union
{
  int wert;
  struct {
    int a:1;
    int b:1;
    int c:1;
  };
} meinkram_t;

meinkram_t meinkram;

meinkram.a = 0;
meinkram.b = 0;
meinkram.c = 1;

printf("meinkram %d", meinkram.wert);

Dem (jetzt anonymen) Bitfeld fehlte das Schlüsselwort struct.

Wird meinkram als automatische Variable auf dem Stack angelegt, wird es 
aber zu merkwürdigen Effekten kommen. Zwar werden die drei 
Strukturelemente des Bitfelds hier beschrieben, aber die (verborgenen) 
restlichen Bits der Struktur bleiben uninitialisiert, so daß bei der 
Ausgabe von meinkram.wert merkwürdige Werte ausgegeben werden.

Das lässt sich mit

    memset(&meinkram, 0, sizeof (meinkram));

vor dem Beschreiben der Elemente des Bitfelds umgehen.


Das lässt sich compilieren, siehe hier:

https://goo.gl/84n5We

[bitsetzer (Gast)]

Rufus Τ. F. schrieb:

Ich teste das gleich danke!

..
> Wird meinkram als automatische Variable auf dem Stack angelegt, wird es
> aber zu merkwürdigen Effekten kommen. Zwar werden die drei
> Strukturelemente des Bitfelds hier beschrieben,

genau

> aber die (verborgenen)
> restlichen Bits der Struktur bleiben uninitialisiert,

um das geht es Rufus!
Wie kann man diese auf 0 setzen?

> so daß bei der
> Ausgabe von meinkram.wert merkwürdige Werte ausgegeben werden.

Genau so ist es!

>
> Das lässt sich mit    memset(&meinkram, 0, sizeof (meinkram));
>
> vor dem Beschreiben der Elemente des Bitfelds umgehen.

Teste ich gleich

[bitsetzer (Gast)]

ohne

 memset(&meinkram, 0, sizeof (meinkram));

C:\bits>µc.exe
Mask3: 2130567169 a:-1  b:0  c:0
Mask8: 2686721 a:-1  b:0  c:0
Mask3: 2130567172 a:0  b:0  c:-1
Mask8: 2686724 a:0  b:0  c:-1
Groesse struct  (3) : 4
Groesse struct  (8) : 4
Groesse typedef (3) : 4
Groesse typedef (8) : 4
meinkram 4194436

mit

 memset(&meinkram, 0, sizeof (meinkram));

C:\bits>gcc µc.c -o µc.exe
µc.c: In function 'main':
µc.c:115:1: warning: incompatible implicit declaration of built-in 
function 'memset' [enabled by def
 memset(&meinkram, 0, sizeof (meinkram));
 ^

C:\bits>µc.exe
Mask3: 2130567169 a:-1  b:0  c:0
Mask8: 2686721 a:-1  b:0  c:0
Mask3: 2130567172 a:0  b:0  c:-1
Mask8: 2686724 a:0  b:0  c:-1
Groesse struct  (3) : 4
Groesse struct  (8) : 4
Groesse typedef (3) : 4
Groesse typedef (8) : 4
meinkram 4
C:\bits>

Genau dieses Ergebnis wollte ich haben!
Die anderen ( Mask3, Mask8 ) sind unvorhergesehen,
ich werde diese auch einmal miz memset vor dem beschreiben
testen.


Vielen Dank Rufus, muss das erst mal genauer ansehen
um es besser zu verstehen. Wo liegt das Geheimnis?
Union ?

[bitsetzer (Gast)]

#include <stdio.h>
#include <stdlib.h>


typedef struct bitfields3 {
  /*unsigned char*/ int a : 1;
  /*unsigned char*/ int b : 1;
  /*unsigned char*/ int c : 1;
} bitfields3_t;


typedef struct bitfields8 {
  /*unsigned char*/ int a : 1;
  /*unsigned char*/ int b : 1;
  /*unsigned char*/ int c : 1;

        // TEST
  /*unsigned char*/ int d : 1;
  /*unsigned char*/ int e : 1;
  /*unsigned char*/ int f : 1;
  /*unsigned char*/ int g : 1;
  /*unsigned char*/ int h : 1;
} bitfields8_t;


void main ( void ) {

bitfields3_t mask3;
bitfields8_t mask8;


// Test ohne memset:
// beabsichtigt : 0 0 0 0 0 0 0 1
mask3.a = 1;  // ( b0 )
mask3.b = 0;  // ( b1 )
mask3.c = 0;  // ( b2 )


// Test ohne memset:
// beabsichtigt 0 0 0 0 0 1 0 0
mask8.a = 0;  // ( b0 )
mask8.b = 0;  // ( b1 )
mask8.c = 1;  // ( b2 )
mask8.d = 0;  
mask8.e = 0;
mask8.f = 0;
mask8.g = 0;
mask8.h = 0;


printf("Mask3: %i a:%d  b:%d  c:%d\n", mask3, mask3.a, mask3.b, mask3.c);
printf("Mask8: %i a:%d  b:%d  c:%d\n", mask8, mask8.a, mask8.b, mask8.c);




// danke Rufus! das fehlte bei mir.
memset(&mask3, 0, sizeof (mask3));

// 0 0 0 0 0 0 0 1
mask3.a = 1;  // ( b0 )
mask3.b = 0;  // ( b1 )
mask3.c = 0;  // ( b2 )


// danke Rufus! das fehlte bei mir.
memset(&mask8, 0, sizeof (mask8));

// 0 0 0 0 0 1 0 0
mask8.a = 0;  // ( b0 )
mask8.b = 0;  // ( b1 )
mask8.c = 1;  // ( b2 )
mask8.d = 0;
mask8.e = 0;
mask8.f = 0;
mask8.g = 0;
mask8.h = 0;

printf("Mask3: %i a:%d  b:%d  c:%d\n", mask3, mask3.a, mask3.b, mask3.c);
printf("Mask8: %i a:%d  b:%d  c:%d\n", mask8, mask8.a, mask8.b, mask8.c);


// test sizeof struct:
printf ("Groesse struct  (3) : %d\n", sizeof(struct bitfields3) );
printf ("Groesse struct  (8) : %d\n", sizeof(struct bitfields8) );

// test sizeof type
printf ("Groesse typedef (3) : %d\n", sizeof(bitfields3_t) );
printf ("Groesse typedef (8) : %d\n", sizeof(bitfields8_t) );



// rufus mit union :

typedef union
{
  int wert;
  struct {
    int a:1;
    int b:1;
    int c:1;
  };
} meinkram_t;

meinkram_t meinkram;

memset(&meinkram, 0, sizeof (meinkram));

meinkram.a = 0;
meinkram.b = 0;
meinkram.c = 1;

printf("meinkram %d", meinkram.wert);

}

C:\bits>gcc µc.c -o µc.exe
µc.c: In function 'main':
µc.c:58:1: warning: incompatible implicit declaration of built-in function 'memset' [enabled by default]
 memset(&mask3, 0, sizeof (mask3));
 ^

C:\bits>µc.exe
Mask3: 2130567169 a:-1  b:0  c:0       // willkur andere bits
Mask8: 2686724 a:0  b:0  c:-1          // willkur andere bits
Mask3: 1 a:-1  b:0  c:0                // memset ok, a: -1 ??
Mask8: 4 a:0  b:0  c:-1                // memset ok, c: -1 ??
Groesse struct  (3) : 4
Groesse struct  (8) : 4
Groesse typedef (3) : 4
Groesse typedef (8) : 4
meinkram 4
C:\bits>

Eine Frage noch:
Warum  erscheint ein Bit (a:-1) (c:-1) als negativ ?

[bitsetzer (Gast)]

Kann man sagen, dass immer der erste Eintrag das LSB Bit ist,
example:
meinkram.a  BIT0 ( LSB ) ist
und dann nach oben geht (MSB) ?

meinkram.a = 0;  // BIT0
meinkram.b = 0;  // BIT1
meinkram.c = 1;  // BIT2

Danke!

[Rufus Τ. F. (rufus)]

Du machst Dir das Leben unnötig schwer.

Bitfelder sind dafür da, damit man sich eben nicht mit der Wertigkeit 
einzelner Bits beschäftigen muss.

Wenn Du das willst, brauchst Du keine Bitfelder.

int x;

x = (1 << 2);

printf("%d\n", x);

x += (1 << 4);

printf("%d\n", x);

Lies Dir mal in Deinem C-Buch das Kapitel über Bitmanipulation durch.

[Carl D. (jcw2)]

bitsetzer schrieb:
> Eine Frage noch:
> Warum  erscheint ein Bit (a:-1) (c:-1) als negativ ?

Welche Werte kann wohl ein int mit 1Bit Breite annehmen?

0 und -1

Falls du 0 und 1 haben willst, das wäre unsigned.

[bitsetzer (Gast)]

Jetzt ist es viel klarer, vielen Dank.

Ausgegangen war der Gedanke von so einem Define, über das ich mir den 
Kopf zerbrochen habe, wie man solche defines für Bitmanipulation / 
setzen zu nutze machen kann.

Hätte da jemand ein Beispiel?

#define auto_map [5:3]

[Rufus Τ. F. (rufus)]

bitsetzer schrieb:
> #define auto_map [5:3]

Das ist kein C.

[bitsetzer (Gast)]

Rufus Τ. F. schrieb:
> bitsetzer schrieb:
>> #define auto_map [5:3]
>
> Das ist kein C.

HA - und ich depp hab mir den Kopf zerbrochen!
Irretiert von "Python has C style bit manipulation operators"
aus diesem Fundus:
http://stackoverflow.com/questions/147713/how-do-i-manipulate-bits-in-python/150411#150411

wollte ich mir wahrscheinlich diesen Vector

b = BitVector(0)
 b[3:0]   = 0xD
 b[7:4]   = 0xE
 b[11:8]  = 0xA
 b[15:12] = 0xD

in C einreden,
oh Mann, danke Rufus!
Das war zuviel Wald heute - der "Ausgangs" Baum war irgendwie 
verschwunden.

Jetzt bin ich erleichtert.

[bitsetzer (Gast)]

Quer gefragt, gibt es sowas für C auch?

[Rufus Τ. F. (rufus)]

Ich kenne Python nicht, aber das sieht mir irgendwie nach einem Bitfeld 
aus.

struct
{
  unsigned int a:4;
  unsigned int b:4;
  unsigned int c:4;
  unsigned int d:4;
} x;

x.a = 0xD;
x.b = 0xE;
x.c = 0xA;
x.d = 0xD;

[bitsetzer (Gast)]

struct
{
  unsigned int a:4;
  unsigned int b:4;
  unsigned int c:4;
  unsigned int d:4;
} x;

x.a = 0xD;
x.b = 0xE;
x.c = 0xA;
x.d = 0xD;

printf("0xD : %d\n", x.a);
printf("0xE : %d\n", x.b);
printf("0xA : %d\n", x.c);
printf("0xD : %d\n", x.d);

printf("Size of unsigned int: %d\n", sizeof(unsigned int));
printf("Size of struct x    : %d\n", sizeof(x));

Ausgabe:

0xD : 13
0xE : 14
0xA : 10
0xD : 13
Size of unsigned int: 4
Size of struct x    : 4

Perfect! Du hast was gut bei mir.
Genau so brauch ich das auch.

Mal nachgefragt, warum braucht man hier jetzt kein memset?
Das Size vom x verstehe ich nur bedingt.

[bitsetzer (Gast)]

Nur mal als Test:

truct
{
  unsigned int a;
  unsigned int b;
  unsigned int c;
  unsigned int d;
} x;

x.a = 0xD;
x.b = 0xE;
x.c = 0xA;
x.d = 0xD;

printf("0xD : %d\n", x.a);
printf("0xE : %d\n", x.b);
printf("0xA : %d\n", x.c);
printf("0xD : %d\n", x.d);

printf("Size of unsigned int: %d\n", sizeof(unsigned int));
printf("Size of struct x    : %d\n", sizeof(x));

0xD : 13
0xE : 14
0xA : 10
0xD : 13
Size of unsigned int: 4
Size of struct x    : 16

[Rufus Τ. F. (rufus)]

bitsetzer schrieb:
> Mal nachgefragt, warum braucht man hier jetzt kein memset?

Ob man es braucht oder nicht kommt auf den Gebrauch des Bitfelds an.
Wenns auf dem Stack angelegt wird, werden die "Lücken" im Bitfeld nicht 
initialisiert. Da Du aber auch nicht das Bitfeld als gesamtes, sondern 
nur die definierten Teilelemente ausgibst, kann Dir das aber auch egal 
sein.

> Das Size vom x verstehe ich nur bedingt.

Ein Bitfeld ist üblicherweise so groß wie ein (unsigned) int oder ein 
vielfaches davon. Da Du ein 32-Bit-System einsetzt, ist sizeof int bei 
Dir 4, und damit auch das Bitfeld 4 Bytes groß.