Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::prev — mover um iterador para trás

std::prev, de <iterator>, devolve uma cópia deslocada de um iterador bidirecional sem alterar o argumento. Por predefinição, recua um passo; um n negativo significa avançar. Quem chama a função tem de garantir que o movimento permanece dentro dos limites válidos e que o cálculo de -n não causa um transbordo.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#include <iterator>

template<class BidirectionalIterator>
constexpr BidirectionalIterator prev(
    BidirectionalIterator x,
    typename std::iterator_traits<BidirectionalIterator>::difference_type n = 1);

std::prev(x)
std::prev(x, n)

std::prev(x, n) devolve um iterador do mesmo tipo que x, deslocado n passos para trás. O valor predefinido de n é 1; n == 0 mantém a posição e um n negativo desloca para a frente. A função de <iterator> trabalha sobre uma cópia: equivale a std::advance(x, -n); return x;, pelo que não altera o iterador fornecido.

Se o difference_type do iterador for um tipo inteiro com sinal de largura reduzida, o operador menos unário pode promover n a int. Nesse caso, std::advance pode receber o resultado do tipo int, mesmo que este não seja representável no difference_type original. Se, pelo contrário, n for o valor mínimo de um tipo inteiro com sinal que não é promovido (por exemplo, std::ptrdiff_t quando não é sujeito a promoção), calcular -n causa um transbordo de um inteiro com sinal e, consequentemente, comportamento indefinido, mesmo que o movimento pretendido se mantivesse dentro dos limites válidos.

O tipo tem de cumprir os requisitos dos iteradores bidirecionais, mesmo quando n é negativo. Os iteradores de acesso aleatório demoram tempo constante; os restantes iteradores bidirecionais demoram tempo linear em relação ao número de passos. O resultado é um iterador, não o valor de um elemento; lê o elemento com * se o resultado puder ser desreferenciado.

A função não verifica os limites. Não recues para antes do início nem saias do intervalo válido. std::prev(values.end()) aponta para o último elemento apenas num contentor não vazio com um iterador adequado; esse passo para trás é inválido num contentor vazio. Não é possível desreferenciar o próprio end().

Não confundas std::prev com std::ranges::prev: esta última também tem uma sobrecarga que recebe um limite bound, que std::prev não disponibiliza. O exemplo utiliza std::list<int> para demonstrar o movimento para trás, o movimento para a frente com n negativo e a preservação do iterador original.

Exemplos

#include <iostream>
#include <iterator>
#include <list>

int main() {
    const std::list<int> values{10, 20, 30, 40};
    const auto finish = values.end();
    const auto last = std::prev(finish);
    const auto earlier = std::prev(finish, 2);
    const auto forward = std::prev(earlier, -1);

    std::cout << *last << ' ' << *earlier << ' ' << *forward << '\n';
    std::cout << std::boolalpha << (finish == values.end()) << '\n';
}

Resultado

40 30 40
true

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes