std::bitset - Why on earth isn't it dynamically allocated?

The title of the post sums my question up. I haven't been able to find any information the logic behind this anywhere - there is a lot of people bashing it, however.

Do you guys have any idea why they chose to implement it as such? I am by no means an experiences C++ programmer, and I knew that it was possible to use templates to pass arguments like that, but am I the only one who thinks it's a perversion of the whole concept of generic programming? For some reason, I don't think it makes sense to be able to pass templates anything but types.

I know boost has a bitset that does it dynamically, but I'm still curious as to the logic behind this design. It really limits its usage.

It is much more efficient this way?

You could similarly bash std::tr1::array for not allocating the array dynamically. It's not supposed to.

If that is not what you need, use something else, like boost's dynamic_bitset.

Besides, non-type template arguments are used heavily in C++ (e.g think boost and type_traits, half of which are instantiations of integer_constant<bool, true/false> or something like that. Neither should it particularly interfere with generic programming:

Code:

---

template <class Bitset>
void foo(const Bitset& bs); //accepts all bitsets and anything else with a similar interface

template <unsigned N>
void foo(const std::bitset<N>& bs); //accepts bitsets of any size

---

Quote:

---

Originally Posted by anon

It is much more efficient this way?

You could similarly bash std::tr1::array for not allocating the array dynamically. It's not supposed to.

If that is not what you need, use something else, like boost's dynamic_bitset.

Besides, non-type template arguments are used heavily in C++ (e.g think boost and type_traits, half of which are instantiations of integer_constant<bool, true/false> or something like that. Neither should it particularly interfere with generic programming:

Code:

---

template <class Bitset>
void foo(const Bitset& bs); //accepts all bitsets and anything else with a similar interface

template <unsigned N>
void foo(const std::bitset<N>& bs); //accepts bitsets of any size

---

---

Why would it be much more efficient? Wouldn't the only overhead by the single allocation of memory when it instantiated?

I did mention that boost has a dynamic bitset, but I still don't understand why the functionality wasn't provided from the get-go.

Quote:

---

Originally Posted by IceDane

I know boost has a bitset that does it dynamically, but I'm still curious as to the logic behind this design. It really limits its usage.

---

One possibility is that due to design by committee, they ended up going with something that they could agree on, despite its limitations. Also, if I understand the possible implementations correctly, if you only need a fixed sized bitset, std::bitset is likely to provide more efficient operations than boost::dynamic_bitset.

Dynamic allocations may be very expensive in C++. (If you see a benchmark where OMG Java is much faster than C++, the culprit seems to be quite often that the benchmark in reality tests the speed of small object allocation-deallocation.)

Besides, there is a dynamic bitset in standard C++, and that's the vector<bool> specialization (it is deprecated, though, since it doesn't work like a container).

Quote:

---

Originally Posted by IceDane

Do you guys have any idea why they chose to implement it as such?

---

What would distinguish it from std::vector<bool> then?