Difference between revisions of "cpp/ranges/cbegin"
m (→Example: ~) |
D41D8CD98F (Talk | contribs) m (→Notes) |
||
| (2 intermediate revisions by one user not shown) | |||
| Line 3: | Line 3: | ||
{{dcl begin}} | {{dcl begin}} | ||
{{dcl header|ranges}} | {{dcl header|ranges}} | ||
| + | {{dcl header|iterator}} | ||
{{dcl|notes={{mark custpt}}|since=c++20|1= | {{dcl|notes={{mark custpt}}|since=c++20|1= | ||
inline namespace /* unspecified */ { | inline namespace /* unspecified */ { | ||
| Line 37: | Line 38: | ||
{{cpp/ranges/cpo}} | {{cpp/ranges/cpo}} | ||
| + | |||
| + | ===Notes=== | ||
| + | For an lvalue range {{c|e}} of type {{c|T}}, {{c|ranges::cbegin(e)}} is equivalent to | ||
| + | {{rrev multi|until1=c++23|rev1= | ||
| + | {{c|ranges::begin(std::as_const(e))}}. | ||
| + | |rev2= | ||
| + | * {{c|ranges::begin(e)}} if {{c|T}} models {{lconcept|constant_range}}. | ||
| + | * Otherwise, {{c|ranges::begin(std::as_const(e))}} if {{c|const T}} models {{lconcept|constant_range}}. | ||
| + | * Otherwise, {{c|std::basic_const_iterator(ranges::begin(e))}}. | ||
| + | }} | ||
===Example=== | ===Example=== | ||
Latest revision as of 23:14, 7 November 2023
| Defined in header <ranges>
|
||
| Defined in header <iterator>
|
||
| inline namespace /* unspecified */ { inline constexpr /* unspecified */ cbegin = /* unspecified */; |
(since C++20) (customization point object) |
|
| Call signature |
||
| template< class T > requires /* see below */ |
(since C++20) | |
|
Returns an iterator to the first element of the const-qualified argument. |
(until C++23) |
|
Returns a constant iterator to the first element of the argument. |
(since C++23) |
|
Let
A call to |
(until C++23) |
|
If the argument is an lvalue or ranges::enable_borrowed_range<std::remove_cv_t<T>> is true, then a call to
In all other cases, a call to |
(since C++23) |
The return type models std::input_or_output_iterator and constant-iterator(since C++23) in all cases.
Contents |
Customization point objects
The name ranges::cbegin denotes a customization point object, which is a const function object of a literal semiregular class type. For exposition purposes, the cv-unqualified version of its type is denoted as __cbegin_fn.
All instances of __cbegin_fn are equal. The effects of invoking different instances of type __cbegin_fn on the same arguments are equivalent, regardless of whether the expression denoting the instance is an lvalue or rvalue, and is const-qualified or not (however, a volatile-qualified instance is not required to be invocable). Thus, ranges::cbegin can be copied freely and its copies can be used interchangeably.
Given a set of types Args..., if std::declval<Args>()... meet the requirements for arguments to ranges::cbegin above, __cbegin_fn models
- std::invocable<__cbegin_fn, Args...>,
- std::invocable<const __cbegin_fn, Args...>,
- std::invocable<__cbegin_fn&, Args...>, and
- std::invocable<const __cbegin_fn&, Args...>.
Otherwise, no function call operator of __cbegin_fn participates in overload resolution.
[edit] Notes
For an lvalue range e of type T, ranges::cbegin(e) is equivalent to
| (until C++23) | |
|
(since C++23) |
[edit] Example
#include <cassert> #include <ranges> #include <vector> int main() { std::vector v{3, 1, 4}; auto vi = std::ranges::cbegin(v); assert(3 == *vi); ++vi; // OK, constant-iterator object is mutable assert(1 == *vi); // *vi = 13; // Error: constant-iterator points to an immutable element int a[]{3, 1, 4}; auto ai = std::ranges::cbegin(a); // cbegin works with C-arrays as well assert(3 == *ai and *(ai + 1) == 1); // *ai = 13; // Error: read-only variable is not assignable }
[edit] See also
| (C++20) |
returns an iterator to the beginning of a range (customization point object) |
| (C++11)(C++14) |
returns an iterator to the beginning of a container or array (function template) |
