Ver el código de «cpp/iterator/size»

No tienes permiso para modificar esta página, por el siguiente motivo:
La acción que has solicitado está restringida a los usuarios de uno de estos 2 grupos: Usuarios, Administradores.
Puedes ver y copiar el código fuente de esta página.
{{cpp/title|size|ssize}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{cpp/iterator/range access headers}}
{{dcla|num=1|since=c++17|
template< class C >
constexpr auto size( const C& c ) -> decltype(c.size());
}}
{{dcla|num=2|since=c++20|
template< class C >
constexpr auto ssize( const C& c )
    -> std::common_type_t<std::ptrdiff_t,
                          std::make_signed_t<decltype(c.size())>>;
}}
{{dcla|num=3|since=c++17|
template< class T, std::size_t N >
constexpr std::size_t size( const T (&array)[N] ) noexcept;
}}
{{dcla|num=4|since=c++20|
template< class T, std::ptrdiff_t N >
constexpr std::ptrdiff_t ssize( const T (&array)[N] ) noexcept;
}}
{{dcl end}}

Devuelve el tamaño de un rango dado.

@1, 2@ Devuelve {{c|c.size()}}, convertido al tipo de retorno si es necesario.
@3, 4@ Devuelve {{c|N}}.

===Parámetros===
{{par begin}}
{{par | c | Un contenedor o vista con una función miembro {{tt|size}}.}}
{{par | array | Un ''array'' de tipo arbitrario.}}
{{par end}}

===Valor de retorno===
@1@ {{c|c.size()}},
@2@ {{c multi|static_cast<std::common_type_t<std::ptrdiff_t,|                               std::make_signed_t<decltype(c.size())>>>(c.size())}}.
@3,4@ {{c|N}}.

===Excepciones===
@1,2@ {{cpp/impldef exception item}}

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

{{rrev|since=c++20|
Las sobrecargas de {{tt|size}} detectadas por la [[cpp/language/adl|búsqueda dependiente de argumentos]] se pueden usar para personalizar el comportamiento de {{c/core|std::ranges::size}}, {{c/core|std::ranges::ssize}} y {{c/core|std::ranges::empty}}.
}}

===Posible implementación===
{{eq impl
|title1=size (1)|ver1=1|1=
template<class C>
constexpr auto size(const C& c) -> decltype(c.size())
{
    return c.size();
}
|title2=ssize (2)|ver2=2|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());
}
|title3=size (3)|ver3=3|3=
template<class T, std::size_t N>
constexpr std::size_t size(const T (&array)[N]) noexcept
{
    return N;
}
|title4=ssize (4)|ver4=4|4=
template<class T, std::ptrdiff_t N>
constexpr std::ptrdiff_t ssize(const T (&array)[N]) noexcept
{
    return N;
}
}}

===Notas===
{{ftm begin|std=1|comment=1}}
{{ftm|std=C++17|value=201411L|__cpp_lib_nonmember_container_access|{{tt|std::size()}}, {{lc|std::data}} y {{lc|std::empty}}.}}
{{ftm|std=C++20|value=201902L|__cpp_lib_ssize|{{tt|std::ssize()}} {{vl|2,4}} y {{ltf|cpp/container/span/size|std::span::size}} sin signo.}}
{{ftm end}}

===Ejemplo===
{{example
|code=
#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);
}
|p=true<!--tamaño del puntero y entero-->
|output=
tamaño de a[]: 12
8
4 1 3
}}

===Véase también===
{{dsc begin}}
{{dsc inc | cpp/types/dsc ptrdiff_t}}
{{dsc inc | cpp/types/dsc size_t}}
{{dsc inc | cpp/ranges/dsc size}}
{{dsc inc | cpp/ranges/dsc ssize}}
{{dsc end}}

{{langlinks|en|ja|zh}}
Plantillas usadas en esta página:
Volver a cpp/iterator/size.
cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Ver el código de «cpp/iterator/size»

Navegación

Herramientas
