Grabbit 1 und 6, und 2 bis 5 in einem unsigned Char in C

Question

Ich habe ein Zeichen ohne Vorzeichen mit 6 Bytes lang. Der Wert innerhalb des char gespeichert ist:

Hex: 53167DFD95B7 
Binary: 010100 110001 011001 111101 111111 011001 010110 110111 

Was ich tun muss, ist Capture-Bit 1 und Bit 6. Dann, dass in eine Dezimalzahl umwandeln. Dann erfassen Sie Bit 2-5 und konvertieren Sie das in Dezimal Zum Beispiel ist Bit 1 hier 0, Bit 6 ist 0, also binär 00, ist dezimal 0. Dann für Bit 2-5, binär 1010 oder dezimal 10. Dann bewegen zur nächsten Gruppe von 6 Bits.

Bit 1 = 1, Bit 6 gleich 1 ist, so binär 11 oder dezimal 3 Bit 2-5 ist binär 1000 oder dezimal 8

Bit 1 = 0, Bit 6 = 1, 01 so binäre oder dezimal 1 Bit 2-5 ist binär 1100 oder dezimal 12

Und so weiter für die verbleibenden Gruppen von 6 Bits.

Ich bin nicht wirklich sicher, wie ich maskieren sollte, Verschiebung dafür. Da dies nur 6 Bits gleichzeitig sind, habe ich einige Schwierigkeiten. Jede Hilfe mit diesem würde sehr geschätzt werden! Vielen Dank im Voraus.

EDIT

int getBitVal(unsigned char *keyStrBin, int keyIndex) { 

    int keyMod = keyIndex % 8; 
    int keyIn = keyIndex/8; 

    return (((keyStrBin[keyIn]) >> (7 - (keyMod))) & 1); 

} 
void getSValueMajor(char **tableS, unsigned char *f, unsigned char *sValue) { 
    int i, bitOne, bitSix; 
    int sCol; 

    for (i = 0; i < 8; i++) { 
     bitOne = getBitVal(f, 0); 
     bitSix = getBitVal(f, 5); 
     // Do something here to get only bits 2-5. Doesn't matter if its decimal. Just need the 4 bits. 

    } 

} 

Ill Verschiebung um 6 Bits I am Ende der Schleife erraten auf die nächsten 6 Bits zu gehen, aber nicht sicher, wie diese 4 Bits in eine Variable zu lesen.

Answer 1

Ich habe dies aktualisiert, weil ein Kommentator erwähnt, dass es keine reellen Zahlen verwendet. Ich weiß das, aber der Punkt war, etwas demjenigen zu überlassen, der seine Hausaufgaben macht.

Das Folgende ist keine saubere Antwort, aber es sollte jedem, der dazu kommt, eine Idee geben, wie man es auf eine saubere Art und Weise lösen kann. In der zweiten Methode habe ich eine Zeichenfolge als das Ding verwendet, das ich umwandle, und dies in eine Binärzahl umgewandelt und von dort habe ich ein paar Manipulationen vorgenommen.

Mit allem, was in wenig das Hantieren gibt es immer Möglichkeiten, die Dinge zu beschleunigen, dh Sie Masken für alle 8 Bytes nutzen könnten einige Verschiebungen zu vermeiden, können Sie auch die Schleife usw.

#include <assert.h> 
#include <stdint.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
/* 
010100 == 00 , 1010 === 0 , 10 
110001 == 11 , 1000 === 3 , 8 
011001 == 10 , 1100 === 2 , 12 
111101 == 11 , 1110 === 3 , 14 
111111 == 11 , 1111 === 3 , 15 
011001 == 01 , 1100 === 1 , 12 
010110 == 00 , 1011 === 0 , 11 
110111 == 11 , 1011 === 3 , 11 
*/ 
int main(void) { 
    size_t x = 48; 
    size_t v = 91356068156855; 

    size_t one66 = 0; 
    size_t two55 = 0; 
    size_t bit1 = 0; 
    size_t bit6 = 0; 

    //Masks 
    size_t sixty3 = 63; 
    size_t thirty = 30; 

    size_t b[8]; 
    b[0] = (v & (sixty3 << 42ULL)) >> 42ULL; 
    b[1] = (v & (sixty3 << 36ULL)) >> 36ULL; 
    b[2] = (v & (sixty3 << 30ULL)) >> 30ULL; 
    b[3] = (v & (sixty3 << 24ULL)) >> 24ULL; 
    b[4] = (v & (sixty3 << 18ULL)) >> 18ULL; 
    b[5] = (v & (sixty3 << 12ULL)) >> 12ULL; 
    b[6] = (v & (sixty3 << 6ULL)) >> 6ULL; 
    b[7] = (v & (sixty3 << 0ULL)) >> 0ULL; 

    for(x = 0; x < 8;x++) { 
    one66 = 0; 
    two55 = 0; 
    bit1 = (b[x] & 1) > 0; 
    bit6 = (b[x] & 32) > 0; 
    one66 |= bit1 << 1; 
    one66 |= bit6 << 0; 
    two55 = (b[x] & thirty) >> 1; 
    printf("%zu %zu\n", one66, two55); 
    } 

// Method 2 using a string as the input... 
//     |  |  |  |  |  |  |  |  
    char  pat[]  = "010100110001011001111101111111011001010110110111"; 
    size_t patlength = strlen(pat); 
    for(x = 0; x < patlength; x += 6) { 
    size_t one6 = 0; 
    size_t two5 = 0; 
    if(pat[x] == '1') { 
     one6 |= 1ULL << 0; 
    } 
    if(pat[x + 5] == '1') { 
     one6 |= 1ULL << 1; 
    } 
    assert(one6 < 4); 
    if(pat[x + 1] == '1') { 
     two5 |= 1ULL << 3; 
    } 
    if(pat[x + 2] == '1') { 
     two5 |= 1ULL << 2; 
    } 
    if(pat[x + 3] == '1') { 
     two5 |= 1ULL << 1; 
    } 
    if(pat[x + 4] == '1') { 
     two5 |= 1ULL << 0; 
    } 
    assert(two5 < 16); 
    printf("%zu %zu\n", one6, two5); 
    } 
    return 0; 
}