Converter matriz de bytes em bitset

Question

I têm uma matriz de bytes gerado por um gerador de números aleatórios. Eu quero colocar isso no bitset STL.

Infelizmente, parece que bitset só suporta os seguintes construtores:

1. Uma cadeia de 1 e 0 como "10101011"
2. um sem assinatura longo. (Minha matriz de bytes será mais longo)

A única solução que eu posso pensar agora é ler o bit array de bytes a pouco e fazer uma série de 1s e 0s. Alguém tem uma solução mais eficiente?

Answer 1

Algo como isso? (Não tenho certeza se a magia modelo funciona aqui como eu esperava. Estou enferrujado em 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;
}

Answer 2

Há um terceiro construtor para bitset<> - que leva sem parâmetros e conjuntos de todos os bits a 0. Eu acho que você vai precisar usar que, em seguida, percorrer a matriz chamando set() para cada bit na matriz de bytes que é um 1.

Um pouco de força bruta, mas ele vai trabalhar. Haverá um pouco de complexidade para converter o byte de índice e pouco deslocamento dentro de cada byte a um índice de bitset, mas não é nada um pouco de pensamento (e talvez uma corrida através sob o depurador) não vai resolver. Eu acho que é mais provável mais simples e mais eficiente do que tentar executar a matriz através de uma conversão de cadeia ou um riacho.

Answer 3

Pessoal, eu passei muito tempo escrevendo uma função inversa (bitset -> byte matriz / char). Aí 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")

Answer 4

Bem, vamos ser honesto, eu estava entediado e começou a pensar que tinha que haver uma maneira um pouco mais rápido do que definir cada 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;
}

Este é realmente um pouco mais rápido, pelo menos enquanto a matriz de bytes é menor do que 30 elementos (dependendo de suas otimização-flags passados ??para o compilador). matriz maior do que isso e o tempo utilizado, deslocando o bitset torna a configuração cada pouco mais rápido.

Answer 5

Você pode inicializar o bitset de um córrego. Não me lembro de como disputar um byte [] em um córrego, mas ...

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;
  }

Answer 6

Aqui está minha implementação usando o modelo de meta-programação.
Loops são feitos no tempo de compilação.
Tomei @strager versão, modificado, a fim de se preparar para TMP:

• mudado ordem de iteração (para que eu pudesse fazer recursão a partir dele);
• redução do número de variáveis ??utilizadas.

Versão modificada com loops em um tempo de execução:

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

Versão TMP com base nele:

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

código de cliente:

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