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.

Member types

Member functions

Non-member functions

Helper classes

Deduction guides (C++17)

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 LegacyForwardIterator s may result in either compile-time or run-time errors .

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

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]

Defect reports

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