Namespaces
Variants

std:: size, std:: ssize

From cppreference.net
C++
Iterator library
Iterator concepts
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
size ssize
(C++17) (C++20)
(C++17)
(C++17)
Definido en el encabezado <array>
Definido en el encabezado <deque>
Definido en el encabezado <flat_map>
Definido en el encabezado <flat_set>
Definido en el encabezado <forward_list>
Definido en el encabezado <inplace_vector>
Definido en el encabezado <iterator>
Definido en el encabezado <list>
Definido en el encabezado <map>
Definido en el encabezado <regex>
Definido en el encabezado <set>
Definido en el encabezado <span>
Definido en el encabezado <string>
Definido en el encabezado <string_view>
Definido en el encabezado <unordered_map>
Definido en el encabezado <unordered_set>
Definido en el 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)

Devuelve el tamaño del rango dado.

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

Contenidos

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 pueden ser detectadas.

Las sobrecargas de size encontradas mediante búsqueda dependiente de argumento pueden utilizarse para personalizar el comportamiento de std :: ranges:: size , std :: ranges:: ssize , y std :: ranges:: empty .

(desde C++20)

Implementación posible

tamaño (1) 
template<class C>
constexpr auto size(const C& c) -> decltype(c.size())
{
    return c.size();
}
tamaño con signo (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());
}
tamaño (3) 
template<class T, std::size_t N>
constexpr std::size_t size(const T (&array)[N]) noexcept
{
    return N;
}
tamaño con signo (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ísticas Valor Std Característica
__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

Ejecutar 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 incorporados
    int a[]{-5, 10, 15};
    // Retorna el número de elementos (no bytes) a diferencia de sizeof
    assert(std::size(a) == 3);
    std::cout << "size of a[]: " << sizeof a << '\n'; // 12, si sizeof(int) == 4
    // Proporciona una forma segura (comparada con sizeof) de obtener el tamaño del búfer de cadena
    const char str[] = "12345";
    // Estos funcionan correctamente y dan el resultado adecuado
    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 falla al compilar
    std::cout << sizeof(str_decayed) << '\n'; // ¡Imprime el tamaño del puntero!
    // Desde C++20 está disponible el tamaño con signo (std::ssize)
    auto i = std::ssize(v);
    for (--i; i != -1; --i)
        std::cout << v[i] << (i ? ' ' : '\n');
    assert(i == -1);
    // Nótese que el literal de cadena incluye el carácter nulo final, el cual
    // formará parte del array de caracteres construido. Esto hace que std::size
    // se comporte de forma 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);
}

Salida posible: 

size of a[]: 12
8
4 1 3

Véase también

tipo entero con signo devuelto al restar dos punteros
(typedef)
tipo entero sin signo devuelto por el operador sizeof
(typedef)
(C++20)
devuelve un entero igual al tamaño de un rango
(customization point object)
(C++20)
devuelve un entero con signo igual al tamaño de un rango
(customization point object)