std::vector<bool, Alloc>::reference - cppreference.com (original) (raw)
The std::vector<bool, Alloc> specializations define std::vector<bool, Alloc>::reference as a publicly-accessible nested class. std::vector<bool, Alloc>::reference proxies the behavior of references to a single bit in std::vector<bool, Alloc>.
The primary use of std::vector<bool, Alloc>::reference is to provide an assignable value that can be returned from operator[].
Any reads or writes to a vector that happen via a std::vector<bool, Alloc>::reference potentially read or write to the entire underlying vector.
Contents
- 1 Member functions
- 2 std::vector<bool, Alloc>::reference::reference
- 3 std::vector<bool, Alloc>::reference::~reference
- 4 std::vector<bool, Alloc>::reference::operator=
- 5 std::vector<bool, Alloc>::reference::operator bool
- 6 std::vector<bool, Alloc>::reference::flip
- 7 std::formatter<std::vector<bool, Alloc>::reference>
[edit] Member functions
| | constructs the reference (public member function) | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | destroys the reference (public member function) | | | assigns a value to the referenced bit (public member function) | | | returns the referenced bit (public member function) [edit] | | | flips the referenced bit (public member function) |
std::vector<bool, Alloc>::reference::reference
| reference( const reference& ) = default; | | (since C++11) (constexpr since C++20) | | ----------------------------------------- | | ------------------------------------- |
Constructs the reference from another reference. The copy constructor is implicitly declared.(until C++11)
Other constructors can only be accessed by std::vector<bool, Alloc>.
std::vector<bool, Alloc>::reference::~reference
| ~reference(); | | (constexpr since C++20) | | -------------- | | ----------------------- |
Destroys the reference.
std::vector<bool, Alloc>::reference::operator=
| reference& operator=( bool x ); | (1) | (noexcept since C++11) (constexpr since C++20) |
|---|---|---|
| constexpr const reference& operator=( bool x ) const noexcept; | (2) | (since C++23) |
| reference& operator=( const reference& x ); | (3) | (noexcept since C++11) (constexpr since C++20) |
Assigns a value to the referenced bit.
| The const operator= enables std::vector<bool,Alloc>::iterator to satisfy output_iterator. | (since C++23) |
|---|
Parameters
Return value
*this
std::vector<bool, Alloc>::reference::operator bool
| operator bool() const; | | (noexcept since C++11) (constexpr since C++20) | | ---------------------- | | ---------------------------------------------- |
Returns the value of the referenced bit.
Return value
The referenced bit.
std::vector<bool, Alloc>::reference::flip
| void flip(); | | (noexcept since C++11) (constexpr since C++20) | | ------------ | | ---------------------------------------------- |
Inverts the referenced bit.
[edit] Helper classes
std::formatter<std::vector<bool, Alloc>::reference>
| template< class T, class CharT > requires /*is-vector-bool-reference*/<T> struct formatter<T, CharT>; | | (since C++23) | | ----------------------------------------------------------------------------------------------------------- | | ------------- |
Specializes the std::formatter for std::vector<bool, Alloc>::reference. The specialization uses std::formatter<bool, CharT> as its underlying formatter (denoted as _underlying_) where the referenced bit is converted to bool to be formatted.
The exposition-only constant /*is-vector-bool-reference*/<T> is true if and only if T denotes the type std::vector<bool, Alloc>::reference for some type Alloc and std::vector<bool, Alloc> is not a program-defined specialization.
Member functions
| template< class ParseContext > constexpr ParseContext::iterator parse( ParseContext& ctx ); | (1) | (since C++23) |
|---|---|---|
| template< class FormatContext >FormatContext::iterator format( const T& r, FormatContext& ctx ) const; | (2) | (since C++23) |
Equivalent to return
_underlying_.parse(ctx);.Equivalent to return
_underlying_.format(r, ctx);.
[edit] Example
[edit] See also
| | access specified element (public member function of std::vector<T,Allocator>) [edit] | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | swaps two std::vector::references (public static member function) [edit] |
[edit] External links
"Effective Modern C++" by Scott Meyers (2015), Chapter 2, Item 6: "Use the explicitly typed initializer idiom when auto deduces undesired types." (p.43-46) — describes a possible misuse of the proxy class std::vector::reference).