Spaß mit Bits



  • Hey,

    um die Netzwerklast vom meinem Programm weiter zu reduzieren, möchte ich gerne einige Bytes einsparen. Das ist auch möglich, da die überflüssigen Bytes nur sehr kleine Zahlen darstellen und ich sie daher alle problemlos in ein Byte bekommen könnte.

    Zugreifen möchte ich im Byte auf folgende Bits:
    Bit 1-5 (Wertbereich 0-32)
    Bit 6-7 (Wertbereich 0-4)
    Bit 8 (Wertbereich 0-1)

    Wie kann man das am sinnvollsten angehen?

    Das Auslesen könnte man vermutlich mit >> und << gut erledigen, wenn man einfach die überflüssigen Bits zur Seite schiebt. Oder ist das vielleicht keine gute Idee?

    Aber wie setze ich die entsprechenden Bits?

    Bin sehr gepsannt auf eure Ideen und Anmerkungen 🙂



  • Dafür würde ich bitset verwenden.
    http://www.cplusplus.com/reference/stl/bitset/



  • Ich würds gerne ohne std::bitset lösen. Alle Operationen sollen auf einem unsigned char ausgeführt werden.



  • Für Setzen:

    c |= (1 << position)

    Für Löschen:

    c &= ~(1 << position)

    Für Lesen:

    v = (c >> position) & 1

    Man muss halt mit Big und Little Endian aufpassen. D.h. diese Lösung ist nicht portabel, glaub ich. Aber weiß ich nicht so genau.



  • Eisflamme schrieb:

    Für Setzen:

    c |= (1 << position)

    Für Löschen:

    c &= ~(1 << position)

    Für Lesen:

    v = (c >> position) & 1

    Man muss halt mit Big und Little Endian aufpassen. D.h. diese Lösung ist nicht portabel, glaub ich. Aber weiß ich nicht so genau.

    Hallo Eisflamme,

    die Endianess spielt hier absolut gar keine Rolle, da es sich nur um ein einzelnes Byte handelt. Im übrigen gilt in der Netzwerkprogrammierung eh die Network-Byte-Order.

    Mir geht es einfach darum, das ich möglichst geschickt an die von mir beschrieben Bits komme, um sie lesen und setzen zu können. Bei der Zahl 16 reicht es z.B. nicht, wenn ich nur ein Bit setze oder lese, da mehrere Bits zur Darstellung notwendig sind.



  • Um ein einzelnes Bit zu lesen, kannst du das Byte nach rechts shiften und dann mit 1 verknüpfen:

    (byte >> 3) & 1; // Ergibt Bit 3
    

    Um mehrere Bit zu bekommen musst du deine Bitmaske so ändern, dass dort alle Bits gesetzt sind, die du aus dem Byte haben willst:

    (byte >> 2) & ((1 << 2) | (1 << 3) | ......); // Ergibt die Bits 4(2+2) und 5(2+3)
    

    Zum setzen eines bestimmten Bits nimmst du das Bitweis-Oder:

    byte |= (1 << 3); // Setzt das dritte Bit
    

    Zum setzen mehrerer Bits:

    byte |= ((1 << 2) | (1 << 5) | ......); // Setzt die Bits 2 und 5
    

    Zum Löschen eines Bits:

    byte &= ~(1 << 2); // Löscht Bit 2
    

    Mehrere Bits löschen:

    byte &= ~((1 << 4) | (1 << 5) | ......); // Löscht Bits 4 und 5
    

    Ein Byte "flippen":

    byte ^= (1 << 4); // Flippt Bit 4
    

    Flippen mehrerer Bits:

    byte ^= ((1 << 2) | (1 << 6) | ......); // Flippt Bits 2 und 6
    

    Hoffe das ist jetzt richtig so, ist ungetestet.
    Vergiss aber nicht, dass du bei 0 zu zählen anfängst. 😉



  • <rampage>
    Na dann mach doch das entsprechende für mehrere Bits. Ich raffs nicht... dafür sind doch Masken etc da.
    Ich hasse es, wenn jemand mit soner Simpelfrage ankommt und dann gut gemeinten Rat mit Klugscheißerei abschmettert.
    Und klar spielt die Endianness hier eine Rolle, nämlich auf welcher Seite der Anpassung du die Bitsachen betreibst.
    </rampage>



  • Decimad schrieb:

    <rampage>
    Na dann mach doch das entsprechende für mehrere Bits. Ich raffs nicht... dafür sind doch Masken etc da.
    Ich hasse es, wenn jemand mit soner Simpelfrage ankommt und dann gut gemeinten Rat mit Klugscheißerei abschmettert.
    Und klar spielt die Endianness hier eine Rolle, nämlich auf welcher Seite der Anpassung du die Bitsachen betreibst.
    </rampage>

    Varriert etwa auch die Reihenfolge der Bits auf unterschiedlichen Systemen?



  • Es soll auch Systeme geben, die nicht 8 Bit haben 😃



  • 314159265358979 schrieb:

    Es soll auch Systeme geben, die nicht 8 Bit haben 😃

    Ja, das ist klar. Trotzdem sollte man es mit Portabilität nicht übetreiben. Mein Programm hat auf einem Toaster schließlich nichts zu suchen.



  • Nur mal so als Anmerkung:
    Was zum Geier erhofft man sich davon!?!?
    Mit DSL Anschlüssen ein paar bytes zu senden ist nun wirklich kein Aufwand - da muss man nicht mit bits rumfrickeln 😉



  • Wenn du nicht zu den leidgeplagten Programmieren gehörst, die schneller Essen können als der Toaster toasten, siehst du das natürlich ganz anders 😉



  • cooky451 schrieb:

    Nur mal so als Anmerkung:
    Was zum Geier erhofft man sich davon!?!?
    Mit DSL Anschlüssen ein paar bytes zu senden ist nun wirklich kein Aufwand - da muss man nicht mit bits rumfrickeln 😉

    Es ist letztendlich auch einfach eine Übung, da ich mich im Umgang mit Bits nicht so sicher fühle - und das zu recht, wie man sieht.

    Ich hatte nun folgende Idee um an die entsprechenden Werte zu kommen:

    c = 255

    c & 0x1F; // Bitmaske 00011111 [ ergibt 31]
    c & 0x60; // Bitmaske 01100000 [ ergibt 96]
    c & 0x80; // Bitmaske 10000000 [ ergibt true]

    Der erste Wert erscheint mir absolut plausibel, aber leider kommen bei den folgenden Operationen nicht die Werte raus, die ich erwarten würde. So ergibt die zweite Operation als Ergebnis 96, was nicht sein kann, da ich mit 2 Bits die Zahl 96 gar nicht darstellen kann. Hier läuft also etwas schief.

    Wäre über Hilfe sehr dankbar.



  • Ich habe dir doch gesagt, wie du das machen kannst.



  • Mit & maskierst du nur die Bits, du veränderst aber nicht ihre Wertigkeit.



  • Es leuchtet mir einfach nicht ein.

    (byte >> 2) & ((1 << 2) | (1 << 3) | ......); // Ergibt die Bits 4(2+2) und 5(2+3)

    Wozu ist das byte >> 2 und warum 2 + 2 und 2 + 3?

    Ich komme einfach nicht dahinter.



  • ghjghj schrieb:

    ...

    Ich hatte nun folgende Idee um an die entsprechenden Werte zu kommen:

    c = 255

    c & 0x1F; // Bitmaske 00011111 [ ergibt 31]
    c & 0x60; // Bitmaske 01100000 [ ergibt 96]
    c & 0x80; // Bitmaske 10000000 [ ergibt true]

    Der erste Wert erscheint mir absolut plausibel, aber leider kommen bei den folgenden Operationen nicht die Werte raus, die ich erwarten würde. So ergibt die zweite Operation als Ergebnis 96, was nicht sein kann, da ich mit 2 Bits die Zahl 96 gar nicht darstellen kann. Hier läuft also etwas schief.

    Wäre über Hilfe sehr dankbar.

    c & 0x60; // Bitmaske 01100000 [ ergibt 96]
    // ((c & 0x60)>>5) == 3
    

    💡



  • unsigned char gepackt; // <- Dein Konstrukt
    unsigned char echt;
    
    // Lesen:
    // 0-4
    echt = gepackt & 0x1F;
    // 5-6
    echt = (gepackt >> 5) & 0x03;
    // 7
    echt = gepackt >> 7;
    
    // Setzen:
    // 0-4
    gepackt = (gepackt & 0xE0) | echt; // zur Sicherheit auch: "| (echt & 0x1f)"
    // 5-6
    gepackt = (gepackt & 0x9F) | (echt << 5); // zur Sicherheit auch: "| ((echt & 0x03) << 5)"
    // 7
    gepackt = (gepackt & 0xEF) | (echt << 7); // zur Sicherheit auch: "| ((echt & 0x01) << 7)"
    

    Unsigned ist wichtig für's Rechtsshiften.

    Hab's nicht getestet. Hoffe, es stimmt alles.
    Aber vielleicht gehts ja noch einfacher?



  • Für das erste Ding brauchst du ab dem ersten Bit fünf Stück:
    (c>>0) & ((1<<5)-1)

    Für das zweite Ding brauchst du ab dem sechsten Bit zwei Stück:
    (c>>5) & ((1<<2)-1)

    Für das dritte brauchst du ab dem achten Bit eins:
    (c>>7) & ((1<<1)-1)



  • Ich das nun der Einfachheit mal mit nur 2 Werten versucht. Das Auslesen klappt sehr gut, aber das setzen nicht.

    #include <iostream>
    
    #define MASK_BIT1 (1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4)
    #define MASK_BIT2 (1 << 0 | 1 << 1 | 1 << 2)
    
    int get_bits1(unsigned char c)
    {
    	// Start: 11111111
    
    		     // => 76543210
    	c >>= 3; // => 00011111
    
    	return c & MASK_BIT1;
    }
    
    int get_bits2(unsigned char c)
    {
    	// Start: 11111111
    
    			 // => 76543210
    	c >>= 5; // => 00000111
    
    	return c & MASK_BIT2;
    }
    
    void set_bits1(unsigned char& c, unsigned char val)
    {
    	// Start: 
    	//	c = 00000000
    	//	val = 00011111
    
    	c = (val & MASK_BIT1) | (c << 3); // ???
    }
    
    void set_bits2(unsigned char& c, unsigned char val)
    {
    }
    
    int main()
    {
    	unsigned char c = 0;
    
    	set_bits1(c, 24);
    	set_bits2(c, 6);
    
    	std::cout << get_bits1(c) << std::endl;
    	std::cout << get_bits2(c) << std::endl;
    
    	return 0;
    }
    

    Ich würde gerne den Wert von val in die entsprechenden Bits schreiben. Leider kommen nicht wieder die Werte raus, die ich übergeben habe. Ich hatte es einmal geschafft, das zumindest set_bits1 klappt, aber set_bits2 hat die Werte wieder kaputt gemacht. Ich hab jetzt so viele Varianten ausprobiert... Hier fehlt mir wieder das Verständnis.


Log in to reply