Accessing std::uint8_t as std::bitset

0
votes

I would like to model a status register in C/C++, which should be accessible as std::bitset and as std::uint8_t. Thus I would combine them as union as follows:

#include <bitset>
#include <iostream>

union byte {
        std::uint8_t uint;
        std::bitset<8> bitset;
};

int main(int, char*[])
{
        byte b = { .uint = 0b10101010 };

        std::cout << "Value of bit 5: "
                << (b.bitset.test(5) ? "true" : "false") << std::endl;

        std::cout << "Value of bit 4: "
                << (b.bitset.test(4) ? "true" : "false") << std::endl;

        std::cout << "Bitset Output: " << b.bitset << std::endl;
        std::cout << "Uint Output: " << static_cast<int>(b.uint) << std::endl;

        return 0;
}

This seems to work as expected, when compiled with GCC x86_64 8.2. However, I would like to know if I could expect this to work in all cases or if I am better off with some helper functions like bitset, bittest, ...

2
c++c++11unionsbitset
Type punning is undefined behavior, so you can't expect it to work. Note, that it seems to be working by pure chance (as is usually the case with UB) since std::uint8_t and std::bitset<8> have different representations in memory (one is 1 byte and the other is 8 bytes). You can just use bitset with to_ulong method (and cast that to uint8_t), to avoid UB. - Dan M.
Type-punning using unions is allowed in C, but not in C++. I also don't think there's any requirement that the data layout of a std::bitset have to be directly compatible with a built-in type corresponding to the bit-size. All in all, attempting to do what you do will lead to undefined behavior - Some programmer dude
@DanM. Partially wrong, the template argument for std::bitset is the number of bits not bytes. - Some programmer dude
As for your problem, if you want a type that can act as both a native uint8_t and handle bits in a "nice" way, then you have to implement such a class yourself. If you need it to map to a memory-mapped hardware register it should probably wrap a pointer to the register. - Some programmer dude
@Someprogrammerdude and? bitset<N> is not guaranteed to take exactly N/8 bytes. See godbolt.org/z/oBRgT9 There is nothing wrong with my statement. - Dan M.

2 Answers

4
votes

What you are trying to do here with union is called type punning and is Undefined Behavior in C++ (you can read more about it in this SO answer), so it's not guaranteed to work properly even on the same compiler.

Furthermore, even if it was allowed, std::bitset<8> is not guaranteed to have the same representation as std::uint8_t (and in fact it does not on any major compiler).

In your case, you could just use the regular std::bitset<8> with to_ulong method.

Another alternative is to have a wrapper class with bitset member that would provide convenience methods to assign/convert to uint8_t.

Also, if you only want some limited API of std::bitset<8>, it might be good idea (if you want to keep the size of your class as 1 byte) to wrap around std::uint8_t and implement those few methods (like test) manually.

2
votes

I took the idea of SomeProgrammerDude's comment

As for your problem, if you want a type that can act as both a native uint8_t and handle bits in a "nice" way, then you have to implement such a class yourself. If you need it to map to a memory-mapped hardware register it should probably wrap a pointer to the register.

and tried to make it in C++. This is the sample I came up with:

#include <cassert>
#include <iostream>
#include <iomanip>

class ByteReg {
  private:
    volatile uint8_t &reg;
  public:
    explicit ByteReg(volatile uint8_t &reg): reg(reg) { }
    ByteReg(const ByteReg&) = delete;
    ByteReg operator=(const ByteReg&) = delete;
    ~ByteReg() = default;

    operator uint8_t() { return reg; }
    bool test(int i) const
    {
      assert(i >= 0 && i < 8);
      return ((reg >> i) & 1) != 0;
    }
};

int main() 
{
  volatile uint8_t hwReg = 0xaa; // 0x10101010
  ByteReg reg(hwReg);
  unsigned value = reg;
  std::cout << "reg: 0x" << std::hex << std::setw(2) << std::setfill('0')
    << value << '\n';
  for (int i = 0; i < 8; ++i) {
    std::cout << "bit " << i << ": "
      << (reg.test(i) ? "set" : "unset") << '\n';
  }
  return 0; 
}

Output:

reg: 0xaa
bit 0: unset
bit 1: set
bit 2: unset
bit 3: set
bit 4: unset
bit 5: set
bit 6: unset
bit 7: set

Live Demo on coliru

Though, a free-standing function testBit() might do as well with even less code:

#include <cassert>
#include <iostream>
#include <iomanip>

bool testBit(uint8_t reg, int i)
{
  assert(i >= 0 && i < 8);
  return ((reg >> i) & 1) != 0;
}

int main() 
{
  volatile uint8_t reg = 0xaa; // 0x10101010
  unsigned value = reg;
  std::cout << "reg: 0x" << std::hex << std::setw(2) << std::setfill('0')
    << value << '\n';
  for (int i = 0; i < 8; ++i) {
    std::cout << "bit " << i << ": "
      << (testBit(reg, i) ? "set" : "unset") << '\n';
  }
  return 0; 
}

Live Demo on coliru