std::ranges::size

inline namespace /* unspecified */ {
    inline constexpr auto size = /* unspecified */;
}

template< class T >
    requires /* see below */
constexpr auto size( T&& t );

Calcula el número de elementos en t en tiempo constante.

Dada la subexpresión de la cual t denota el objeto resultado (posiblemente materializado) como E, y el tipo de E como T:

• Si T es un arreglo de límite desconocido, ranges::size(E) está mal formado.
• En caso contrario, si T es un tipo arreglo, ranges::size(E) es equivalente en expresión a decay-copy (std::extent_v<T>)(hasta C++23)auto(std::extent_v<T>)(desde C++23).
• En caso contrario, si se satisfacen todas las siguientes condiciones, ranges::size(E) es equivalente en expresión a decay-copy (t.size())(hasta C++23)auto(t.size())(desde C++23):
  • ranges::disable_sized_range<std::remove_cv_t<T>> es false.
  • decay-copy (t.size())(hasta C++23)auto(t.size())(desde C++23) es una expresión válida de tipo similar a entero.
• En caso contrario, si se satisfacen todas las siguientes condiciones, ranges::size(E) es equivalente en expresión a decay-copy (size(t))(hasta C++23)auto(size(t))(desde C++23):
  • T es un tipo clase o enumeración.
  • ranges::disable_sized_range<std::remove_cv_t<T>> es false.
  • decay-copy (size(t))(hasta C++23)auto(size(t))(desde C++23) es una expresión válida de tipo similar a entero, donde el significado de size se establece como si se realizara una búsqueda dependiente de argumentos únicamente.
• En caso contrario, si se satisfacen todas las siguientes condiciones, ranges::size(E) es equivalente en expresión a to-unsigned-like (ranges::end(t) - ranges::begin(t)):
  • T modela forward_range.
  • Dado el tipo de ranges::begin(t) como I y el tipo de ranges::end(t) como S, ambos sized_sentinel_for<S, I> y forward_iterator<I> son modelados.
  • to-unsigned-like (ranges::end(t) - ranges::begin(t)) es una expresión válida.
• En caso contrario, ranges::size(E) está mal formado.

Los casos mal formados diagnosticables anteriores resultan en fallo de sustitución cuando ranges::size(E) aparece en el contexto inmediato de una instanciación de plantilla.

Objetos de punto de personalización

El nombre ranges::size denota un objeto de punto de personalización , que es un objeto función constante de un tipo de clase literal semiregular . Consulte CustomizationPointObject para más detalles.

Notas

Siempre que ranges :: size ( e ) sea válido para una expresión e , el tipo de retorno es integer-like .

El estándar C++20 requiere que si la llamada subyacente a la función size devuelve un prvalue, el valor de retorno se construye por movimiento desde el objeto temporal materializado. Todas las implementaciones devuelven directamente el prvalue en su lugar. El requisito se corrige mediante la propuesta posterior a C++20 P0849R8 para coincidir con las implementaciones.

La expresión ranges:: distance ( e ) también puede utilizarse para determinar el tamaño de un rango e . A diferencia de ranges :: size ( e ) , ranges:: distance ( e ) funciona incluso si e es un rango sin tamaño definido, al costo de tener complejidad lineal en ese caso.

Ejemplo

#include <iostream>
#include <ranges>
#include <type_traits>
#include <vector>
int main()
{
    auto v = std::vector<int>{};
    std::cout << "ranges::size(v) == " << std::ranges::size(v) << '\n';
    auto il = {7};     // std::initializer_list
    std::cout << "ranges::size(il) == " << std::ranges::size(il) << '\n';
    int array[]{4, 5}; // array has a known bound
    std::cout << "ranges::size(array) == " << std::ranges::size(array) << '\n';
    static_assert(std::is_signed_v<decltype(std::ranges::size(v))> == false);
}

ranges::size(v) == 0
ranges::size(il) == 1
ranges::size(array) == 2

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también