std::size, std::ssize

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de iteradores

Conceptos de iteradores
indirectly_readable (C++20) indirectly_writable (C++20) weakly_incrementable (C++20) incrementable (C++20) input_or_output_iterator (C++20) sentinel_for (C++20) sized_sentinel_for (C++20)	input_iterator (C++20) output_iterator (C++20) forward_iterator (C++20) bidirectional_iterator (C++20) random_access_iterator (C++20) contiguous_iterator (C++20)
Primitivas de iteradores
iterator_traits input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag (C++20) iterator (en desuso en C++17)	incrementable_traits (C++20) indirectly_readable_traits (C++20) iter_value_titer_difference_titer_reference_titer_rvalue_reference_titer_common_reference_t (C++20)(C++20)(C++20)(C++20)(C++20)
Conceptos de algoritmos y servicios
Conceptos invocables indirectos
indirectly_unary_invocableindirectly_regular_unary_invocable (C++20)(C++20) indirect_unary_predicate (C++20)	indirect_binary_predicate (C++20) indirect_equivalence_relation (C++20) indirect_strict_weak_order (C++20)
Requerimientos comunes de algoritmos
indirectly_movable (C++20) indirectly_movable_storable (C++20) indirectly_copyable (C++20) indirectly_copyable_storable (C++20)	indirectly_swappable (C++20) indirectly_comparable (C++20) permutable (C++20) mergeable (C++20) sortable (C++20)
Servicios
indirect_result_t	projected
Adaptadores de iteradores
reverse_iterator move_iterator (C++11) move_sentinel (C++20) common_iterator (C++20) counted_iterator (C++20) back_insert_iterator front_insert_iterator insert_iterator	make_reverse_iterator (C++14) make_move_iterator (C++11) default_sentinel_tdefault_sentinel (C++20)(C++20) unreachable_sentinel_tunreachable_sentinel (C++20)(C++20) back_inserter front_inserter inserter
Iteradores de flujos
istream_iterator ostream_iterator	istreambuf_iterator ostreambuf_iterator
Puntos de personalización de iteradores
ranges::iter_move (C++20)
ranges::iter_swap (C++20)
Operaciones de iteradores
advance distance prev (C++11) next (C++11)	ranges::advance (C++20) ranges::distance (C++20) ranges::prev (C++20) ranges::next (C++20)
Acceso a rangos
begincbegin (C++11)(C++14) endcend (C++11)(C++14) sizessize (C++17)(C++20)	rbegincrbegin (C++14)(C++14) rendcrend (C++14)(C++14) empty (C++17) data (C++17)

 

<tbody> </tbody>

Definido en el archivo de encabezado <array>
Definido en el archivo de encabezado <deque>
Definido en el archivo de encabezado <flat_map>
Definido en el archivo de encabezado <flat_set>
Definido en el archivo de encabezado <forward_list>
Definido en el archivo de encabezado <inplace_vector>
Definido en el archivo de encabezado <iterator>
Definido en el archivo de encabezado <list>
Definido en el archivo de encabezado <map>
Definido en el archivo de encabezado <regex>
Definido en el archivo de encabezado <set>
Definido en el archivo de encabezado <span>
Definido en el archivo de encabezado <string>
Definido en el archivo de encabezado <string_view>
Definido en el archivo de encabezado <unordered_map>
Definido en el archivo de encabezado <unordered_set>
Definido en el archivo de encabezado <vector>
template< class C > constexpr auto size( const C& c ) -> decltype(c.size());	(1)	(desde C++17)
template< class C > constexpr auto ssize( const C& c ) -> std::common_type_t<std::ptrdiff_t, std::make_signed_t<decltype(c.size())>>;	(2)	(desde C++20)
template< class T, std::size_t N > constexpr std::size_t size( const T (&array)[N] ) noexcept;	(3)	(desde C++17)
template< class T, std::ptrdiff_t N > constexpr std::ptrdiff_t ssize( const T (&array)[N] ) noexcept;	(4)	(desde C++20)

See More

Devuelve el tamaño de un rango dado.

1, 2) Devuelve c.size(), convertido al tipo de retorno si es necesario.

3, 4) Devuelve N.

Parámetros

c	-	Un contenedor o vista con una función miembro size.
array	-	Un array de tipo arbitrario.

Valor de retorno

1) c.size(),

2) static_cast<std::common_type_t<std::ptrdiff_t,
std::make_signed_t<decltype(c.size())>>>(c.size()).

3,4) N.

Excepciones

1,2) Puede lanzar excepciones definidas por la implementación.

Sobrecargas

Se pueden proporcionar sobrecargas personalizadas de size para clases y enumeraciones que no exponen una función miembro size() adecuada, pero que se pueden detectar.

Las sobrecargas de size detectadas por la búsqueda dependiente de argumentos se pueden usar para personalizar el comportamiento de std::ranges::size, std::ranges::ssize y std::ranges::empty.

(desde C++20)

Posible implementación

size (1)
template<class C> constexpr auto size(const C& c) -> decltype(c.size()) { return c.size(); }
ssize (2)
template<class C> constexpr auto ssize(const C& c) -> std::common_type_t<std::ptrdiff_t, std::make_signed_t<decltype(c.size())>> { using R = std::common_type_t<std::ptrdiff_t, std::make_signed_t<decltype(c.size())>>; return static_cast<R>(c.size()); }
size (3)
template<class T, std::size_t N> constexpr std::size_t size(const T (&array)[N]) noexcept { return N; }
ssize (4)
template<class T, std::ptrdiff_t N> constexpr std::ptrdiff_t ssize(const T (&array)[N]) noexcept { return N; }

Notas

Macro de prueba de característica	Valor	Estándar	Comentario
__cpp_lib_nonmember_container_access	201411L	(C++17)	std::size(), std::data y std::empty.
__cpp_lib_ssize	201902L	(C++20)	std::ssize() (2,4) y std::span::size() sin signo.

Ejemplo

Ejecuta este código

#include <cassert>
#include <cstring>
#include <iostream>
#include <vector>

int main()
{
    // Funciona con contenedores
    std::vector<int> v{3, 1, 4};
    assert(std::size(v) == 3);
    
    // Y también funciona con arrays integrados
    int a[]{-5, 10, 15};
    // Devuelve el número de elementos (no bytes) en lugar de sizeof
    assert(std::size(a) == 3);
    std::cout << "tamaño de a[]: " << sizeof a << '\n'; // 12, if sizeof(int) == 4
    
    // Proporciona una forma segura (en comparación con sizeof)
    // de obtener el tamaño del búfer de cadena
    const char str[] = "12345";
    // Estos están bien y dan el resultado correcto.
    assert(std::size(str) == 6);
    assert(sizeof(str) == 6);
    
    // Pero el uso de sizeof aquí es una fuente común de errores.
    const char* str_decayed = "12345";
    // std::cout << std::size(str_decayed) << '\n'; // Útilmente no se compila
    std::cout << sizeof(str_decayed) << '\n'; // ¡Imprime el tamaño del puntero!
    
    // Desde C++20 el tamaño con signo (std::ssize) está disponible
    auto i = std::ssize(v);
    for (--i; i != -1; --i)
        std::cout << v[i] << (i ? ' ' : '\n');
    assert(i == -1);

    // Ten en cuenta que el literal de cadena incluye el carácter nulo final, que
    // será parte del array de caracteres construida. Esto hace que std::size
    // se comporte de manera diferente a std::strlen y std::string::size:
    constexpr char symbols[] = "0123456789";

    static_assert(std::size(symbols) == 11);
    static_assert(std::string(symbols).size() == 10);
    assert(std::strlen(symbols) == 10);
}

Posible salida:

tamaño de a[]: 12
8
4 1 3

Véase también

ptrdiff_t	Tipo entero con signo devuelto al restar dos punteros. (typedef)
size_t	Tipo entero sin signo devuelto por el operador sizeof. (typedef)
ranges::size (C++20)	Obtiene el tamaño de un rango cuyo tamaño puede calcularse en tiempo constante. (objeto punto de personalización)
ranges::ssize (C++20)	Obtiene el tamaño de un rango cuyo tamaño puede calcularse en tiempo constante y lo convierte a un entero con signo. (objeto punto de personalización)