How to access a slice of packed_bits as a std::bitset?

Question

I am attempting to implement a `packed_bits` class using variadic templates and `std::bitset`. In particular, I am running into problems writing a `get` function which returns a reference to a subset of the member `m_bits` which contains all the packed bits. The function should be analogous to `std::get` for `std::tuple`. It should act as an reference overlay so I can manipulate a subset of `packed_bits`. For instance, ``` using my_bits = packed_bits<8,16,4>; my_bits b; std::bitset< 8 >& s0 = get<0>( b ); std::bitset< 16 >& s1 = get<1>( b ); std::bitset< 4 >& s2 = get<2>( b ); ``` UPDATE Below is the code that has been rewritten according to Yakk's recommendations below. I am stuck at the point of his last paragraph: not sure how to glue together the individual references into one bitset-like reference. Thinking/working on that last part now. UPDATE 2 Okay, my new approach is going to be to let `bit_slice<>` do the bulk of the work: - it is meant to be short-lived - it will publicly s…

Accepted Answer

I wouldn't have `get` return a `bitset`, because each `bitset` needs to manage its own memory. Instead, I'd use a `bitset` internally to manage all of the bits, and create `bitset::reference`-like individual bit references, and `bitset`-like "slices", which `get` can return. A `bitslice` would have a pointer back to the original `packed_bits`, and would know the offset where it starts, and how wide it is. It's `references` to individual bits would be `references` from the original `packed_bits`, which are `references` from the internal `bitset`, possibly. Your `Size` is redundant -- `sizeof...(pack)` tells you how many elements are in the pack. I'd pack up the sizes of the slices into a seqence so you can pass it around easier. Ie: ``` template struct seq {}; ``` is a type from which you can extract an arbitrary length list of `unsigned int`s, yet can be passed as a single parameter to a template. As a first step, write `bit_slice`, which takes a `std::bitset` and produces `bitset::reference`s to individual bits, where `bit_slice[n]` is the same as `bitset[n+offset]`. Optionally, `bit_slice` could store `offset` as a run-time parameter (because `offset` as a compile-time parameter is just an optimization, and not that strong of one I suspect). Once you have `bit_slice`, working on the tuple syntax of `packed_bits` is feasible. `get( packed_bits& )` returns a `bit_slice` determined by indexing the `packed_bits` sizes, with an `offset` determined by adding the first n-1 `packed_bits` sizes, which is then constructed from the internal `bitset` of the `packed_bits`. Make sense? Apparently not. Here is a quick `bit_slice` that represents some sub-range of bits within a `std::bitset`. ``` #include template struct bit_slice { private: std::bitset* bits; public: // cast to `bitset`: operator std::bitset() const { std::bitset retval; for(unsigned i = 0; i < Offset; ++i) { retval[i] = (*this)[i]; } return retval; } typedef typename std::bitset::reference reference; reference operator[]( size_t pos ) { // TODO: check that pos < Width? return (*bits)[pos+Offset]; } constexpr bool operator[]( size_t pos ) const { // TODO: check that pos < Width? return (*bits)[pos+Offset]; } typedef bit_slice self_type; // can be assigned to from any bit_slice with the same width: template self_type& operator=( bit_slice&& o ) { for (unsigned i = 0; i < Width; ++i ) { (*this)[i] = o[i]; } return *this; } // can be assigned from a `std::bitset` of the same size: self_type& operator=( std::bitset const& o ) { for (unsigned i = 0; i < Width; ++i ) { (*this)[i] = o[i]; } return *this; } explicit bit_slice( std::bitset& src ):bits(&src) {} bit_slice( self_type const& ) = default; bit_slice( self_type&& ) = default; bit_slice( self_type&o ):bit_slice( const_cast(o)) {} // I suspect, but am not certain, the the default move/copy ctor would do... // dtor not needed, as there is nothing to destroy // TODO: reimplement rest of std::bitset's interface that you care about }; template bit_slice< width, offset, src_width > make_slice( std::bitset& src ) { return bit_slice< width, offset, src_width >(src); } #include int main() { std::bitset<16> bits; bits[8] = true; auto slice = make_slice< 8, 8 >( bits ); bool b0 = slice[0]; bool b1 = slice[1]; std::cout << b0 << b1 << " "; // should output 10 } ``` Another useful class would be a `bit_slice` with runtime offset-and-source size. This will be less efficient, but easier to program against.

How to access a slice of packed_bits<> as a std::bitset<>?

Solution

Problem