Unterschiedliche Anzahl von Bits maskieren?

#defien GET_MASK_BIT(N) ((1u << (N)) -1)

Für N = 0 ... 8*sizeof(int)-1

AVRli schrieb:
> GET_MASK_BITS(3); gibt nur die ersten 3 Bits zurück.

Du meinst sowas:

1

#define GET_MASK_BITS(x) ((1 << (x)) - 1)

?

edit: OK, Johann war schneller und genauer (an "unsigned" gedacht).

AVRli schrieb:
> Vielleicht habe ich mich auch unglücklich ausgedrückt,

Nein.

> doch das was
> holger beschrieben hat, ist das was ich gesucht habe.

Das, was Johann und ich geschrieben haben, ist es dann auch. ;-)

Holger benutzt halt eine tabellenbasierten Ansatz, Johann und ich
einen arithmetischen.  Die Tabelle ist schneller, braucht aber
bei größeren zulässigen Operanden schnell viel Platz.

AVRli schrieb:

> Aber ganz ehrlich die andere Richtung bekomme ich so nicht hin...

kleiner Tip.

Wenn du in einem Byte nur die untersten 5 Bits auf 1 hast, dann sind 
logischerweise die obersten 3 Bits auf 0  (weil 5 + 3 wieder die 8 Bits 
in einem Byte ergeben).
Dreht man dann in dem so erhaltenen Byte die Bits einfach alle um, dann 
hat man ein Byte, bei dem die obersten 3 Bits auf 1 sind und die unteren 
5 Bits auf 0.

Um also ein Byte zu erhalten, bei dem die obersten n Bits auf 1 sind, 
genügt es sich ein Byte zu machen, bei dem die unteren (8-n)Bits auf 1 
sind und dann einfach alle Bits umzudrehen.
Und wie man sich ein Byte macht, bei dem die unteren m Bits auf 1 sind, 
dafür hast du ja schon eine Funktion :-)

Bsp. Du brauchst ein Byte, bei dem die oberen 2 Bits auf 1 sind.

Zu erzeugen ist also                      0b11000000
------------------------------------------------------
Dazu erzeugst du dir ein Byte,
bei dem die unteren 6 Bits auf 1 sind     0b00111111
und drehst alle Bits um                   0b11000000

Für die high-Bits muss man doch nur die unteren Bits wegschieben:

1

#define MASK_HIGH(N) (-1u << (8-(N)))

-1u ist ein unsigned, der alle Bits gesetzt hat. Alternativ geht auch

UINT_MAX aus limits.h oder, falls 16-Bit int, UINT16_MAX aus stdint.h

Um zB eine Maske zu bekommen, die jedes 3. Bit gesetzt hat, kann man 
einfach

1

unsigned long mask_jedes_3te_bit = -1ul / 7; // 0x24924924

oder eine Maske, die abwechselnd immer 3 Bits gesetzt und leer hat:

1

unsigned long mask_mit_3er_paketen = -1ul / 9; // 0x1C71C71C

AVRli schrieb:
> Nur ganz ehrlich... nicht lachen Warum das so klappt ist mir ein
> Rätsel... :-D

Es beruht auf folgender Faktorisierung:

Oben ist b=2, d.h. es ist für Zahlen in Binärdarstellung, aber die 
Faktorisierung geht genauso für alle anderen b-ären Darstellungen.

Z.B ist 111111 immer durch 111 und duch 11 teilbar, unabhängig vom 
Zahlensystem, in dem diese Zahlen dargestellt sind.

asdf schrieb:
> Johann L. schrieb:
>> unsigned long mask_jedes_3te_bit = -1ul / 7; // 0x24924924
>
> Hm, wobei mich das -1u oder -1ul auch eher irritieren würde.
>
> Warum nicht 0xffff oder 0xffffffff etc. je nach Anzahl Bits, dann ist
> sofort klar dass es ein uint16_t/uint32_t mit allen Bits auf 1 gesetzt
> ist.

Da muss man aber erst die 'f's nachzählen. Bei 16 Bit ist das noch
leicht, bei 32 Bit schon etwas ungemütlich und bei 64 Bit ziemlich
fehlerträchtig ;-)

Wenn dich nur die Negation des unsigned-Werts stört, kannst du auch

1

unsigned long mask_jedes_3te_bit = ~0ul / 7; // 0x24924924

schreiben.