std::span<T,Extent>::last
From cppreference.com
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Containers library
(C++17)
(C++11)
(C++26)
(C++26)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++23)
(C++23)
(C++23)
(C++23)
(C++20)
(C++23)
Tables
std::span
(C++26)
(C++23)
(C++23)
(C++23)
(C++23)
span::last
template< std::size_t Count >
constexpr std::span <element_type, Count> last() const;
(1)
(since C++20)
constexpr std::span <element_type, Count> last() const;
constexpr std::span <element_type, std::dynamic_extent >
last( size_type count ) const;
(2)
(since C++20)
last( size_type count ) const;
Obtains a subview over the last Count or count elements of this span.
1) The element count is provided as a template argument, and the subview has a static extent.
If Count > Extent is true, the program is ill-formed.
2) The element count is provided as a function argument, and the subview has a dynamic extent.
If Count > size() or count > size() is true, the behavior is undefined.
(until C++26)If Count > size() or count > size() is true:
- If the implementation is hardened, a contract violation occurs. Moreover, if the contract-violation handler returns under "observe" evaluation semantic, the behavior is undefined.
- If the implementation is not hardened, the behavior is undefined.
Contents
[edit] Parameters
count
-
the number of the elements of the subview
[edit] Return value
1) std::span <element_type, Count>{data() + (size() - Count), Count}
2) std::span <element_type, std::dynamic_extent >{data() + (size() - count), count}
[edit] Example
Run this code
#include <iostream> #include <span> #include <string_view> void println(const std::string_view title, const auto& container) { std::cout << title << '[' << std::size (container) << "]{ "; for (const auto& elem : container) std::cout << elem << ", "; std::cout << "};\n"; }; void run(std::span <const int> span) { println("span: ", span); std::span <const int, 3> span_last = span.last<3>(); println("span.last<3>(): ", span_last); std::span <const int, std::dynamic_extent > span_last_dynamic = span.last(2); println("span.last(2): ", span_last_dynamic); } int main() { int a[8]{1, 2, 3, 4, 5, 6, 7, 8}; println("int a", a); run(a); }
Output:
int a[8]{ 1, 2, 3, 4, 5, 6, 7, 8, };
span: [8]{ 1, 2, 3, 4, 5, 6, 7, 8, };
span.last<3>(): [3]{ 6, 7, 8, };
span.last(2): [2]{ 7, 8, };[edit] See also
obtains a subspan consisting of the first
(public member function) [edit]
N elements of the sequence (public member function) [edit]