| Defined in header <ranges>
|
||
| Defined in header <iterator>
|
||
| inline namespace /* unspecified */ { inline constexpr /* unspecified */ ssize = /* unspecified */; } |
(since C++20) (customization point object) |
|
| Call signature |
||
| template< class T > requires /* see below */ constexpr auto ssize( T&& t ); |
(since C++20) | |
Calculates the number of elements in t in constant time, and converts the result to a signed type.
Given the subexpression of which t denotes the (possibly materialized) result object as E:
- If
ranges::size(t)is ill-formed,ranges::ssize(E)is also ill-formed. - Otherwise, let
Signedbemake-signed-like-t<decltype(ranges::size(t))>:- If std::ptrdiff_t is wider than
Signed,ranges::ssize(E)is expression-equivalent tostatic_cast<std::ptrdiff_t>(ranges::size(t)). - Otherwise,
ranges::ssize(E)is expression-equivalent tostatic_cast<Signed>(ranges::size(t)).
- If std::ptrdiff_t is wider than
Customization point objects
The name ranges::ssize 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 __ssize_fn.
All instances of __ssize_fn are equal. The effects of invoking different instances of type __ssize_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::ssize 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::ssize above, __ssize_fn models
-
std::invocable<__ssize_fn, Args...>, -
std::invocable<const __ssize_fn, Args...>, -
std::invocable<__ssize_fn&, Args...>, and -
std::invocable<const __ssize_fn&, Args...>.
Otherwise, no function call operator of __ssize_fn participates in overload resolution.
Notes
If ranges::ssize(e) is valid for an expression e, the return type is a signed-integer-like type.
Example
#include <array>
#include <iostream>
#include <ranges>
#include <type_traits>
int main()
{
std::array arr{1, 2, 3, 4, 5};
auto s = std::ranges::ssize(arr);
std::cout << "ranges::ssize(arr) = " << s << '\n'
<< "ranges::ssize is "
<< (std::is_signed_v<decltype(s)> ? "signed" : "unsigned")
<< '\n';
std::cout << "reversed arr: ";
for (--s; s >= 0; --s)
std::cout << arr[s] << ' ';
std::cout << "\n" "s = " << s << '\n';
}ranges::ssize(arr) = 5
ranges::ssize is signed
reversed arr: 5 4 3 2 1
s = -1Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 3403 | C++20 | ranges::size worked for some non-range types but ranges::ssize did not
|
made work |
See also
| (C++20) |
returns an integer equal to the size of a range (customization point object) |
| (C++20) |
specifies that a range knows its size in constant time (concept) |
| (C++20) |
returns the distance between an iterator and a sentinel, or between the beginning and end of a range (algorithm function object) |
| (C++17)(C++20) |
returns the size of a container or array (function template) |
Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.