WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::vector::back — Zugriff auf das letzte Element

Mit `back()` lässt sich das letzte Element eines nicht leeren Vektors lesen oder ändern. Entscheidend ist, wann das Ergebnis ungültig wird und warum das Entnehmen aus einem Heap zwei Schritte erfordert.

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

Syntax

#include <vector>

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

std::vector::back ist eine parameterlose Memberfunktion aus <vector>. Sie greift in konstanter Zeit auf das letzte Element zu, ohne es zu entfernen oder size() zu ändern. Bei einem gewöhnlichen std::vector<T> liefern die constexpr-Überladungen T& beziehungsweise bei einem const-Vektor const T&. Daher ändert v.back() = 3 das Element eines std::vector<int>. Bei der Spezialisierung std::vector<bool> gibt die Nicht-const-Überladung ein Proxy-Objekt als Wert zurück, die const-Überladung einen bool-Wert. Dort speichert bool saved = v.back(); den Wert und keinen Proxy.

In C++23 führt back() bei einem leeren Vektor zu undefiniertem Verhalten: Weder eine Ausnahme noch eine Diagnose ist garantiert. Wenn der Vektor leer sein könnte, prüfe zuerst !v.empty(). reserve() kann die Kapazität erhöhen, fügt aber keine Elemente hinzu und ändert size() nicht. Bei einem nicht leeren Vektor greift back() auf dasselbe Element zu wie *std::prev(v.end()); v.end() selbst bezeichnet die Position hinter dem letzten Element und darf nicht dereferenziert werden.

Eine gespeicherte Referenz folgt nicht der letzten Position. Wenn push_back() keine Reallokation auslöst, verweist die Referenz weiterhin auf das ursprüngliche Element, das nicht mehr das letzte ist. Eine Reallokation macht Elementreferenzen ungültig; auch nach dem Löschen des referenzierten Elements oder der Zerstörung des Vektors darf die Referenz nicht mehr verwendet werden. Soll der Wert das Löschen überdauern, kopiere ihn vorher, etwa mit int saved = v.back(); bei einem Vektor von int-Werten.

Das letzte Element ist nicht unbedingt das Minimum oder Maximum. std::minmax_element(v.begin(), v.end()) liefert ein Iteratorpaar: first und second verweisen auf das Minimum beziehungsweise das Maximum. Bei einem leeren Bereich sind beide gleich v.end() und dürfen nicht dereferenziert werden.

Bei einem gültigen, nicht leeren Heap verschiebt std::pop_heap(v.begin(), v.end()) die bisherige Wurzel an die letzte Position. Der vordere Teil bleibt ein Heap, die Vektorgröße ändert sich aber nicht. Lies den verschobenen Wert mit back() und lösche das Element dann mit pop_back(), das keinen Wert zurückgibt.

Beispiele

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

Ergebnis

empty
3
7
3

Nach `reserve(2)` ist der Vektor noch leer. Die Zuweisung über `back()` ändert `2` in `3`; der Zugriff über die `const`-Referenz gibt `3` aus. Nach `pop_heap()` kopiert der Code `7`, bevor er das Element löscht; `3` bleibt im Vektor.

Zugehörige Lektionen

  • C++ · Lektion 30 · Fortgeschritten · Version: 3
  • C++ · Lektion 34 · Fortgeschritten · Version: 3

Quellen