std::ranges::ssize
| Definido en el archivo de encabezado <ranges>
|
||
inline namespace /*no especificado*/ { inline constexpr /*no especificado*/ ssize = /*no especificado*/; } |
(desde C++20) (objeto punto de personalización) |
|
| Signatura de la llamada |
||
template< class T > requires /* véase a continuación */ constexpr /*similar-a-entero-con-signo*/ ssize( T&& t ); |
(desde C++20) | |
Devuelve el tamaño de un rango convertido a un tipo con signo.
Si ranges::size(std::forward<T>(t)) está bien formada, dejemos que MadeSigned denote
- la versión correspondiente con signo de
decltype(ranges::size(std::forward<T>(t))), si es más ancho que std::ptrdiff_t, o - std::ptrdiff_t de lo contrario,
una llamada a ranges::ssize es equivalente en expresión a static_cast<MadeSigned>(ranges::size(std::forward<T>(t))).
En todos los otros casos, una llamada a ranges::ssize está mal formada, lo que puede resultar en falla en la sustitución cuando ranges::ssize(t) aparece en el contexto inmediato de una instanciación de plantilla.
Equivalente en expresión
La expresión e es equivalente-en-expresión a la expresión f, si e y f tienen los mismos efectos, ambas potencialmente lanzan o ambas potencialmente no lanzan (es decir, noexcept (e) == noexcept(f)), y ambas son subexpresiones constantes o ambas no son subexpresiones constantes.
Objetos de punto de personalización
El nombre ranges::ssize denota un objeto de punto de personalización, que es un objeto función const de un tipo clase literal semiregular (denotado, a efectos de exposición, como ssize_ftor). Todos los ejemplares de ssize_ftor son iguales. Por lo tanto, ranges::ssize puede copiarse libremente y sus copias pueden usarse indistintamente.
Dado un conjunto de tipos Args..., si std::declval<Args>()... cumple con los requerimientos para los argumentos de ranges::ssize mencionado anteriormente, ssize_ftor satisfará a std::invocable<const ssize_ftor&, Args...>. De lo contrario, ningún operador de llamada a función de ssize_ftor participa en la resolución de sobrecarga.
Notas
Si ranges::ssize(e) es válido para una expresión e, el tipo de retorno es un tipo similar a un entero. Es decir, un tipo entero para el que std::is_signed_v es true, o uno de los tipos enteros con signo.
La anchura de un tipo similar a un entero puede detectarse mediante std::numeric_limits::digits.
Ejemplo
#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 "
<< (std::is_signed_v<decltype(s)> ? "tiene signo" : "no tiene signo")
<< '\n';
std::cout << "arr invertido: ";
for (--s; s >= 0; --s)
std::cout << arr[s] << ' ';
std::cout << "\n" "s = " << s << '\n';
}
Salida:
ranges::ssize(arr) = 5
ranges::ssize tiene signo
arr invertido: 5 4 3 2 1
s = -1
Informes de defectos
Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 3403 | C++20 | ranges::size funcionaba con algunos tipos no rango, pero ranges::ssize no.
|
Se hizo que funcionara. |
Véase también
(C++20) |
Obtiene el tamaño de un rango cuyo tamaño puede calcularse en tiempo constante. (objeto punto de personalización) |
(C++17)(C++20) |
Devuelve el tamaño de un contenedor o un array. (plantilla de función) |