Namespaces
Variants

std::basic_string<CharT,Traits,Allocator>:: rfind

From cppreference.net
std::basic_string
size_type rfind ( const basic_string & str, size_type pos = npos ) const ;
(1) (noexcept seit C++11)
(constexpr seit C++20)
size_type rfind ( const CharT * s, size_type pos, size_type count ) const ;
(2) (constexpr seit C++20)
size_type rfind ( const CharT * s, size_type pos = npos ) const ;
(3) (constexpr seit C++20)
size_type rfind ( CharT ch, size_type pos = npos ) const ;
(4) (noexcept seit C++11)
(constexpr seit C++20)
template < class StringViewLike >

size_type rfind ( const StringViewLike & t,

size_type pos = npos ) const noexcept ( /* siehe unten */ ) ;
(5) (seit C++17)
(constexpr seit C++20)

Findet die letzte Teilzeichenfolge, die der gegebenen Zeichenfolge entspricht. Die Suche beginnt bei pos und verläuft von rechts nach links (daher kann die gefundene Teilzeichenfolge, falls vorhanden, nicht an einer Position beginnen, die nach pos liegt). Wenn npos oder ein Wert nicht kleiner als size() - 1 als pos übergeben wird, wird die gesamte Zeichenfolge durchsucht.

1) Findet die letzte Teilzeichenkette gleich str .
2) Findet die letzte Teilzeichenkette, die dem Bereich [ s , s + count ) entspricht. Dieser Bereich kann Nullzeichen enthalten.
Falls [ s , s + count ) kein gültiger Bereich ist, ist das Verhalten undefiniert.
3) Findet die letzte Teilzeichenfolge, die gleich der Zeichenfolge ist, auf die s zeigt. Die Länge der Zeichenfolge wird durch das erste Nullzeichen unter Verwendung von Traits :: length ( s ) bestimmt.
Wenn [ s , s + Traits :: length ( s ) ) kein gültiger Bereich ist, ist das Verhalten undefiniert.
4) Findet das letzte Zeichen gleich ch .
5) Konvertiert implizit t zu einem String-View sv als ob durch std:: basic_string_view < CharT, Traits > sv = t ; , findet dann die letzte Teilzeichenkette, die dem Inhalt von sv entspricht.
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_convertible_v < const StringViewLike & ,
std:: basic_string_view < CharT, Traits >>
true ist und std:: is_convertible_v < const StringViewLike & , const CharT * > false ist.

In allen Fällen wird Gleichheit durch Aufruf von Traits::eq überprüft.

Inhaltsverzeichnis

Parameter

str - Zeichenkette, nach der gesucht werden soll
pos - Position, an der die Suche beginnen soll
count - Länge des zu suchenden Teilstrings
s - Zeiger auf eine Zeichenkette, nach der gesucht werden soll
ch - Zeichen, nach dem gesucht werden soll
t - Objekt (konvertierbar zu std::basic_string_view ), nach dem gesucht werden soll

Rückgabewert

Position des ersten Zeichens der gefundenen Teilzeichenkette oder npos falls keine solche Teilzeichenkette gefunden wurde. Beachten Sie, dass dies ein Offset vom Anfang der Zeichenkette ist, nicht vom Ende.

Wenn nach einer leeren Zeichenkette gesucht wird (d.h., str. size ( ) , count , oder Traits :: length ( s ) ist null), wird die leere Zeichenkette sofort gefunden und rfind gibt zurück:

  • pos , falls pos < size ( ) ;
  • size ( ) andernfalls, einschließlich des Falls, in dem pos == npos .

Andernfalls, wenn size() null ist, wird stets npos zurückgegeben.

Ausnahmen

1,4) Wirft nichts.
5)
noexcept Spezifikation:
noexcept ( std:: is_nothrow_convertible_v < const T & , std:: basic_string_view < CharT, Traits >> )

Wenn aus irgendeinem Grund eine Exception ausgelöst wird, hat diese Funktion keine Wirkung ( strong exception safety guarantee ).

Beispiel

#include <iomanip>
#include <iostream>
#include <string>
void print(std::string::size_type n,
           std::string::size_type len,
           std::string const &s)
{
    if (n == std::string::npos)
        std::cout << "not found\n";
    else
        std::cout << "found: " << std::quoted(s.substr(n, len)) << " at " << n << '\n';
}
int main()
{
    std::string::size_type n;
    std::string const s = "This is a string";
    // Suche rückwärts vom Ende des Strings
    n = s.rfind("is");
    print(n, 2, s);
    // Suche rückwärts von Position 4
    n = s.rfind("is", 4);
    print(n, 2, s);
    // Finde ein einzelnes Zeichen
    n = s.rfind('s');
    print(n, 1, s);
    // Finde ein einzelnes Zeichen
    n = s.rfind('q');
    print(n, 1, s);
    // Finde das Präfix (siehe auch s.starts_with("This"))
    n = s.rfind("This", 0);
    print(n, 4, s);
}

Ausgabe:

found: "is" at 5
found: "is" at 2
found: "s" at 10
not found
found: "This" at 0

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 847 C++98 es gab keine Exception-Sicherheitsgarantie starke Exception-Sicherheitsgarantie hinzugefügt
LWG 2064 C++11 Überladungen (3,4) waren noexcept entfernt
LWG 2946 C++17 Überladung (5) verursachte in einigen Fällen Mehrdeutigkeit vermieden durch Template-Implementierung
P1148R0 C++11
C++17
noexcept für Überladungen (4,5) wurden
versehentlich durch LWG2064/LWG2946 entfernt
wiederhergestellt

Siehe auch

findet das erste Vorkommen der angegebenen Teilzeichenkette
(öffentliche Elementfunktion)
findet das erste Vorkommen von Zeichen
(öffentliche Elementfunktion)
findet das erste Fehlen von Zeichen
(öffentliche Elementfunktion)
findet das letzte Vorkommen von Zeichen
(öffentliche Elementfunktion)
findet das letzte Fehlen von Zeichen
(öffentliche Elementfunktion)
findet das letzte Vorkommen einer Teilzeichenkette
(öffentliche Elementfunktion von std::basic_string_view<CharT,Traits> )