Expert: Ralph McArdell - 10/10/2006

Question
Hello,

I'd like to construct a set of bitsets (using C++ STL), where the length iof the bitsets is determined by the output of a function (but all bitsets in the set will have the same length). I am getting errors that the int the function returns is not constant, and therefore cannot be used in the bitset template. I've tried typecasting but it hasn't worked. Here's an example of what I'd like to do, but cannot:

#include <bitset>
#include <set>

int some_function(int n);

int main() {
 const int size = (const int) some_function(3);
 set< bitset<size>> my_bitset_set;
}

int some_function(int n) {
 return n;
}

Any help would be greatly appreciated!

Answer
You cannot use std::bitset in this way, just as you could not use size for the dimension of a non-dynamic built in array, and for the same reason:

 const int size = (const int) some_function(3);

 int int_array[size]; // Not allowed, arrays sized at compile time

Template parameters need to be specified at _compile_ time just as (non dynamic) array dimensions need to be known at compile time. As size is returned from a function executed at run time the compiler cannot calculate its value and therefore cannot plug the value of size into the std::bitset class template to create a specific bitset class.

That's right, by specifying template parameters you cause the compiler to create a new class type (or a new function in the case of a function template). That is why they are called templates - they are templates that can be used by the compiler to create classes (or functions). As these are used by the compiler all information to convert a template into an actual class (or function) has to be available to the compiler at the point it uses a template to create a class (or function).

The best alternative I can offer from the C++ standard library is to try using a std::vector<bool>, which does not have all the nice bit operations of std::bitset, but most implementations do use one bit per bool and use a proxy class to help in the access of elements. This allows for bit-level operations on what would otherwise be a bool type, most noticeably the flip() operation is available for single (bit) elements as well as the whole of a std::vector<bool>.

The only other alternative I can think of is to use a std::bitset large enough for any reasonable value of size.

If you can use libraries other than the C++ standard library then I suggest you start by looking at the Boost libraries (http://www.boost.org/), specifically the Boost Dynamic Bitset library (http://www.boost.org/libs/dynamic_bitset/dynamic_bitset.html), which does exactly what you want as the number of bits is defined at construction time (i.e. at run time) and not statically via a template parameter at compile time.