how to split a bitset to an array - c++

Question

I have am enum like below:
enum types : uint16_t
{
A = 1 << 0,
B = 1 << 1,
C = 1 << 2,
D = 1 << 3,
E = 1 << 4,
F = 1 << 5,
G = 1 << 6
};
Assume I have number:
uint16_t val = A | C | F;
how to split the val to an array, I know I can do this by using for
for(int i=0;i<7;++i){
if(val & (1 << i)){
//push_back(1 << i)
}
}
but what if the enum has 1000 rows?
Is there any simple and faster way to do this?

Answer 1

Use a std::bitset<N> to store bit flags like that. Have the enum be, instead of 1 << 5, just be a normal incrementing enum. Then you use the bitset like this:
std::bitset<1000> myBits;
myBits.set(A);
if(myBits[A]) {
// do some bit flag logic.
}

Answer 2

but what if the enum has 1000 rows?
C++ doesn't have a primitive type with 1000 bits (even __int128 uses 128 bits) so we will have to make our own.
struct Bits1000
{
uint8_t bits[1000 / 8] = {};
};
Is there any simple and faster way to do this?
One way or the other, you will end up using a loop. It's the other optimizations that can be done to improve performance. The reason is that C++ does not have a way to index bits (like bits[0] is equal to the first bit, unless we're talking about std::bitset). Even a struct containing a bitfield also gets packed to a byte. And considering that we have an if condition that we use to check if a certain enum is present, this means that this process should be done at runtime.
Optimizations
Since we are looking at the poweres of two, we can always increment the index by multiplying it by two. This way we dont have to do the bit shift opearation, in addition to the index increment and might help reduce the total CPU instruction cycles.
/**
* Helper to calculate the power.
*/
template<size_t Base, size_t Exponent>
struct Power
{
static constexpr size_t Value = Base * Power<Base, Exponent - 1>::Value;
};
/**
* Helper template specialization.
*/
template<size_t Base>
struct Power<Base, 1>
{
static constexpr size_t Value = Base;
};
// ...
for (int i = 1; i < Power<2, sizeof(uint8_t) * 8>::Value; i *= 2)
{
if(val & i)
{
// Do your work here.
}
}
Another optimization would be to precompute and store the powers of two in an array, then index that array to get the poweres.
uint64_t poweres[64] = { 1, 2, 4, 8, ... };
for (int i = 0; i < sizeof(uint8_t) * 8; i++)
{
if(val & poweres[i])
{
// Do your work here.
}
}
The trick here is that with standard types, you can get away with almost constant time (O(8), O(16), O(32), and O(64) time complexities). So the performance hits are pretty low. Even with custom types, we will be using the absolute minimum that's available for us.
I should also note that if we're dealing with very large numbers (for example with 1000 bits), the iterating integer would not be able to handle that (nor would bit shifting because the result will always be at max uint64_t depending on the build). In that case, make sure to iterate through the maximum available (4 bytes in x86 and 8 bytes in x64).

Answer 3

Bit scanning is a technique to efficiently do this sort of thing. To do that you'll need bit-level operations. Traditionally, that has involved compiler extensions (like GCC's builtins). Starting with C++20 you'll find what you need in the bit header.
Example using your types type:
std::vector<types> parse_num(uint16_t num)
{
std::vector<types> res;
while (num) {
auto bit = std::countr_zero(num);
auto mask = 1 << bit;
res.push_back(static_cast<types>(mask));
num &= ~mask;
}
return res;
}
This is something you may want to reach for in the "the enum has 1000 rows" kind of case - especially if the data is sparse - rather than the simple example in the question where your loop is simpler and possibly more performant. As always, it depends.
For a (non-portable) pre-C++20 solution you can:
Replace std::countr_zero(num) with __builtin_ctz(num) for GCC/Clang.
Use _BitScanForward for MSVC.