std::ranges:: size

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 array de límite desconocido, ranges :: size ( E ) está mal formado.
• De lo contrario, si T es un tipo de arreglo, ranges :: size ( E ) es equivalente-expresión a decay-copy  ( std:: extent_v < T > ) (hasta C++23) auto ( std:: extent_v < T > ) (desde C++23) .
• De lo contrario, si se satisfacen todas las siguientes condiciones, ranges :: size ( E ) es expresión-equivalente 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 integer-like .
• De lo contrario, si se satisfacen todas las siguientes condiciones, ranges :: size ( E ) es expresión-equivalente 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 únicamente búsqueda dependiente de argumentos .
• De lo contrario, si se satisfacen todas las siguientes condiciones, ranges :: size ( E ) es expresión-equivalente 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 , tanto sized_sentinel_for < S, I > como forward_iterator < I > están modelados.
  • to-unsigned-like  ( ranges:: end ( t ) - ranges:: begin ( t ) ) es una expresión válida.
• De lo contrario, ranges :: size ( E ) está mal formado.

Los casos incorrectos 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