std::vector<bool>

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Containers library

array (C++11)

vector

deque

forward_list (C++11)

list

set

multiset

map

multimap

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

stack

queue

priority_queue

 

std::vector<bool>

Member functions

vector::vector

vector::~vector

vector::operator=

vector::assign

vector::get_allocator

Element access

vector::at

vector::operator[]

vector::front

vector::back

Iterators

vector::beginvector::cbegin (C++11)

vector::endvector::cend (C++11)

vector::rbeginvector::crbegin (C++11)

vector::rendvector::crend (C++11)

Capacity

vector::empty

vector::size

vector::max_size

vector::reserve

vector::capacity

Modifiers

vector::clear

vector::insert

vector::erase

vector::push_back

vector::pop_back

vector::resize

vector::swap

Helper classes

std::hash (C++11)

std::vector<bool> specific

vector<bool>::flip

vector<bool>::swap

 

Defined in header <vector>
template<class Allocator> class vector<bool, Allocator>;

std::vector<bool> is a 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 (so &v[0] + n != &v[n])
• 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 type	Definition
value_type	bool
allocator_type	Allocator
size_type	implementation-defined
difference_type	implementation-defined
reference	proxy class representing a reference to a single bool (class)
const_reference	bool
pointer	implementation-defined
const_pointer	implementation-defined
iterator	implementation-defined
const_iterator	implementation-defined
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>

Member functions

(constructor)	constructs the vector (public member function of std::vector)
(destructor)	destructs the vector (public member function of std::vector)
operator=	assigns values to the container (public member function of std::vector)
assign	assigns values to the container (public member function of std::vector)
get_allocator	returns the associated allocator (public member function of std::vector)
Element access
at	access specified element with bounds checking (public member function of std::vector)
operator[]	access specified element (public member function of std::vector)
front	access the first element (public member function of std::vector)
back	access the last element (public member function of std::vector)
Iterators
begin cbegin	returns an iterator to the beginning (public member function of std::vector)
end cend	returns an iterator to the end (public member function of std::vector)
rbegin crbegin	returns a reverse iterator to the beginning (public member function of std::vector)
rend crend	returns a reverse iterator to the end (public member function of std::vector)
Capacity
empty	checks whether the container is empty (public member function of std::vector)
size	returns the number of elements (public member function of std::vector)
max_size	returns the maximum possible number of elements (public member function of std::vector)
reserve	reserves storage (public member function of std::vector)
capacity	returns the number of elements that can be held in currently allocated storage (public member function of std::vector)
Modifiers
clear	clears the contents (public member function of std::vector)
insert	inserts elements (public member function of std::vector)
emplace (since C++14)	constructs element in-place (public member function of std::vector)
erase	erases elements (public member function of std::vector)
push_back	adds an element to the end (public member function of std::vector)
emplace_back (C++14)	constructs elements in-place at the end (public member function of std::vector)
pop_back	removes the last element (public member function of std::vector)
resize	changes the number of elements stored (public member function of std::vector)
swap	swaps the contents (public member function of std::vector)
vector<bool> specific modifiers
flip	flips all the bits (public member function)
swap [static]	swaps two std::vector<bool>::references (public static member function)

Non-member functions

operator==operator!=operator<operator<=operator>operator>=	lexicographically compares the values in the vector (function template)
std::swap(std::vector)	specializes the std::swap algorithm (function template)

Helper classes

std::hash<std::vector<bool>> (C++11)

hash support for std::vector<bool> (class template specialization)

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 by 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 ForwardIterator requirement. Use of algorithms such as std::search that require ForwardIterators may result in either compile-time or run-time errors.