Can anyone suggest a more efficient method to break apart a 64 bit dynamic bitset into 32 bit unsigned int chunks? The conversion is needed because eventually a C style system IO call needs to be performed that can't deal with a boost::dynamic_bitset or std::bitset; Thanks for any help/advice, Graham This works, but it feels inefficient: #include <iostream> #include "boost/dynamic_bitset.hpp" using namespace std; using namespace boost; // Create a 64 bit dynamic bitset from two 32 bit words, not 64 bit portable, illustration only dynamic_bitset<> create_64_bitset(unsigned int ms_word, unsigned int ls_word); int main(int argc, char* argv[]) { dynamic_bitset<> bitset_64( create_64_bitset(static_cast<unsigned>(0xaaaaaaaa), static_cast<unsigned>(0xbbbbbbbb))); cout << bitset_64 << endl; // This whole portion, below, seems inefficient. Is it? Is there a better method? // Break 64 bit dynamic bitset into 32 bit words dynamic_bitset<> temp_bitset(bitset_64); // Get least sig. 32 bits unsigned int ls_word = ((bitset_64 <<= 32) >>= 32).to_ulong(); // Get most sig 32 bits unsigned int ms_word = (temp_bitset >>= 32).to_ulong(); cout << ls_word << endl << ms_word << endl; cin >> argc; return 0; } dynamic_bitset<> create_64_bitset(unsigned int ms_word, unsigned int ls_word) { // Create a 64 bitset dynamic_bitset<> most_sig_word(64, ms_word); most_sig_word <<= 32; dynamic_bitset<> least_sig_word(64, ls_word); // Combine the two into one 64 bit bitset most_sig_word |= least_sig_word; return most_sig_word; }