Difference between revisions of "cpp/ranges/cend"
m (langlinks) |
m (fmt) |
||
| Line 1: | Line 1: | ||
| − | {{cpp/ranges/title | cend}} | + | {{cpp/ranges/title|cend}} |
{{cpp/ranges/navbar}} | {{cpp/ranges/navbar}} | ||
| − | |||
{{dcl begin}} | {{dcl begin}} | ||
| − | + | {{dcl header|ranges}} | |
| − | {{dcl header | ranges}} | + | {{dcl|notes={{mark custpt}}|since=c++20|1= |
| − | + | inline namespace /* unspecified */ { | |
| − | {{dcl | notes={{mark custpt}} | since=c++20 | 1= | + | inline constexpr /* unspecified */ cend = /* unspecified */; |
| − | inline namespace /*unspecified*/ { | + | |
| − | inline constexpr /*unspecified*/ cend = /*unspecified*/; | + | |
} | } | ||
}} | }} | ||
| − | |||
{{dcl h|Call signature}} | {{dcl h|Call signature}} | ||
| − | {{dcl | since=c++20 |1= | + | {{dcl|since=c++20|1= |
template< class T > | template< class T > | ||
requires /* see below */ | requires /* see below */ | ||
| Line 25: | Line 21: | ||
Let {{tt|CT}} be | Let {{tt|CT}} be | ||
| − | # {{c|const std::remove_reference_t<T>&}} if the argument is | + | # {{c|const std::remove_reference_t<T>&}} if the argument is an lvalue (i.e. {{tt|T}} is an lvalue reference type), |
# {{c|const T}} otherwise, | # {{c|const T}} otherwise, | ||
a call to {{tt|ranges::cend}} is expression-equivalent to {{c|ranges::end(static_cast<CT&&>(t))}}. | a call to {{tt|ranges::cend}} is expression-equivalent to {{c|ranges::end(static_cast<CT&&>(t))}}. | ||
| Line 36: | Line 32: | ||
===Example=== | ===Example=== | ||
{{example | {{example | ||
| − | + | | | |
| − | + | |code= | |
#include <algorithm> | #include <algorithm> | ||
#include <iostream> | #include <iostream> | ||
| Line 43: | Line 39: | ||
#include <vector> | #include <vector> | ||
| − | int main() | + | int main() |
{ | { | ||
| − | std::vector<int> | + | std::vector<int> vec = {3, 1, 4}; |
| − | + | if (std::ranges::find(vec, 5) != std::ranges::cend(vec)) | |
| − | + | std::cout << "Found a 5 in vector vec!\n"; | |
| − | std::cout << " | + | |
| − | + | ||
| − | int | + | int arr[] = {5, 10, 15}; |
| − | if (ranges::find( | + | if (std::ranges::find(arr, 5) != std::ranges::cend(arr)) |
| − | std::cout << " | + | std::cout << "Found a 5 in array arr!\n"; |
| − | + | ||
} | } | ||
| − | + | |output=Found a 5 in array arr! | |
}} | }} | ||
===See also=== | ===See also=== | ||
{{dsc begin}} | {{dsc begin}} | ||
| − | {{dsc inc | cpp/ranges/dsc end}} | + | {{dsc inc|cpp/ranges/dsc end}} |
| − | {{dsc inc | cpp/iterator/dsc end}} | + | {{dsc inc|cpp/iterator/dsc end}} |
{{dsc end}} | {{dsc end}} | ||
{{langlinks|de|es|ja|ru|zh}} | {{langlinks|de|es|ja|ru|zh}} | ||
Revision as of 14:09, 16 January 2023
| Defined in header <ranges>
|
||
| inline namespace /* unspecified */ { inline constexpr /* unspecified */ cend = /* unspecified */; |
(since C++20) (customization point object) |
|
| Call signature |
||
| template< class T > requires /* see below */ |
(since C++20) | |
Returns a sentinel indicating the end of a const-qualified range.
Let CT be
- const std::remove_reference_t<T>& if the argument is an lvalue (i.e.
Tis an lvalue reference type), - const T otherwise,
a call to ranges::cend is expression-equivalent to ranges::end(static_cast<CT&&>(t)).
If ranges::cend(e) is valid for an expression e, where decltype((e)) is T, then CT models std::ranges::range, and std::sentinel_for<S, I> is true in all cases, where S is decltype(ranges::cend(e)), and I is decltype(ranges::cbegin(e)).
Contents |
Expression-equivalent
Expression e is expression-equivalent to expression f, if
- e and f have the same effects, and
- either both are constant subexpressions or else neither is a constant subexpression, and
- either both are potentially-throwing or else neither is potentially-throwing (i.e. noexcept(e) == noexcept(f)).
Customization point objects
The name ranges::cend 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 __cend_fn.
All instances of __cend_fn are equal. The effects of invoking different instances of type __cend_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::cend 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::cend above, __cend_fn models
- std::invocable<__cend_fn, Args...>,
- std::invocable<const __cend_fn, Args...>,
- std::invocable<__cend_fn&, Args...>, and
- std::invocable<const __cend_fn&, Args...>.
Otherwise, no function call operator of __cend_fn participates in overload resolution.
Example
#include <algorithm> #include <iostream> #include <ranges> #include <vector> int main() { std::vector<int> vec = {3, 1, 4}; if (std::ranges::find(vec, 5) != std::ranges::cend(vec)) std::cout << "Found a 5 in vector vec!\n"; int arr[] = {5, 10, 15}; if (std::ranges::find(arr, 5) != std::ranges::cend(arr)) std::cout << "Found a 5 in array arr!\n"; }
Output:
Found a 5 in array arr!
See also
| (C++20) |
returns a sentinel indicating the end of a range (customization point object) |
| (C++11)(C++14) |
returns an iterator to the end of a container or array (function template) |
