Convertir en Tableau d'Octets en Bitset

J'ai un tableau d'octets générés par un générateur de nombre aléatoire. Je veux tout mettre dans la STL bitset.

Malheureusement, il ressemble à Bitset seulement prend en charge les constructeurs:

  1. Une chaîne de 1 et de 0 comme "10101011"
  2. Un unsigned long. (mon tableau d'octets sera plus long)

La seule solution que je peux penser maintenant, c'est de lire le tableau d'octets peu à peu et de faire une chaîne de 1 et de 0. Quelqu'un aurait-il une solution plus efficace?

InformationsquelleAutor Unknown | 2009-04-02
  1. 7

    Quelque chose comme cela? (Pas sûr si le modèle de la magie fonctionne ici comme je l'avais espérer. Je suis rouillé en C++.)

    std::bitset bytesToBitset<int numBytes>(byte *data)
{
    std::bitset<numBytes * CHAR_BIT> b;

    for(int i = 0; i < numBytes; ++i)
    {
        byte cur = data[i];
        int offset = i * CHAR_BIT;

        for(int bit = 0; bit < CHAR_BIT; ++bit)
        {
            b[offset] = cur & 1;
            ++offset;   //Move to next bit in b
            cur >>= 1;  //Move to next bit in array
        }
    }

    return b;
}
    InformationsquelleAutor strager
  2. 3

    Il y a un 3ème constructeur pour bitset<> - il ne prend aucun paramètre et définit tous les bits à 0. Je pense que vous aurez besoin de l'utiliser ensuite à pied à travers la matrice d'appel set() pour chaque bit dans le tableau d'octets qui est un 1.

    Un peu de force brute, mais ça marchera. Il y aura un peu de complexité pour convertir l'octet de l'index et de bits de décalage à l'intérieur de chaque octet à un bitset index, mais rien qu'un peu de réflexion (et peut-être une course à travers sous le débogueur) ne suffit pas à résoudre. Je pense que c'est probablement plus simple et plus efficace que d'essayer d'exécuter le tableau par le biais d'une chaîne de conversion ou d'un ruisseau.

    InformationsquelleAutor Michael Burr
  3. 2

    Les gars, j'ai passé beaucoup de temps par l'écriture d'une fonction d'inversion (bitset -> byte/char array). Ça y est:

        bitset<SIZE> data = ...

    //bitset to char array
    char current = 0;
    int offset = 0;
    for (int i = 0; i < SIZE; ++i) {
        if (data[i]) { //if bit is true
            current |= (char)(int)pow(2, i - offset * CHAR_BIT); //set that bit to true in current masked value
        } //otherwise let it to be false
        if ((i + 1) % CHAR_BIT == 0) { //every 8 bits
            buf[offset++] = current; //save masked value to buffer & raise offset of buffer
            current = 0; //clear masked value
        }
    }

    //now we have the result in "buf" (final size of contents in buffer is "offset")
    InformationsquelleAutor Honza Javorek
  4. 2

    Bien, soyons honnête, je me suis ennuyé et a commencé de penser qu'il devait être un peu plus rapide que la création de chaque bit.

    template<int numBytes>
std::bitset<numBytes * CHARBIT bytesToBitset(byte *data)
{
    std::bitset<numBytes * CHAR_BIT> b = *data;

    for(int i = 1; i < numBytes; ++i)
    {
        b <<= CHAR_BIT;  //Move to next bit in array
        b |= data[i];    //Set the lowest CHAR_BIT bits
    }

    return b;
}

    C'est en effet légèrement plus rapide, au moins aussi longtemps que le tableau d'octets est inférieure à 30 éléments (en fonction de votre optimisation des indicateurs transmis à compilateur). Ensemble plus grand que cela et le temps utilisé par le passage de la bitset, le réglage de chaque peu plus vite.

    InformationsquelleAutor asheidan
  5. 0

    vous pouvez initialiser le bitset à partir d'un flux. Je ne me souviens pas comment régler un byte[] dans un cours d'eau, mais...

    de http://www.sgi.com/tech/stl/bitset.html

      bitset<12> x;

  cout << "Enter a 12-bit bitset in binary: " << flush;
  if (cin >> x) {
    cout << "x =        " << x << endl;
    cout << "As ulong:  " << x.to_ulong() << endl;
    cout << "And with mask: " << (x & mask) << endl;
    cout << "Or with mask:  " << (x | mask) << endl;
  }
    • J'ai juste essayé, et il exige que l'entrée n'être que 1 ou 0
    InformationsquelleAutor Darren Gilroy
  6. 0

    Voici ma mise en œuvre à l'aide du modèle de méta-programmation.

    Les boucles sont faites au moment de la compilation.

    J'ai pris @strager version modifiée afin de préparer pour la TMP:

    • changé l'ordre d'itération (pour que je puisse faire de la récursivité de celui-ci);
    • réduction du nombre de variables utilisées.

    Version modifiée avec des boucles dans un moment de l'exécution:

    template <size_t nOfBytes>
void bytesToBitsetRunTimeOptimized(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) {
  for(int i = nOfBytes - 1; i >= 0; --i) {
    for(int bit = 0; bit < CHAR_BIT; ++bit) {
      result[i * CHAR_BIT + bit] = ((arr[i] >> bit) & 1);
    }
  }
}

    TMP version basée sur elle: 

    template<size_t nOfBytes, int I, int BIT> struct LoopOnBIT {
static inline void bytesToBitset(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) {
result[I * CHAR_BIT + BIT] = ((arr[I] >> BIT) & 1);
LoopOnBIT<nOfBytes, I, BIT+1>::bytesToBitset(arr, result);
}
};
//stop case for LoopOnBIT
template<size_t nOfBytes, int I> struct LoopOnBIT<nOfBytes, I, CHAR_BIT> {
static inline void bytesToBitset(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) { }
};
template<size_t nOfBytes, int I> struct LoopOnI {
static inline void bytesToBitset(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) {
LoopOnBIT<nOfBytes, I, 0>::bytesToBitset(arr, result);
LoopOnI<nOfBytes, I-1>::bytesToBitset(arr, result);
}
};
//stop case for LoopOnI
template<size_t nOfBytes> struct LoopOnI<nOfBytes, -1> {
static inline void bytesToBitset(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) { }
};
template <size_t nOfBytes>
void bytesToBitset(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) {
LoopOnI<nOfBytes, nOfBytes - 1>::bytesToBitset(arr, result);
}

    code client: 

    uint8_t arr[]={0x6A};
std::bitset<8> b; 
bytesToBitset<1>(arr,b);
    InformationsquelleAutor spin_eight