dynamic_bitset | Simple dynamic bitset template class | 3D Printing library

I have traced the code for my boost 1_75_0 and I see it has a define to conditionally reserve access to friends:

I've implemented serialization for dynamic_bitset before: How to serialize boost::dynamic_bitset?

You can use that or a similar technique based on the same interfaces:

You can expect the actual memory usage to be (in bytes):

• sizeof the object itself (which you've said is 32 bytes in your case) plus
• however-many bits you've constructed the dynamic_bitset to divided by 8, probably rounded up somewhat by your dynamic memory allocation library, but at worst probably to the next power-of-two in bytes

If you push_back or append to the dynamic_bitset to increase its length gradually, it'll probably double the memory usage periodically, same way e.g. std::vector and std::unordered_map do, but I haven't checked the code or docs for that. That's generally considered the sane compromise between excessive copying and being wasteful of memory. If you want to check, look at the source code.

At runtime, you can get a more accurate idea of the bytes current allocated using by calling .capacity() and dividing by 8 (but there can still be a little overhead from the allocation library, and there's the fixed number of bytes per sizeof - 32 in your case):

size_type capacity() const;

Returns: The total number of elements that *this can hold without requiring reallocation. Throws: nothing.

See: https://www.boost.org/doc/libs/1_75_0/libs/dynamic_bitset/dynamic_bitset.html

You can divide by 8 because you can fit 8 bits in a single byte. (Strictly speaking it's better to use CHAR_BIT instead of hard-coding 8).

You are facing two different issues:

1. The boost function to_block_range will pad the output to the internal block size, by appending zeros at the end. In your case, the internal block size is sizeof(unsigned char)*8 == 8. So if the bit sequence you write to the file in writeToFile is not a multiple of 8, additional 0s will be written to make for a multiple of 8. So if you read the bit sequence back in with readFromFile, you have to find some way to remove the padding bits again.

2. There is no standard way for how to represent a bit sequence (reference). Depending on the scenario, it might be more convenient to represent the bits left-to-right or right-to-left (or some completely different order). For this reason, when you use different code pieces to print the same bit sequence and you want these code pieces to print the same result, you have to make sure that these code pieces agree on how to represent the bit sequence. If one piece of code prints left-to-right and the other right-to-left, you will get different results.

Let's discuss each issue individually:

I understand that you want to define your own block size with the bitSize variable, on top of the internal block size of boost::dynamic_bitset. For example, in your main method, you construct BitOperations c(7, "bits2.bin");. I understand that to mean that you expect the bit seqence stored in the file to have a length that is some multiple of 7.

If this understanding is correct, you can remove the padding bits that have been inserted by to_block_range by reading the file size and then rounding it down to the nearest multiple of your block size. Though you should note that you currently do not enforce this contract in the BitOperation constructor or in writeToFile (i.e. by ensuring that the data size is a multiple of 7).

In your readFromFile method, first note that the inner loop incorrectly takes the blockSize into account. So if blockSize is 7, this incorrectly only considers the first 7 bits of each block. Whereas the blocks that were written by to_block_range use the full 8 bit of each 1-byte block, since boost::dynamic_bitset does not know anything about your 7-bit block size. So this makes you miss some bits.

Here is one example for how to fix your code:

Your decode method is marked const, but you are attempting to modify class member variable values.

Either remove the const or mark values mutable

For example:

From the docs:

It should be noted that in practice bcp can produce a rather "fat" list of dependencies, reasons for this include:

• It searches for library names first, so using "regex" as a name will give you everything in the libs/regex directory and everything that depends on. This can be a long list as all the regex test and example programs will get scanned for their dependencies. If you want a more minimal list, then try using the names of the headers you are actually including, or use the --scan option to scan your source code.

• ...

So, you are getting a fat list of dependencies because the search includes the tests and examples which are themselves not header-only, and have further non-header-only dependencies.

Is Boost dynamic_bitset really header-only

I see no reason to doubt that.

if so, how do I include only the relevant headers in my project?

As per the quoted suggestion, you might attempt instead: bcp --list boost/dynamic_bitset.hpp for a leaner list.

Look at the bitset from most significant bits to the least significant ones

The using directive can pull in the base class constructors. When I tried it I found that it didn't include the default constructor, but that one is easy to include; an empty default contructor will of course call the base-class one implicitly.

edit: see comment, this is UB - there doesn't appear to be a "good" solution to the problem.

wrap your op<< in a namespace std {...}