`<iterator>` funções

`advance`

Incrementa um iterador por um número especificado de posições.

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

Parameters

InIt
O iterador que deve ser incrementado e que deve satisfazer os requisitos para um iterador de entrada.

Off
Um tipo integral que seja convertível para o tipo de diferença do iterador e que especifique o número de incrementos em que a posição do iterador deve ser avançado.

Remarks

O intervalo deve ser não singular, onde os iteradores devem ser desreferenciables ou ultrapassar o fim.

Se o InputIterator satisfer os requisitos para um tipo de iterador bidirecional, então Off pode ser negativo. Se InputIterator for um tipo de iterador de entrada ou forward, Off deve ser não negativo.

A função de avanço tem complexidade constante quando InputIterator satisfaz os requisitos para um iterador de acesso aleatório; caso contrário, tem complexidade linear e, por isso, pode ser dispendiosa.

Exemplo

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

Cria um iterador que pode inserir elementos na parte de trás de um contentor especificado.

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

Parameters

Cont
O contentor onde a inserção de volta deve ser executada.

Valor de retorno

A back_insert_iterator associado ao objeto Contcontentor .

Remarks

Dentro da Biblioteca Padrão C++, o argumento deve referir-se a um dos três recipientes de sequência que têm a função push_backmembro: deque Classe, list Classe ou vector Classe.

Exemplo

// 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 um iterador para o primeiro elemento de um contentor 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]);

Parameters

cont
Um contentor.

array
Um array de objetos do tipo Ty.

Valor de retorno

As duas primeiras funções-modelo retornam cont.begin(). A primeira função é não constante; a segunda é constante.

A terceira função modelo devolve array.

Exemplo

Recomendamos que utilize esta função modelo em vez do membro begin() do contentor quando for necessário um comportamento mais 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

A função reverse_sort suporta contentores de qualquer tipo, além de arrays regulares, porque chama a versão não membro de begin(). Codificação reverse_sort para usar o membro begin()do contentor :

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

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

}

Depois, enviar um array para ela causa este erro do compilador:

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

`cbegin`

Recupera um iterador const (somente leitura) para o primeiro elemento de um contentor especificado.

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

Parameters

cont
Um recipiente ou initializer_list.

Valor de retorno

Uma constante cont.begin().

Remarks

Esta função funciona com todos os contentores da Biblioteca Padrão C++ e com initializer_list.

Pode usar esta função membro em vez da begin() função modelo para garantir que o valor de retorno é const_iterator. Normalmente, é usado com a auto palavra-chave dedução de tipo, como mostrado no exemplo seguinte. No exemplo, considere-se Container como um contentor modificável (não- const) ou initializer_list de qualquer tipo que suporte begin() e cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Recupera um iterador const (apenas leitura) para o elemento que segue o último elemento no contentor especificado.

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

Parameters

cont
Um recipiente ou initializer_list.

Valor de retorno

Uma constante cont.end().

Remarks

Esta função funciona com todos os contentores da Biblioteca Padrão C++ e com initializer_list.

Pode usar esta função membro em vez da end() função modelo para garantir que o valor de retorno é const_iterator. Normalmente, é usado com a auto palavra-chave dedução de tipo, como mostrado no exemplo seguinte. No exemplo, considere-se Container como um contentor modificável (não- const) ou initializer_list de qualquer tipo que suporte end() e cend().

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

// i2 is Container<T>::const_iterator

`crbegin`

Obtenha um iterador de leitura somente invertida para os elementos do contentor, começando pelo final do contentor.

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

Parameters

C
O tipo do recipiente.

c
Uma instância de contêiner.

Valor de retorno

Este iterador devolve os elementos do contentor em ordem inversa, começando pelo final do contentor.

Imagem de um vetor contendo os elementos 10, 20 e 30. Há uma caixa imaginária antes do elemento mais à esquerda (o elemento mais à esquerda contém o número 10) que representa o sentinela. Está rotulado crend(). O primeiro elemento do vetor contém o número 10, e é rotulado como 'último elemento'. O elemento mais à direita do vetor contém 30 e é rotulado crbegin().

Exemplo: `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`

Coloca o sentinela no final de uma sequência invertida de elementos em modo apenas leitura.

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

Parameters

C
O tipo do recipiente.

c
Uma instância de contêiner.

Valor de retorno

O sentinela segue o último elemento numa vista invertida do recipiente.

`crend` exemplo

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

`data`

Arranja um apontador para o primeiro elemento do recipiente.

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;

Parameters

C
O tipo do recipiente.

c
Um exemplo de contentor.

E
O tipo de elemento da lista de inicializadores.

il
Uma lista de inicializadores.

N
O número de elementos na matriz.

T
O tipo de dados no array.

Valor de retorno

1, 2) Um ponteiro, baseado no tipo do recipiente, para o primeiro elemento. Por exemplo, se o contentor for um vetor de inteiros, o tipo do valor de retorno é um int *.

3) Um apontador para o primeiro elemento como um array.

4) Um apontador para o primeiro elemento da lista de inicializadores.

Exemplo `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 o número de incrementos entre as posições abordadas por dois iteradores.

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

Parameters

first
O primeiro iterador cuja distância do segundo deve ser determinada.

last
O segundo iterador cuja distância do primeiro deve ser determinada.

Valor de retorno

O número de vezes que isso first deve ser incrementado até ser lastigual a .

Remarks

A função de distância tem complexidade constante quando InputIterator satisfaz os requisitos para um iterador de acesso aleatório; caso contrário, tem complexidade linear e, por isso, é potencialmente dispendiosa.

Exemplo

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

Parameters

C
O tipo do recipiente.

c
Um exemplo de contentor.

E
O tipo de elemento da lista de inicializadores.

il
Uma lista de inicializadores.

N
O número de elementos na matriz.

T
O tipo de dados no array.

Valor de retorno

Retorna true se o contentor não tiver elementos; caso contrário false.

Exemplo

#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 um iterador para o elemento que segue o último elemento no contentor 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]);

Parameters

cont
Um contentor.

array
Um array de objetos do tipo Ty.

Valor de retorno

As duas primeiras funções template retornam cont.end() (a primeira é não constante e a segunda é constante).

A terceira função modelo devolve array + Size.

Remarks

Para obter um exemplo de código, consulte begin.

`front_inserter`

Cria um iterador que pode inserir elementos na frente de um contentor especificado.

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

Parameters

Cont
O objeto contentor cuja frente está a ter um elemento inserido.

Valor de retorno

A front_insert_iterator associado ao objeto Contcontentor .

Remarks

A função front_insert_iterator membro da classe front_insert_iterator também pode ser utilizada.

Dentro da Biblioteca Padrão C++, o argumento deve referir-se a um dos dois contentores de sequência que têm a função push_backmembro: deque Class ou "list Class".

Exemplo

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

Uma função de modelo auxiliar que permite usar inserter(Cont, Where) em vez de insert_iterator<Container>(Cont, Where).

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

Parameters

Cont
O contentor ao qual novos elementos serão adicionados.

Where
Um iterador a localizar o ponto de inserção.

Remarks

A função template devolve insert_iterator<Container>(Cont, Where).

Exemplo

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

Cria um checked_array_iterator que pode ser usado por outros algoritmos.

Note

checked_array_iterator foi removido no MSVC Build Tools 14.51. Esta função é uma extensão da Microsoft da C++ Standard Library. O código implementado através desta função não é portátil para ambientes de compilação padrão C++ que não suportam esta extensão da Microsoft.

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

Parameters

Ptr
Um apontador para o array de destino.

Size
O tamanho do array de destino.

Index
Índice opcional para o array.

Valor de retorno

Um exemplo de checked_array_iterator.

Remarks

A make_checked_array_iterator função está definida no stdext namespace.

Esta função pega num ponteiro bruto — que normalmente causaria preocupação com o excesso de limites — e envolve-o numa classe checked_array_iterator que faz verificação. Como essa classe está marcada como assinalada, a Biblioteca Padrão C++ não avisa sobre isso. Para mais informações e exemplos de código, veja Iteradores Verificados.

Exemplo

No exemplo seguinte, um vetor é criado e preenchido com 10 itens. O conteúdo do vetor é copiado para um array usando o algoritmo de cópia, e depois make_checked_array_iterator é usado para especificar o destino. Isto é seguido por uma violação intencional da verificação dos limites, de modo a que uma falha na asserção de depuração seja desencadeada.

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

Cria um move iterator que contém o iterador fornecido como stored iterador.

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

Parameters

It
O iterador está armazenado no novo iterador de movimentos.

Remarks

A função template devolve move_iterator<Iterator>(_It).

`make_unchecked_array_iterator`

Cria um unchecked_array_iterator que pode ser usado por outros algoritmos.

Note

A unchecked_array_iterator classe foi removida no MSVC Build Tools 14.51. Esta função é uma extensão da Microsoft da C++ Standard Library. O código implementado através desta função não é portátil para ambientes de compilação padrão C++ que não suportam esta extensão da Microsoft.

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

Parameters

Ptr
Um apontador para o array de destino.

Valor de retorno

Um exemplo de unchecked_array_iterator.

Remarks

A make_unchecked_array_iterator função está definida no stdext namespace.

Esta função pega num ponteiro bruto e envolve-o numa classe que não realiza verificação e, por isso, otimiza até ao fim, mas também silencia avisos do compilador como o C4996. Portanto, esta é uma forma direcionada de lidar com avisos de ponteiros não verificados sem os silenciar globalmente ou incorrer no custo da verificação. Para mais informações e exemplos de código, veja Iteradores Verificados.

Exemplo

No exemplo seguinte, um vetor é criado e preenchido com 10 itens. O conteúdo do vetor é copiado para um array usando o algoritmo de cópia, e depois make_unchecked_array_iterator é usado para especificar o 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`

Itera um número especificado de vezes e devolve a nova posição do iterador.

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

Parameters

first
A posição atual.

off
O número de vezes a iterar.

Valor de retorno

Devolve a nova posição de iterador após tempos de iteração off .

Remarks

A função template devolve next tempos incrementados off

`prev`

Itera inversamente um número especificado de vezes e retorna a nova posição do iterador.

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

Parameters

first
A posição atual.

off
O número de vezes a iterar.

Remarks

A função template devolve next os tempos off decrementados.

`rbegin`

Arranja um iterador, que devolve os elementos do contentor por ordem inversa.

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

Parameters

C
O tipo do recipiente.

c
Uma instância de contêiner.

Valor de retorno

O iterador devolvido apresenta os elementos do contentor em ordem inversa, começando no final do intervalo invertido.

Imagem de um vetor contendo os elementos 10, 20 e 30. Há uma caixa imaginária antes do elemento mais à esquerda (o elemento mais à esquerda contém o número 10) que representa o sentinela. É rotulado rend(). O primeiro elemento do vetor contém o número 10 e é rotulado como 'último elemento'. O elemento mais à direita no vetor contém 30 e é rotulado rbegin().

Exemplo `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`

Coloca o sentinela no final de uma sequência 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());

Parameters

C
O tipo do recipiente.

c
Uma instância de contêiner.

Valor de retorno

Um iterador inverso ao sentinela no final do contentor. O sentinela segue o último elemento na vista invertida do contentor:

Imagem de um vetor contendo os elementos 10, 20 e 30. Há uma caixa imaginária antes do elemento mais à esquerda (o elemento mais à esquerda contém o número 10) que representa o sentinela. É rotulado rend(). O primeiro elemento do vetor contém o número 10 e é rotulado como 'último elemento'. O elemento mais à direita no vetor contém 30 e é rotulado rbegin().

`rend` exemplo

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

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

Parameters

C
O tipo do recipiente.

c
Um exemplo de contentor.

N
O número de elementos na matriz.

T
O tipo de dados no array.

Valor de retorno

O número de elementos no contentor como um valor inteiro sem signo.

Exemplo `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
}

Comentários

Esta página foi útil?

Última atualização a 2026-10-05

<iterator> funções

advance

Parameters

Remarks

Exemplo

back_inserter

Parameters

Valor de retorno

Remarks

Exemplo

begin

Parameters

Valor de retorno

Exemplo

cbegin

Parameters

Valor de retorno

Remarks

cend

Parameters

Valor de retorno

Remarks

crbegin

Parameters

Valor de retorno

Exemplo: crbegin

crend

Parameters

Valor de retorno

crend exemplo

data

Parameters

Valor de retorno

Exemplo data

distance

Parameters

Valor de retorno

Remarks

Exemplo

empty

Parameters

Valor de retorno

Exemplo

end

Parameters

Valor de retorno

Remarks

front_inserter

Parameters

Valor de retorno

Remarks

Exemplo

inserter

Parameters

Remarks

Exemplo

make_checked_array_iterator

Parameters

Valor de retorno

Remarks

Exemplo

make_move_iterator

Parameters

Remarks

make_unchecked_array_iterator

Parameters

Valor de retorno

Remarks

Exemplo

next

Parameters

Valor de retorno

Remarks

prev

Parameters

Remarks

rbegin

Parameters

Valor de retorno

Exemplo rbegin

`<iterator>` funções

`advance`

`back_inserter`

`begin`

`cbegin`

`cend`

`crbegin`

Exemplo: `crbegin`

`crend`

`crend` exemplo

`data`

Exemplo `data`

`distance`

`empty`

`end`

`front_inserter`

`inserter`

`make_checked_array_iterator`

`make_move_iterator`

`make_unchecked_array_iterator`

`next`

`prev`

`rbegin`

Exemplo `rbegin`

`rend`

`rend` exemplo

`size`

Exemplo `size`