<iterator> funzioni

advance

Incrementa un iteratore di un numero specificato di posizioni.

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

Parametri

InIt
Iteratore che deve essere incrementato e che deve soddisfare i requisiti per un iteratore di input.

Off
Tipo integrale convertibile nel tipo di differenza dell'iteratore e che specifica il numero di incrementi in cui è necessario far avanzare la posizione dell'iteratore.

Osservazioni:

L'intervallo deve essere non in formato nonulare, in cui gli iteratori devono essere dereferenziabili o oltre la fine.

Se soddisfa InputIterator i requisiti per un tipo iteratore bidirezionale, Off può essere negativo. Se InputIterator è un tipo di iteratore di input o di inoltro, Off deve essere non negativo.

La funzione di avanzamento presenta una complessità costante quando InputIterator soddisfa i requisiti per un iteratore ad accesso casuale; in caso contrario, presenta una complessità lineare ed è quindi potenzialmente costoso.

Esempio

// 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 iteratore in grado di inserire gli elementi nella parte finale di un contenitore specificato.

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

Parametri

Cont
Contenitore in cui deve essere eseguito l'inserimento inverso.

Valore restituito

Oggetto back_insert_iterator associato all'oggetto contenitore Cont.

Osservazioni:

All'interno della libreria standard C++, l'argomento deve fare riferimento a uno dei tre contenitori di sequenze con la funzione push_backmembro : deque Classe, list Classe o vector Classe.

Esempio

// 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 iteratore al primo elemento di un contenitore specificato.

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]);

Parametri

cont
Contenitore.

array
Matrice di oggetti di tipo Ty.

Valore restituito

Le prime due funzioni di modello restituiscono cont.begin(). La prima funzione è non costante; la seconda è costante.

La terza funzione di modello restituisce array.

Esempio

È consigliabile utilizzare questa funzione di modello anziché il membro del contenitore begin() quando è richiesto un comportamento più generico.

// 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 funzione reverse_sort supporta contenitori di qualsiasi tipo, oltre alle matrici normali, perché chiama la versione non membro di begin(). Codifica reverse_sort per usare il membro begin()del contenitore :

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

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

}

Quindi l'invio di una matrice a tale matrice causa l'errore del compilatore:

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

cbegin

Recupera un iteratore const (di sola lettura) al primo elemento di un contenitore specificato.

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

Parametri

cont
Contenitore o initializer_list.

Valore restituito

Costante cont.begin().

Osservazioni:

Questa funzione funziona con tutti i contenitori della libreria standard C++ e con initializer_list.

È possibile utilizzare questa funzione membro anziché il modello begin() per garantire che il valore restituito sia const_iterator. In genere, viene usato con la parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile o initializer_list di qualsiasi tipo che supporta begin() e cbegin().

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

// i2 is Container<T>::const_iterator

cend

Recupera un iteratore const (di sola lettura) all'elemento che segue l'ultimo elemento nel contenitore specificato.

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

Parametri

cont
Contenitore o initializer_list.

Valore restituito

Costante cont.end().

Osservazioni:

Questa funzione funziona con tutti i contenitori della libreria standard C++ e con initializer_list.

È possibile utilizzare questa funzione membro anziché il modello end() per garantire che il valore restituito sia const_iterator. In genere, viene usato con la parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile o initializer_list di qualsiasi tipo che supporta end() e cend().

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

// i2 is Container<T>::const_iterator

crbegin

Ottenere un iteratore di sola lettura inverso agli elementi del contenitore, a partire dalla fine del contenitore.

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

Parametri

C
Tipo del contenitore.

c
Istanza del contenitore.

Valore restituito

Questo iteratore restituisce gli elementi del contenitore in ordine inverso, a partire dalla fine del contenitore.

Esempio: 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

Ottenere la sentinella alla fine di una sequenza di elementi invertita di sola lettura.

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

Parametri

C
Tipo del contenitore.

c
Istanza del contenitore.

Valore restituito

Sentinel segue l'ultimo elemento in una visualizzazione inversa del contenitore.

crendEsempio

#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

Ottenere un puntatore al primo elemento nel contenitore.

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;

Parametri

C
Tipo del contenitore.

c
Istanza di un contenitore.

E
Tipo di elemento dell'elenco di inizializzatori.

il
Elenco di inizializzatori.

N
Numero di elementi nella matrice.

T
Tipo di dati nella matrice.

Valore restituito

1, 2) Puntatore, in base al tipo del contenitore, al primo elemento. Ad esempio, se il contenitore è un vettore di numeri interi, il tipo del valore restituito è .int *

3) Puntatore al primo elemento come matrice.

4) Puntatore al primo elemento dell'elenco di inizializzatori.

Esempiodata

#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 il numero di incrementi tra le posizioni a cui puntano due iteratori.

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

Parametri

first
Primo iteratore di cui deve essere determinata la distanza dal secondo.

last
Secondo iteratore di cui deve essere determinata la distanza dal primo.

Valore restituito

Numero di volte in cui first è necessario incrementare fino a quando non è lastuguale a .

Osservazioni:

La funzione distance presenta una complessità costante quando InputIterator soddisfa i requisiti per un iteratore ad accesso casuale; in caso contrario, presenta una complessità lineare ed è potenzialmente costoso.

Esempio

// 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;

Parametri

C
Tipo del contenitore.

c
Istanza di un contenitore.

E
Tipo di elemento dell'elenco di inizializzatori.

il
Elenco di inizializzatori.

N
Numero di elementi nella matrice.

T
Tipo di dati nella matrice.

Valore restituito

Restituisce true se il contenitore non dispone di elementi; in caso contrario false, .

Esempio

#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 iteratore all'elemento successivo all'ultimo elemento nel contenitore specificato.

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]);

Parametri

cont
Contenitore.

array
Matrice di oggetti di tipo Ty.

Valore restituito

Le prime due funzioni di modello restituiscono cont.end() (le prima è una funzione non costante, mentre la seconda è una funzione costante).

La terza funzione di modello restituisce array + Size.

Osservazioni:

Per un esempio di codice, vedere begin.

front_inserter

Crea un iteratore in grado di inserire elementi all'inizio di un contenitore specificato.

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

Parametri

Cont
Oggetto contenitore all'inizio del quale viene inserito un elemento.

Valore restituito

Oggetto front_insert_iterator associato all'oggetto contenitore Cont.

Osservazioni:

È possibile usare anche la funzione membro front_insert_iterator della classe front_insert_iterator.

All'interno della libreria standard C++, l'argomento deve fare riferimento a uno dei due contenitori sequenziali che hanno la funzione membro push_back: Classe deque o "Classe list".

Esempio

// 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

Funzione modello helper che consente di usare inserter(Cont, Where) invece di insert_iterator<Container>(Cont, Where).

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

Parametri

Cont
Contenitore a cui devono essere aggiunti nuovi elementi.

Where
Iteratore che individua il punto di inserimento.

Osservazioni:

La funzione modello restituisce insert_iterator<Container>(Cont, Where).

Esempio

// 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 oggetto checked_array_iterator che può essere usato da altri algoritmi.

Nota

Questa funzione è un'estensione Microsoft della libreria standard C++. Il codice implementato mediante questa funzione non può essere trasferito negli ambienti di compilazione standard di C++ che non supportano questa estensione Microsoft.

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

Parametri

Ptr
Puntatore alla matrice di destinazione.

Size
Dimensioni della matrice di destinazione.

Index
Indice facoltativo nella matrice.

Valore restituito

Istanza dell'oggetto checked_array_iterator.

Osservazioni:

La funzione make_checked_array_iterator viene definita nello spazio dei nomi stdext.

Questa funzione accetta un puntatore non elaborato, che causa in genere problemi relativi al superamento dei limiti, e ne esegue il wrapping in una classe checked_array_iterator che effettua la verifica. Poiché la classe è contrassegnata come verificata, la libreria standard C++ non fornisce alcun avviso. Per altre informazioni ed esempi di codice, vedere Iteratori verificati.

Esempio

Nell'esempio seguente viene creato un oggetto vector e tale oggetto viene popolato con 10 elementi. Il contenuto del vettore viene copiato in una matrice utilizzando l'algoritmo di copia, quindi viene utilizzato make_checked_array_iterator per specificare la destinazione. Questa attività è seguita da una violazione intenzionale del controllo dei limiti in modo da generare un errore di asserzione di debug.

// 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 oggetto move iterator contenente l'iteratore fornito come iteratore stored.

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

Parametri

It
Iteratore archiviato nel nuovo iteratore di spostamento.

Osservazioni:

La funzione modello restituisce move_iterator<Iterator>(_It).

make_unchecked_array_iterator

Crea un oggetto unchecked_array_iterator che può essere usato da altri algoritmi.

Nota

Questa funzione è un'estensione Microsoft della libreria standard C++. Il codice implementato mediante questa funzione non può essere trasferito negli ambienti di compilazione standard di C++ che non supportano questa estensione Microsoft.

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

Parametri

Ptr
Puntatore alla matrice di destinazione.

Valore restituito

Istanza dell'oggetto unchecked_array_iterator.

Osservazioni:

La funzione make_unchecked_array_iterator viene definita nello spazio dei nomi stdext.

Questa funzione accetta un puntatore non elaborato e ne esegue il wrapping in una classe che non esegue alcuna verifica e pertanto non produce alcuna ottimizzazione, ma disattiva anche gli avvisi del compilatore, ad esempio C4996. Questa modalità consente pertanto di gestire gli avvisi relativi ai puntatori non verificati senza disattivarli globalmente o senza la necessità di un controllo. Per altre informazioni ed esempi di codice, vedere Iteratori verificati.

Esempio

Nell'esempio seguente viene creato un oggetto vector e tale oggetto viene popolato con 10 elementi. Il contenuto del vettore viene copiato in una matrice utilizzando l'algoritmo di copia, quindi viene utilizzato make_unchecked_array_iterator per specificare la destinazione.

// 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

Esegue l'iterazione per un numero specificato di volte e restituisce la nuova posizione dell'iteratore.

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

Parametri

first
Posizione corrente.

off
Numero di operazioni di iterazione.

Valore restituito

Restituisce la nuova posizione dell'iteratore dopo l'esecuzione di off iterazioni.

Osservazioni:

La funzione modello restituisce next incrementato off volte.

prev

Esegue l'iterazione in ordine inverso per un numero specificato di volte e restituisce la nuova posizione dell'iteratore.

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

Parametri

first
Posizione corrente.

off
Numero di operazioni di iterazione.

Osservazioni:

La funzione modello restituisce next decrementato off volte.

rbegin

Ottenere un iteratore, che restituisce gli elementi del contenitore in ordine inverso.

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

Parametri

C
Tipo del contenitore.

c
Istanza del contenitore.

Valore restituito

L'iteratore restituito presenta gli elementi del contenitore in ordine inverso, a partire dalla fine dell'intervallo invertito.

Esempiorbegin

#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

Ottenere la sentinella alla fine di una sequenza di elementi invertita.

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

Parametri

C
Tipo del contenitore.

c
Istanza del contenitore.

Valore restituito

Iteratore inverso alla sentinella alla fine del contenitore. Sentinel segue l'ultimo elemento nella visualizzazione inversa del contenitore:

rendEsempio

#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;

Parametri

C
Tipo del contenitore.

c
Istanza di un contenitore.

N
Numero di elementi nella matrice.

T
Tipo di dati nella matrice.

Valore restituito

Numero di elementi nel contenitore come valore intero senza segno.

Esempiosize

#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