std::vector<bool>

std::vector<bool> is a possibly space-efficient specialization of std::vector for the type bool.

The manner in which std::vector<bool> is made space efficient (as well as whether it is optimized at all) is implementation defined. One potential optimization involves coalescing vector elements such that each element occupies a single bit instead of sizeof(bool) bytes.

std::vector<bool> behaves similarly to std::vector, but in order to be space efficient, it:

• Does not necessarily store its elements as a contiguous array.
• Exposes class std::vector<bool>::reference as a method of accessing individual bits. In particular, objects of this class are returned by operator[] by value.
• Does not use std::allocator_traits::construct to construct bit values.
• Does not guarantee that different elements in the same container can be modified concurrently by different threads.

[edit] Member types

[edit] Member functions

[edit] Non-member functions

[edit] Helper classes

[edit] Deduction guides (C++17)

[edit] Notes

If the size of the bitset is known at compile time, std::bitset may be used, which offers a richer set of member functions. In addition, boost::dynamic_bitset exists as an alternative to std::vector<bool>.

Since its representation may be optimized, std::vector<bool> does not necessarily meet all Container or SequenceContainer requirements. For example, because std::vector<bool>::iterator is implementation-defined, it may not satisfy the LegacyForwardIterator requirement. Use of algorithms such as std::search that require LegacyForwardIterators may result in either compile-time or run-time errors.

The Boost.Container version of vector does not specialize for bool.

[edit] Example

#include <cassert>
#include <initializer_list>
#include <iostream>
#include <vector>
 
void println(auto rem, const std::vector<bool>& vb)
{
    std::cout << rem << " = [";
    for (std::size_t t{}; t != vb.size(); ++t)
        std::cout << (t ? ", " : "") << vb[t];
    std::cout << "]\n";
}
 
int main()
{
    std::vector<bool> v1; // creates an empty vector of boolean values
    println("1) v1", v1);
 
    std::vector<bool> v2{0, 1, 1, 0, 1}; // creates filled vector
    println("2) v2", v2);
 
    v1 = v2; // copies v2 to v1
    println("3) v1", v1);
 
    assert(v1.size() == v2.size()); // checks that v1 and v2 sizes are equal
    assert(v1.front() == false); // accesses first element, equivalent to:
    assert(v1[0] == false);
    assert(v1.back() == true); // accesses last element, equivalent to:
    assert(v1[v1.size() - 1] == true);
 
    v1 = {true, true, false, false}; // assigns an initializer list
    println("4) v1", v1);
 
    v1.push_back(true); // adds one element to the end
    println("5) v1", v1);
 
    v1.pop_back(); // removes one element from the end
    println("6) v1", v1);
 
    v1.flip(); // flips all elements
    println("7) v1", v1);
 
    v1.resize(8, true); // resizes v1; new elements are set to “true”
    println("8) v1", v1);
 
    v1.clear(); // erases v1
    assert(v1.empty()); // checks that v1 is empty
}

1) v1 = []
2) v2 = [0, 1, 1, 0, 1]
3) v1 = [0, 1, 1, 0, 1]
4) v1 = [1, 1, 0, 0]
5) v1 = [1, 1, 0, 0, 1]
6) v1 = [1, 1, 0, 0]
7) v1 = [0, 0, 1, 1]
8) v1 = [0, 0, 1, 1, 1, 1, 1, 1]

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.