2bit Variablen

Hallo,

naja, wenn Du es nicht machst, muß es der Compiler machen. Ob es reale 
Vorteile bringt, hängt u.a. vom uns unbekannten Prozessortyp ab...

Gruß aus Berlin
Michael

Nennt sich "Bit fields" und geht so:

1

#include "stdio.h"

2

3

struct packed_struct {

4

 unsigned int f1:2;

5

 unsigned int f2:2;

6

 unsigned int f3:2;

7

 unsigned int f4:2;

8

} pack;

9

10

int main() {

11

 struct packed_struct test;

12

 test.f1 = 3;

13

 test.f2 = 0;

14

 test.f3 = 1;

15

 test.f4 = 2;

16

17

18

 printf("0x%02X", *((unsigned char *)&test) );

19

}

(Hinter dem Doppelpunkt immer die Anzahl der bits)
Je nachdem was du für einen prozessor hast solltest du das struct auch 
komplett füllen (Für 8-bit prozessoren so wie oben) ums auszunutzen.

Das Beisiel gibt "0x93" aus was in binär wäre: 10 01 00 11 ;)

Peter F. schrieb:
> Ich arbeite gerade an einem realtiv speicherintensiven Programm. Daher
> bin ich bestrebt, den Code soweit als möglich zu schrumpfen. Das
> Programm verarbeitet hauptsächlich Variablen mit den Werten 0,1,2 oder
> 3, also im Grunde 2bit. Ist es möglich eine Variabel so zu deklarieren,
> dass auch auch bloß 2bit Speicherplatz benötigt? Ich könnte zwar die
> 8bit in 4 mal 2 Bit aufteilen, aber das ist mir zu umständlich...

Das wird immer umständlich bleiben.
Die kleinste natürliche Einheit in C ist das Byte.
Man kann zwar ein Bitfeld definieren, und der Compiler nimmt einem dann 
die ganze Maskiererei ab, aber in deinem Fall ist das nicht so toll

Wenn deine 'vielen Variablen' sich in einem Array abbilden lassen, dann 
reicht es doch im ersten Ansatz 2 Zugriffsfunktionen zu definieren:

1

uint8_t memory[100];  // Platz für 400 2-Bit Variablen

2

3

uint8_t Read( uint16_t index )

4

{

5

  uint8_t memPos = index / 4;   // weil 4 jeweils 2 Bit Werte in einen uint passen

6

  uint8_t bitPos = index % 4;

7

  uint8_t value = memory[memPos];

8

9

  switch( bitPos ) {

10

    case 0:

11

      return ( value & 0xC0 ) >> 6;

12

13

    case 1:

14

      return ( value & 0x30 ) >> 4;

15

16

    case 2:

17

      return ( value & 0x0C ) >> 2;

18

19

    case 3:

20

      return ( value & 0x03 );

21

  }

22

}

23

24

void Write( uint16_t Index, uint8_t value )

25

{

26

  uint8_t memPos = index / 4;   // weil 4 jeweils 2 Bit Werte in einen uint passen

27

  uint8_t bitPos = index % 4;

28

29

  value &= ~0x03;

30

31

  switch( bitPos ) {

32

    case 0:

33

      memory[memPos] = ( memory[memPos] & ~0xC0 ) | ( value << 6 );

34

      break;

35

36

    case 1:

37

      memory[memPos] = ( memory[memPos] & ~0x30 ) | ( value << 4 );

38

      break;

39

40

    case 2:

41

      memory[memPos] = ( memory[memPos] & ~0x0C ) | ( value << 2 );

42

      break;

43

44

    case 3:

45

      memory[memPos] = ( memory[memPos] & ~0x03 ) | value;

46

      break;

47

  }

48

}

Recht viel anderes kann dir der Compiler auch nicht mit einem Bitfeld 
bieten, nur dass du hier das Array ev. einen Tick besser benutzen 
kannst.