Wie man das letzte Zeichen aus einer Zeichenfolge in C++ erhält

Bei einer Zeichenfolge wie "Spider Man" verweist text.back() direkt auf ihr letztes Zeichen. Sie können auch at(text.size() - 1) verwenden, wenn Sie einen geprüften Positionszugriff wünschen. Die Zeichenfolge muss ein Zeichen enthalten, bevor einer dieser Ansätze verwendet wird.

Verwenden Sie std::string::at, um das letzte Zeichen aus einer Zeichenfolge in C++ zu erhalten

std::string::at(index) gibt das Zeichen an einer nullbasierten Position zurück und prüft, ob die Position innerhalb der Zeichenfolge liegt. Die letzte Position ist text.size() - 1. Liegt der Index außerhalb der Zeichenfolge, löst at() eine std::out_of_range aus; der Indextyp ist vorzeichenlos, sodass ein negativer Wert in einen großen vorzeichenlosen Wert umgewandelt wird, anstatt als gültiger negativer Index zu wirken.

Führen Sie dieses Beispiel aus:

#include <iostream>
#include <string>

int main() {
    const std::string text = "Spider Man";
    std::cout << "Character at position 3: " << text.at(3) << '\n';
    std::cout << "Character at last position: "
              << text.at(text.size() - 1) << '\n';
}

Der erste Zugriff verwendet den Index 3; der zweite berechnet den letzten Index aus der Länge der Zeichenfolge. Prüfen Sie, ob die Zeichenfolge nicht leer ist, bevor Sie diese letzte Position berechnen und verwenden.

Verwenden Sie std::string::back(), um das letzte Zeichen aus einer Zeichenfolge in C++ zu erhalten

std::string::back() ist der direkte Weg, um auf das letzte Zeichen zuzugreifen. Es gibt eine Referenz zurück, sodass Sie das Zeichen lesen oder über diese Referenz einen Ersatz zuweisen können. Der Aufruf von back() auf einer leeren Zeichenfolge hat undefiniertes Verhalten, prüfen Sie die Zeichenfolge daher vor der Verwendung.

#include <iostream>
#include <string>

int main() {
    std::string text = "Spider Man";
    const char last = text.back();
    std::cout << "Character at the end: " << last << '\n';
    text.back() = '@';
    std::cout << "After replacement: " << text << '\n';
}

Der erste Aufruf liest n; die Zuweisung ändert die Zeichenfolge in "Spider Ma@".

Verwenden Sie std::string::rbegin(), um das letzte Zeichen aus einer Zeichenfolge in C++ zu erhalten

std::string::rbegin() gibt einen umgekehrten Iterator zurück, dessen erste Position dem letzten Zeichen der Zeichenfolge entspricht. Dereferenzieren Sie ihn, um dieses Zeichen zu lesen, sofern die Zeichenfolge nicht leer ist.

#include <iostream>
#include <string>

int main() {
    const std::string text = "Spider Man";
    const auto last = *text.rbegin();
    std::cout << "The last character is: " << last << '\n';
}

Verwenden Sie rbegin(), wenn Sie mit umgekehrter Iteration arbeiten; für ein einzelnes Zeichen ist back() direkter.

Verwenden Sie std::reverse mit Zeichenfolgen-Iteratoren, um das letzte Zeichen in C++ zu erhalten

std::reverse ist ein Algorithmus, der in <algorithm> deklariert ist, keine Memberfunktion von std::string. Er kehrt die Elemente im Iteratorbereich an Ort und Stelle um. Nach dem Umkehren einer nicht leeren Zeichenfolge verweist text.front() auf das Zeichen, das ursprünglich an letzter Stelle stand. Dadurch ändert sich die gesamte Zeichenfolge, sodass dies in der Regel unnötig ist, wenn Sie nur ihr letztes Zeichen lesen möchten.

#include <algorithm>
#include <iostream>
#include <string>

int main() {
    std::string text = "Spider Man";
    std::reverse(text.begin(), text.end());
    std::cout << "The former last character is: " << text.front() << '\n';
}

Der Algorithmus arbeitet auf dem halboffenen Bereich von begin() bis end(). Stellen Sie sicher, dass die Zeichenfolge nicht leer ist, bevor Sie danach front() lesen.

Verwenden Sie std::string::substr(), um das letzte Zeichen aus einer Zeichenfolge in C++ zu erhalten

std::string::substr(position, count) gibt eine neue Zeichenfolge zurück. Bei einer Zeichenfolge mit mindestens einem Zeichen extrahiert text.substr(text.size() - 1, 1) ihr letztes Zeichen als eine Zeichenfolge aus einem Zeichen. Prüfen Sie, ob ein Zeichen vorhanden ist, bevor Sie die Startposition berechnen.

#include <iostream>
#include <string>

int main() {
    const std::string text = "Spider Man";
    const std::string last = text.substr(text.size() - 1, 1);
    std::cout << "Last character extracted: " << last << '\n';
}

Wählen Sie substr(), wenn das Ergebnis eine Zeichenfolge sein soll; verwenden Sie einen Zeichenzugriff, wenn ein char ausreicht.

Verwenden Sie Array-Indizierung, um auf die Zeichen einer Zeichenfolge in C++ zuzugreifen

std::string unterstützt operator[], sodass das letzte Zeichen als text[text.size() - 1] gelesen werden kann, nachdem bestätigt wurde, dass die Zeichenfolge nicht leer ist. Anders als at() bietet operator[] nicht denselben geprüften Zugriff für eine Position außerhalb des Bereichs.

#include <iostream>
#include <string>

int main() {
    const std::string text = "Spider Man";
    std::cout << "The last character is: "
              << text[text.size() - 1] << '\n';
}

Der Index ist nullbasiert: Bei einer Zeichenfolge der Länge n steht das letzte Zeichen am Index n - 1. Bevorzugen Sie at(), wenn ein Index außerhalb des Bereichs durch eine Ausnahme gemeldet werden soll.

Fazit

Für den direkten Zugriff auf das letzte Zeichen einer nicht leeren std::string verwenden Sie back(). Wählen Sie at(size() - 1), wenn ein geprüfter Positionszugriff nützlich ist. rbegin() erreicht das letzte Zeichen ebenfalls durch umgekehrte Iteration, substr() gibt es als Zeichenfolge zurück, und die Indizierung verwendet dieselbe letzte Position ohne die Bereichsprüfung von at(). Prüfen Sie, ob die Zeichenfolge ein Zeichen enthält, bevor Sie auf ihr Ende zugreifen.