2bit Variablen

[Peter F. (Gast)]

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...

Gruß
Peter

[Michael U. (amiga)]

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

[Philipp F. (nerdture)]

Nennt sich "Bit fields" und geht so:

#include "stdio.h"

struct packed_struct {
 unsigned int f1:2;
 unsigned int f2:2;
 unsigned int f3:2;
 unsigned int f4:2;
} pack;

int main() {
 struct packed_struct test;
 test.f1 = 3;
 test.f2 = 0;
 test.f3 = 1;
 test.f4 = 2;


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

(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 ;)

[Gerd (Gast)]

Du sagst leider nicht für welchen Prozessor und in welcher Sprache Du 
schreibst.

Aber, von Exoten abgesehen, ist die Breite eines Speicherwortes meist 8, 
16 oder 32 Bit. Ein geradzahliges Vielfaches von 8 (abgesehen von 8 
selbst).

>Ich könnte zwar die 8bit in 4 mal 2 Bit aufteilen, aber das ist mir zu 
>umständlich...

Dennoch kannst Du nur so Deine Absicht erreichen, in dem Du Makros oder 
Funktionen in C schreibst (oder entsprechendes in anderen Sprachen).

[Karl H. (kbuchegg)]

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:

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

uint8_t Read( uint16_t index )
{
  uint8_t memPos = index / 4;   // weil 4 jeweils 2 Bit Werte in einen uint passen
  uint8_t bitPos = index % 4;
  uint8_t value = memory[memPos];

  switch( bitPos ) {
    case 0:
      return ( value & 0xC0 ) >> 6;

    case 1:
      return ( value & 0x30 ) >> 4;

    case 2:
      return ( value & 0x0C ) >> 2;

    case 3:
      return ( value & 0x03 );
  }
}

void Write( uint16_t Index, uint8_t value )
{
  uint8_t memPos = index / 4;   // weil 4 jeweils 2 Bit Werte in einen uint passen
  uint8_t bitPos = index % 4;

  value &= ~0x03;

  switch( bitPos ) {
    case 0:
      memory[memPos] = ( memory[memPos] & ~0xC0 ) | ( value << 6 );
      break;

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

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

    case 3:
      memory[memPos] = ( memory[memPos] & ~0x03 ) | value;
      break;
  }
}

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.