std::bitset einlesen von einem Bytearray



  • Ich suche nach der elegantesten Möglichkeit aus einem Byte Array ein std::bitset einzulesen.

    #include<bitset>
    
    
    
    int main(){
    
    uint8_t arr[4] = {1,2,3,4};
    
    std::bitset<32> b1{arr[0]};
    std::bitset<32> b2{arr[1]};
    std::bitset<32> b3{arr[2]};
    std::bitset<32> b4{arr[3]};
    
    b1 <<= 8;
    b1 |= b2;
    b1 <<= 8;
    b1 |= b3;
    b1 <<= 8;
    b1 |= b4;
    }
    

    Die 4 Bytes gehören zusammen und sollen dementsprechenend auch in einem Bitset Object existieren.

    Aber ist das wirklich so umständlich wie ich hier geschrieben habe oder übersehe ich etwas


  • Mod

    Zumindest eleganter, wenn auch nicht elegant:

    std::bitset<32> b((arr[0] << 24) + (arr[1] << 16) + (arr[2] << 8) + arr[3]);
    


  • Also so ist es wirklich umständlich. Warum nicht erst die Zahlen aus dem Array in einer Schleife per <<= und |= verarbeiten und dann das Ergebnis an das std::bitset übergeben?



  • wärst du so nett, da ein Beispiel zu zeigen, wie du das meinst?

    Schade, dass std::bitset nicht einen ctor für Initialisierung durch einen Container bereitstellt...



  • @sewing
    Ich glaube, was Th69 meint ist sowas hier:

    unsigned int bit_mask = 0;
    for( auto val : array_data )
    {
       bit_mask <<= 8;
       bit_mask |= val;
    }
    bitset<32> bit_set( bit_mask );
    


  • vielen Dank



  • Ja, das meinte ich. Aber auf so etwas sollte man als Entwickler wohl selber kommen...



  • Mir war grad langweilig, vielleicht kannste das ja gebrauchen...

    #include <array>
    #include <bitset>
    #include <cassert>
    #include <algorithm>
    #include <type_traits>
    
    template<std::size_t bit_count = 32, typename iterator>
    std::bitset<bit_count> make_bitset( iterator begin, iterator end )
    {
       using value_type = typename iterator::value_type;
    
       // Check: Nur integrale Datentypen erlauben
       static_assert( std::is_integral<value_type>::value, "value type must be integral" );
    
       // Check: Anzahl der benötigten Bits muss in Bitset passen
       std::size_t value_type_bits = sizeof( value_type ) * 8;
       std::size_t bits_needed     = std::distance( begin, end ) * value_type_bits;
       assert( bits_needed <= bit_count );
    
       std::bitset<bit_count> retval;
       std::size_t bit_index = bits_needed -1;
    
       for( ;begin != end; ++begin )
       {
          for( int bit_pos = value_type_bits -1; bit_pos >= 0; --bit_pos, --bit_index )
          {
             retval[bit_index] = *begin & (value_type( 1 ) << bit_pos);
          }
       }
       return retval;
    }
    
    int main()
    {
       std::array<unsigned char,3>   bits1 = { 1, 2, 3 };
       std::array<unsigned short,3>  bits2 = { 1, 2, 3 };
    
       auto bs1 = make_bitset( bits1.begin(), bits1.end() );
       auto bs2 = make_bitset<48>( bits2.begin(), bits2.end() );
    }
    


  • Danke, schöne Lösung 🙂


Log in to reply