split std::bitset in two halves?

Question

I am implementing DES algorithm and I need to split std::bitset<56> permutationKey in two halves.

std::bitset<56> permutationKey(0x133457799BBCDF);
std::bitset<28> leftKey;
std::bitset<28> rightKey;

std::bitset<56> divider(0b00000000000000000000000000001111111111111111111111111111);

rightKey = permutationKey & divider;
leftKey = (permutationKey >> 28) & divider;

I tried to typecast bitset<56> to bitset<28> but it didn't work.

Other way to achieve the same thing is to iterate and assign each bit individually. I want to achieve it without using loops there must be another way.

I was able to do it with primitive types

uint64_t key = 0b0001010101010101110110001100001110000011111100000000011111000000;
                    //00010101.01010101.11011000.11000011---|---10000011.11110000.00000111.11000000
uint32_t right = (uint32_t)key;
uint32_t left = key >> 32;

How can I split bitset like this?

Well, good old bit masking and shifting might come in handy here. — πάντα ῥεῖ, Apr 03 '16 at 13:13
You could even consider to provide a template based version of such function (instantiating certain even sizes) for doing this. — πάντα ῥεῖ, Apr 03 '16 at 13:18
I would think that using primitive types would be more appropriate here. — Sam Varshavchik, Apr 03 '16 at 13:19
You can replace `permutationKey & divider` by `(permutationKey & divider).to_ullong()`, not sure if it is cleaner than the version with `uint_t`. I found the standard `bitset` class really poor when dealing with multiple bits extraction... — Holt, Apr 03 '16 at 13:20
@Holt I think it is a good solution. Let me check for my problem. — Abdul Rehman, Apr 03 '16 at 13:27

score 6 · Accepted Answer · answered Apr 03 '16 at 13:28

6

std::bitset<56> permutationKey(0x133457799BBCDF);
std::bitset<56> divider(0b00000000000000000000000000001111111111111111111111111111);

auto rightKey = std::bitset<28> ( (permutationKey & divider).to_ulong() );
auto leftKey = std::bitset<28> ( ((permutationKey >> 28) & divider).to_ulong() );

answered Apr 03 '16 at 13:28

Richard Hodges

68,278
7
90
142

2

Wow ! It was that simple :-). – Abdul Rehman Apr 03 '16 at 13:30
4

documentation is the new black. You should get some! ;-) http://en.cppreference.com/w/cpp/utility/bitset – Richard Hodges Apr 03 '16 at 13:31
So you can't create a bitset from another without having to convert it to ulong first? This class is very disappointing. Not very powerful for bit manipulation. – Jasancos Nov 18 '19 at 13:14
@Jasancos you can certainly copy-construct a bitset of the same size. This solution is producing 2 bitsets whose size differs from the source objects. – Richard Hodges Nov 18 '19 at 13:50

score 2 · Answer 2 · answered Sep 09 '20 at 07:39

The proposed solution in previous answer is nice but not general: how do we split a bitset that is to big to be converted to u_long without loss of bits? Intuitively we look here for something like iterators and ranges:

vector<int> vec({1,2,3,4});
vector<int> vec1(vec.begin(), vec.begin() + vec.size() / 2); // {1,2}
vector<int> vec2(vec.begin() + vec.size() / 2, vec.end()); // // {3,4}

Unfortunately bitsets do not have iterators and ranges. If you do not care much about speed of conversion I would propose following simple and general solution:

const size_t size = ...  // we assume size is even
bitset<size> bss;
.......
const string str = bss.to_string();
bitset<size/2>bss1(str.substr(0, str.size() / 2));          // first half
bitset<size/2>bss2(str.substr(str.size() / 2, str.size())); // second half

split std::bitset in two halves?

2 Answers2