Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::vector::back — accedere all’ultimo elemento

Usa `back()` per leggere o modificare l’ultimo elemento di un vettore non vuoto. Impara quando il risultato diventa invalido e perché l’estrazione da un heap richiede due passaggi.

Versione: ISO C++23; implementation support may vary

Sintassi

#include <vector>

// Member declarations of std::vector<T, Allocator> in C++23
constexpr reference back();
constexpr const_reference back() const;

std::vector::back è una funzione membro senza argomenti dichiarata in <vector>. Accede all’ultimo elemento in tempo costante senza rimuoverlo né modificare size(). Per un normale std::vector<T>, gli overload constexpr restituiscono T& oppure, se il vettore è const, const T&. Quindi v.back() = 3 modifica l’elemento di uno std::vector<int>. Nella specializzazione std::vector<bool>, l’overload non const restituisce un oggetto proxy per valore e quello const restituisce un bool per valore. In questa specializzazione, bool saved = v.back(); salva il valore, non un proxy.

In C++23, chiamare back() su un vettore vuoto causa un comportamento indefinito: non è garantita alcuna eccezione o diagnostica. Se il vettore potrebbe essere vuoto, controlla prima !v.empty(). reserve() può aumentare la capacità, ma non aggiunge elementi né modifica size(). In un vettore non vuoto, back() accede allo stesso elemento di *std::prev(v.end()); v.end() indica la posizione oltre l’ultimo elemento e non va dereferenziato.

Un riferimento conservato non segue l’ultima posizione. Se push_back() non causa una riallocazione, il riferimento indica ancora l’elemento originale, che non è più l’ultimo. La riallocazione invalida i riferimenti agli elementi; anche rimuovere l’elemento referenziato o distruggere il vettore rende inutilizzabile il riferimento. Se il valore serve anche dopo la rimozione, copialo prima, per esempio con int saved = v.back(); per un vettore di int.

L’ultimo elemento non è necessariamente il minimo o il massimo. std::minmax_element(v.begin(), v.end()) restituisce una coppia di iteratori: first e second indicano rispettivamente il minimo e il massimo. Se l’intervallo è vuoto, entrambi valgono v.end() e non vanno dereferenziati.

Su un heap valido e non vuoto, std::pop_heap(v.begin(), v.end()) sposta la vecchia radice in ultima posizione e lascia il prefisso rimanente sotto forma di heap, senza modificare la dimensione del vettore. Leggi il valore spostato con back(), poi rimuovi l’elemento con pop_back(), che non restituisce nulla.

Esempi

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> v;
    v.reserve(2);
    if (v.empty()) {
        std::cout << "empty\n";
    }

    v.push_back(7);
    v.push_back(2);
    v.back() = 3;
    const std::vector<int>& read_only = v;
    std::cout << read_only.back() << '\n';

    std::make_heap(v.begin(), v.end());
    if (!v.empty()) {
        std::pop_heap(v.begin(), v.end());
        const int removed = v.back();
        v.pop_back();
        std::cout << removed << '\n';
    }
    if (!v.empty()) {
        std::cout << v.back() << '\n';
    }
}

Risultato

empty
3
7
3

Dopo `reserve(2)`, il vettore è ancora vuoto. L’assegnazione tramite `back()` cambia `2` in `3` e la lettura tramite il riferimento `const` stampa `3`. Dopo `pop_heap()`, il codice copia `7` prima di rimuovere l’elemento; nel vettore rimane `3`.

Lezioni correlate

  • C++ · Lezione 30 · Avanzato · Versione: 3
  • C++ · Lezione 34 · Avanzato · Versione: 3

Fonti