funciones<iterator>

advance

Incrementa un iterador un número especificado de posiciones.

template <class InputIterator, class Distance>
void advance(InputIterator& InIt, Distance Off);

Parámetros

InIt
Iterador que se va a incrementar y que debe satisfacer los requisitos de un iterador de entrada.

Off
Tipo entero convertible en el tipo de diferencia del iterador y que especifica el número de incrementos que la posición del iterador debe avanzar.

Comentarios

El intervalo debe ser noingular, donde los iteradores deben ser desreferenciables o más allá del final.

InputIterator Si cumple los requisitos de un tipo de iterador bidireccional, Off puede ser negativo. Si InputIterator es un tipo de iterador de entrada o reenvío, Off debe ser no negativo.

La función advance tiene complejidad constante cuando InputIterator cumple los requisitos de un iterador de acceso aleatorio. En caso contrario, tiene complejidad lineal y, por tanto, es potencialmente costosa.

Ejemplo

// iterator_advance.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>

int main()
{
    using namespace std;

    list<int> L;
    for (int i = 1; i < 9; ++i)
    {
        L.push_back(i);
    }
    list<int>::iterator LPOS = L.begin();

    cout << "The list L is: ( ";
    for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
    {
        cout << *L_Iter << " ";
    }
    cout << ")." << endl;

    cout << "The iterator LPOS initially points to the first element: "
        << *LPOS << "." << endl;

    advance(LPOS, 4);
    cout << "LPOS is advanced 4 steps forward to point"
        << " to the fifth element: "
        << *LPOS << "." << endl;

    advance(LPOS, -3);
    cout << "LPOS is moved 3 steps back to point to the "
        << "2nd element: " << *LPOS << "." << endl;
}

The list L is: ( 1 2 3 4 5 6 7 8 ).
The iterator LPOS initially points to the first element: 1.
LPOS is advanced 4 steps forward to point to the fifth element: 5.
LPOS is moved 3 steps back to point to the 2nd element: 2.

back_inserter

Crea un iterador que puede insertar elementos en la parte posterior de un contenedor especificado.

template <class Container>
back_insert_iterator<Container> back_inserter(Container& Cont);

Parámetros

Cont
Contenedor en el que se va a ejecutar la inserción en el final.

Valor devuelto

back_insert_iterator asociado con el objeto contenedor Cont.

Comentarios

Dentro de la biblioteca estándar de C++, el argumento debe hacer referencia a uno de los tres contenedores de secuencia que tienen la función push_backmiembro : deque Class, list Class o vector Class.

Ejemplo

// iterator_back_inserter.cpp
// compile with: /EHsc
#include <iterator>
#include <vector>
#include <iostream>

int main()
{
    using namespace std;

    vector<int> vec;
    for (int i = 0; i < 3; ++i)
    {
        vec.push_back(i);
    }

    cout << "The initial vector vec is: ( ";
    for (auto vIter = vec.begin(); vIter != vec.end(); vIter++)
    {
        cout << *vIter << " ";
    }
    cout << ")." << endl;

    // Insertions can be done with template function
    back_insert_iterator<vector<int> > backiter(vec);
    *backiter = 30;
    backiter++;
    *backiter = 40;

    // Alternatively, insertions can be done with the
    // back_insert_iterator member function
    back_inserter(vec) = 500;
    back_inserter(vec) = 600;

    cout << "After the insertions, the vector vec is: ( ";
    for (auto vIter = vec.begin(); vIter != vec.end(); vIter++)
    {
        cout << *vIter << " ";
    }
    cout << ")." << endl;
}

The initial vector vec is: ( 0 1 2 ).
After the insertions, the vector vec is: ( 0 1 2 30 40 500 600 ).

begin

Recupera un iterador en el primer elemento de un contenedor especificado.

template <class Container>
auto begin(Container& cont)  `
   -> decltype(cont.begin());

template <class Container>
auto begin(const Container& cont)   `
   -> decltype(cont.begin());

template <class Ty, class Size>
Ty *begin(Ty (& array)[Size]);

Parámetros

cont
Un contenedor .

array
Matriz de objetos de tipo Ty.

Valor devuelto

Las dos primeras funciones de plantilla devuelven cont.begin(). La primera función no es constante; la segunda es constante.

La tercera función de plantilla devuelve array.

Ejemplo

Se recomienda usar esta función de plantilla en lugar del miembro contenedor begin() cuando se precise un comportamiento más genérico.

// cl.exe /EHsc /nologo /W4 /MTd
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>

template <typename C> void reverse_sort(C& c)
{
    std::sort(std::begin(c), std::end(c), std::greater<>());
}

template <typename C> void print(const C& c)
{
    for (const auto& e : c)
    {
        std::cout << e << " ";
    }
    std::cout << "\n";
}

int main() 
{
    std::vector<int> v = { 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1 };

    print(v);
    reverse_sort(v);
    print(v);

    std::cout << "--\n";

    int arr[] = { 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1 };

    print(arr);
    reverse_sort(arr);
    print(arr);
}

11 34 17 52 26 13 40 20 10 5 16 8 4 2 1
52 40 34 26 20 17 16 13 11 10 8 5 4 2 1
--
23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1
160 106 80 70 53 40 35 23 20 16 10 8 5 4 2 1

La función reverse_sort admite contenedores de cualquier clase, además de matrices regulares, porque llama a la versión que no es miembro de begin(). Codificación reverse_sort para usar el miembro begin()del contenedor :

template <typename C>
void reverse_sort(C& c) {
    using std::begin;
    using std::end;

    std::sort(c.begin(), c.end(), std::greater<>());

}

A continuación, el envío de una matriz a ella provoca este error del compilador:

error C2228: left of '.begin' must have class/struct/union

cbegin

Recupera un iterador const (de solo lectura) en el primer elemento de un contenedor especificado.

template <class Container>
auto cbegin(const Container& cont)
   -> decltype(cont.begin());

Parámetros

cont
Un contenedor o initializer_list.

Valor devuelto

Constante cont.begin().

Comentarios

Esta función funciona con todos los contenedores de la biblioteca estándar de C++ y con initializer_list.

Puede utilizar esta función miembro en lugar de la función de plantilla begin() para garantizar que el valor devuelto sea const_iterator. Por lo general, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo, se considera que Container es un contenedor modificable (no const) o initializer_list de cualquier naturaleza que admite begin() y cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

cend

Recupera un iterador const (de solo lectura) en el elemento que sigue al último elemento del contenedor especificado.

template <class Container>
auto cend(const Container& cont)
   -> decltype(cont.end());

Parámetros

cont
Un contenedor o initializer_list.

Valor devuelto

Constante cont.end().

Comentarios

Esta función funciona con todos los contenedores de la biblioteca estándar de C++ y con initializer_list.

Puede utilizar esta función miembro en lugar de la función de plantilla end() para garantizar que el valor devuelto sea const_iterator. Por lo general, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo, se considera que Container es un contenedor modificable (no const) o initializer_list de cualquier naturaleza que admite end() y cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

crbegin

Obtenga un iterador de solo lectura inverso a los elementos del contenedor, comenzando al final del contenedor.

template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));

Parámetros

C
Tipo del contenedor.

c
Una instancia de contenedor.

Valor devuelto

Este iterador devuelve los elementos del contenedor en orden inverso, comenzando al final del contenedor.

Ejemplo: crbegin

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> v{10, 20, 30};
    for (auto i = std::crbegin(v); i != std::crend(v); ++i)
    {
        std::cout << *i << ' '; // outputs 30 20 10
    }
    // v[1] = 100; // error because the iterator is const
}

30 20 10

crend

Obtenga el sentinel al final de una secuencia invertida de solo lectura de elementos.

template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));

Parámetros

C
Tipo del contenedor.

c
Una instancia de contenedor.

Valor devuelto

El sentinel sigue el último elemento de una vista invertida del contenedor.

Ejemplo de crend

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> v{10, 20, 30};
    auto vi = std::crend(v);
    --vi; // get off the sentinel and onto the last element in the reversed range
    std::cout << *vi; // outputs 10
    // vi[0] = 300; // error because the iterator is const
}

10

data

Obtenga un puntero al primer elemento del contenedor.

1) template <class C> constexpr auto data(C& c) -> decltype(c.data());
2) template <class C> constexpr auto data(const C& c) -> decltype(c.data());
3) template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;
4) template <class E> constexpr const E* data(initializer_list<E> il) noexcept;

Parámetros

C
Tipo del contenedor.

c
Instancia de un contenedor.

E
Tipo de elemento de la lista de inicializadores.

il
Una lista de inicializadores.

N
Número de elementos de la matriz.

T
Tipo de los datos de la matriz.

Valor devuelto

1, 2) Puntero, basado en el tipo del contenedor, al primer elemento. Por ejemplo, si el contenedor es un vector de enteros, el tipo del valor devuelto es .int *

3) Puntero al primer elemento como una matriz.

4) Puntero al primer elemento de la lista de inicializadores.

Por ejemplo, data

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> v{ 10, 20, 30 };
    std::string src{ "a string" };

    const char *charPtr = std::data(src);
    int* intPtr = std::data(v);
    std::cout << charPtr << ", " << *intPtr << '\n'; // a string, 10
}

a string, 10

distance

Determina el número de incrementos entre las posiciones direccionadas por dos iteradores.

template <class InputIterator>
typename iterator_traits<InputIterator>::difference_type distance(InputIterator first, InputIterator last);

Parámetros

first
Primer iterador cuya distancia del segundo debe determinarse.

last
Segundo iterador cuya distancia del primero debe determinarse.

Valor devuelto

Número de veces que first se debe incrementar hasta que es igual lasta .

Comentarios

La función distance tiene complejidad constante cuando InputIterator cumple los requisitos de un iterador de acceso aleatorio. En caso contrario, tiene complejidad lineal y, por tanto, es potencialmente costosa.

Ejemplo

// iterator_distance.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>

int main()
{
    using namespace std;

    list<int> L;
    for (int i = -1; i < 9; ++i)
    {
        L.push_back(2 * i);
    }
    list <int>::iterator L_Iter, LPOS = L.begin();

    cout << "The list L is: ( ";
    for (L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
    {
        cout << *L_Iter << " ";
    }
    cout << ")." << endl;

    cout << "The iterator LPOS initially points to the first element: "
         << *LPOS << "." << endl;

    advance(LPOS, 7);
    cout << "LPOS is advanced 7 steps forward to point "
        << " to the eighth element: "
        << *LPOS << "." << endl;

    list<int>::difference_type Ldiff;
    Ldiff = distance(L.begin(), LPOS);
    cout << "The distance from L.begin( ) to LPOS is: "
        << Ldiff << "." << endl;
}

The list L is: ( -2 0 2 4 6 8 10 12 14 16 ).
The iterator LPOS initially points to the first element: -2.
LPOS is advanced 7 steps forward to point  to the eighth element: 12.
The distance from L.begin( ) to LPOS is: 7.

empty

template <class C> constexpr auto empty(const C& c) -> decltype(c.empty());
template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;
template <class E> constexpr bool empty(initializer_list<E> il) noexcept;

Parámetros

C
Tipo del contenedor.

c
Instancia de un contenedor.

E
Tipo de elemento de la lista de inicializadores.

il
Una lista de inicializadores.

N
Número de elementos de la matriz.

T
Tipo de los datos de la matriz.

Valor devuelto

Devuelve true si el contenedor no tiene elementos; en caso contrario false, .

Ejemplo

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> v{ 10,20,30 };
    std::vector<int> v2;

    std::cout << std::boolalpha << std::empty(v); // outputs false
    std::cout << std::boolalpha << ", " << std::empty(v2); // outputs true
}

false, true

end

Recupera un iterador en el elemento que sigue al último elemento del contenedor especificado.

template <class Container>
auto end(Container& cont)
   -> decltype(cont.end());

template <class Container>
auto end(const Container& cont)
   -> decltype(cont.end());

template <class Ty, class Size>
Ty *end(Ty (& array)[Size]);

Parámetros

cont
Un contenedor .

array
Matriz de objetos de tipo Ty.

Valor devuelto

Las dos primeras funciones devuelven cont.end() (la primeras es no-constante y la segunda es constante).

La tercera función de plantilla devuelve array + Size.

Comentarios

Para obtener un ejemplo de código, vea begin.

front_inserter

Crea un iterador que puede insertar elementos en la parte delantera de un contenedor especificado.

template <class Container>
front_insert_iterator<Container> front_inserter(Container& Cont);

Parámetros

Cont
Objeto contenedor en cuya parte frontal se va a insertar un elemento.

Valor devuelto

front_insert_iterator asociado con el objeto contenedor Cont.

Comentarios

También se puede usar la función miembro front_insert_iterator de la clase front_insert_iterator.

Dentro de la biblioteca estándar de C++, el argumento debe hacer referencia a uno de los dos contenedores de secuencia que tienen la función miembro push_back: clase deque, o "clase list".

Ejemplo

// iterator_front_inserter.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>

int main()
{
    using namespace std;

    list<int> L;
    for (int i = -1; i < 9; ++i)
    {
        L.push_back(i);
    }

    cout << "The list L is:\n ( ";
    for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
    {
        cout << *L_Iter << " ";
    }
    cout << ")." << endl;

    // Using the template function to insert an element
    front_insert_iterator<list <int>> Iter(L);
    *Iter = 100;

    // Alternatively, you may use the front_insert member function
    front_inserter(L) = 200;

    cout << "After the front insertions, the list L is:\n ( ";
    for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
    {
        cout << *L_Iter << " ";
    }
    cout << ")." << endl;
}

The list L is:
( -1 0 1 2 3 4 5 6 7 8 ).
After the front insertions, the list L is:
( 200 100 -1 0 1 2 3 4 5 6 7 8 ).

inserter

Función de plantilla auxiliar que permite usar inserter(Cont, Where) en lugar de insert_iterator<Container>(Cont, Where).

template <class Container>
insert_iterator<Container>
inserter(
    Container& Cont,
    typename Container::iterator Where);

Parámetros

Cont
Contenedor en el que se van a agregar nuevos elementos.

Where
Iterador que localiza el punto de inserción.

Comentarios

La función de plantilla devuelve insert_iterator<Container>(Cont, Where).

Ejemplo

// iterator_inserter.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>

int main()
{
    using namespace std;

    list<int> L;
    for (int i = 2; i < 5; ++i)
    {
        L.push_back(10 * i);
    }

    cout << "The list L is:\n ( ";
    for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
    {
        cout << *L_Iter << " ";
    }
    cout << ")." << endl;

    // Using the template version to insert an element
    insert_iterator<list<int>> Iter(L, L.begin());
    *Iter = 1;

    // Alternatively, using the member function to insert an element
    inserter(L, L.end()) = 500;

    cout << "After the insertions, the list L is:\n ( ";
    for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
    {
        cout << *L_Iter << " ";
    }
    cout << ")." << endl;
}

The list L is:
( 20 30 40 ).
After the insertions, the list L is:
( 1 20 30 40 500 ).

make_checked_array_iterator

Crea un checked_array_iterator que pueden usar otros algoritmos.

Nota:

Esta función es una extensión de Microsoft de la biblioteca estándar de C++. El código implementado mediante esta función no es portable a los entornos de compilación estándar de C++ que no admiten esta extensión de Microsoft.

template <class Iter>
checked_array_iterator<Iter>
    make_checked_array_iterator(
Iter Ptr,
    size_t Size,
    size_t Index = 0);

Parámetros

Ptr
Puntero a la matriz de destino.

Size
Tamaño de la matriz de destino.

Index
Índice opcional en la matriz.

Valor devuelto

Instancia de checked_array_iterator.

Comentarios

La función make_checked_array_iterator se define en el espacio de nombres stdext.

Esta función toma un puntero sin formato (que normalmente causaría preocupación sobre la saturación de los límites) y lo encapsula en una clase checked_array_iterator que hace la comprobación. Debido a que esa clase se marca como activada, la biblioteca estándar de C++ no advierte sobre ella. Para obtener más información y ejemplos de código, vea Iteradores comprobados.

Ejemplo

En el ejemplo siguiente, se crea un vector y se rellena con 10 elementos. El contenido del vector se copia en una matriz utilizando el algoritmo de copia y, a continuación, se usa make_checked_array_iterator para especificar el destino. Esto va seguido de una infracción intencionada de la comprobación de límites de forma que se desencadena un error de aserción de depuración.

// make_checked_array_iterator.cpp
// compile with: /EHsc /W4 /MTd

#include <algorithm>
#include <iterator> // stdext::make_checked_array_iterator
#include <memory> // std::make_unique
#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c)
{
    cout << s;

    for (const auto& e : c) 
    {
        cout << e << " ";
    }

    cout << endl;
}

int main()
{
    const size_t dest_size = 10;
    // Old-school but not exception safe, favor make_unique<int[]>
    // int* dest = new int[dest_size];
    unique_ptr<int[]> updest = make_unique<int[]>(dest_size);
    int* dest = updest.get(); // get a raw pointer for the demo

    vector<int> v;

    for (int i = 0; i < dest_size; ++i) 
    {
        v.push_back(i);
    }
    print("vector v: ", v);

    copy(v.begin(), v.end(), stdext::make_checked_array_iterator(dest, dest_size));

    cout << "int array dest: ";
    for (int i = 0; i < dest_size; ++i)
    {
        cout << dest[i] << " ";
    }
    cout << endl;

    // Add another element to the vector to force an overrun.
    v.push_back(10);

    // ! The next line causes a debug assertion when it executes.
    copy(v.begin(), v.end(), stdext::make_checked_array_iterator(dest, dest_size));
}

make_move_iterator

Crea un move iterator que contiene el iterador proporcionado como el iterador stored.

template <class Iterator>
move_iterator<Iterator>
make_move_iterator(const Iterator& It);

Parámetros

It
Iterador almacenado en el nuevo iterador de movimiento.

Comentarios

La función de plantilla devuelve move_iterator<Iterator>(_It).

make_unchecked_array_iterator

Crea un unchecked_array_iterator que pueden usar otros algoritmos.

Nota:

Esta función es una extensión de Microsoft de la biblioteca estándar de C++. El código implementado mediante esta función no es portable a los entornos de compilación estándar de C++ que no admiten esta extensión de Microsoft.

template <class Iter>
unchecked_array_iterator<Iter>
    make_unchecked_array_iterator(Iter Ptr);

Parámetros

Ptr
Puntero a la matriz de destino.

Valor devuelto

Instancia de unchecked_array_iterator.

Comentarios

La función make_unchecked_array_iterator se define en el espacio de nombres stdext.

Esta función toma un puntero sin formato y lo encapsula en una clase que no realiza ninguna comprobación y por tanto no optimiza nada, pero también silencia las advertencias del compilador como C4996. Por tanto, es una manera dirigida de tratar las advertencias de puntero no comprobadas sin silenciarlas de forma global o incurrir en el costo de comprobación. Para obtener más información y ejemplos de código, vea Iteradores comprobados.

Ejemplo

En el ejemplo siguiente, se crea un vector y se rellena con 10 elementos. El contenido del vector se copia en una matriz utilizando el algoritmo de copia y, a continuación, se usa make_unchecked_array_iterator para especificar el destino.

// make_unchecked_array_iterator.cpp
// compile with: /EHsc /W4 /MTd

#include <algorithm>
#include <iterator> // stdext::make_unchecked_array_iterator
#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c)
{
    cout << s;

    for (const auto& e : c) 
    {
        cout << e << " ";
    }

    cout << endl;
}

int main()
{
    const size_t dest_size = 10;
    int* dest = new int[dest_size];
    vector<int> v;

    for (int i = 0; i < dest_size; ++i) 
    {
        v.push_back(i);
    }
    print("vector v: ", v);

    // COMPILER WARNING SILENCED: stdext::unchecked_array_iterator is marked as checked in debug mode
    // (it performs no checking, so an overrun will trigger undefined behavior)
    copy(v.begin(), v.end(), stdext::make_unchecked_array_iterator(dest));

    cout << "int array dest: ";
    for (int i = 0; i < dest_size; ++i)
    {
        cout << dest[i] << " ";
    }
    cout << endl;

    delete[] dest;
}

vector v: 0 1 2 3 4 5 6 7 8 9
int array dest: 0 1 2 3 4 5 6 7 8 9

next

Procesa una iteración un número especificado de veces y devuelve la nueva posición del iterador.

template <class InputIterator>
InputIterator next(
    InputIterator first,
    typename iterator_traits<InputIterator>::difference_type off = 1);

Parámetros

first
Posición actual.

off
Número de veces que se va a iterar.

Valor devuelto

Devuelve la posición del nuevo iterador después de iterar off veces.

Comentarios

La función de plantilla devuelve next incrementado off veces

prev

Procesa una iteración en dirección inversa un número especificado de veces y devuelve la nueva posición del iterador.

template <class BidirectionalIterator>
BidirectionalIterator prev(
    BidirectionalIterator first,
    typename iterator_traits<BidirectionalIterator>::difference_type off = 1);

Parámetros

first
Posición actual.

off
Número de veces que se va a iterar.

Comentarios

La función de plantilla devuelve next reducido off veces.

rbegin

Obtiene un iterador, que devuelve los elementos del contenedor en orden inverso.

template <class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());
template <class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());

Parámetros

C
Tipo del contenedor.

c
Una instancia de contenedor.

Valor devuelto

El iterador devuelto presenta los elementos del contenedor en orden inverso, comenzando al final del intervalo invertido.

Por ejemplo, rbegin

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> v{ 10, 20, 30 };

	for (auto e = std::rbegin(v); e != std::rend(v); ++e)
	{
		std::cout << *e << ' '; // outputs 30 20 10
	}
}

30 20 10

rend

Obtenga el centinela al final de una secuencia invertida de elementos.

template <class C> constexpr auto rend(C& c)-> decltype(c.rend());
template <class C> constexpr auto rend(const C& c) -> decltype(c.rend());

Parámetros

C
Tipo del contenedor.

c
Una instancia de contenedor.

Valor devuelto

Iterador inverso al sentinel al final del contenedor. El sentinel sigue el último elemento de la vista invertida del contenedor:

Ejemplo de rend

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> v{10, 20, 30};
    auto vi = std::rend(v);
    --vi; // get off the sentinel and onto the last element in the reversed range
    std::cout << *vi; // outputs 10
}

10

size

template <class C> constexpr auto size(const C& c)
    -> decltype(c.size());
template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept;

Parámetros

C
Tipo del contenedor.

c
Instancia de un contenedor.

N
Número de elementos de la matriz.

T
Tipo de los datos de la matriz.

Valor devuelto

Número de elementos del contenedor como un valor entero sin signo.

Por ejemplo, size

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> v{ 10, 20, 30 };
    size_t s = std::size(v);
    std::cout << s; // outputs 3
}

3