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 depuis C++11)
(constexpr depuis C++20)
size_type rfind ( const CharT * s, size_type pos, size_type count ) const ;
(2) (constexpr depuis C++20)
size_type rfind ( const CharT * s, size_type pos = npos ) const ;
(3) (constexpr depuis C++20)
size_type rfind ( CharT ch, size_type pos = npos ) const ;
(4) (noexcept depuis C++11)
(constexpr depuis C++20)
template < class StringViewLike >

size_type rfind ( const StringViewLike & t,

size_type pos = npos ) const noexcept ( /* voir ci-dessous */ ) ;
(5) (depuis C++17)
(constexpr depuis C++20)

Trouve la dernière sous-chaîne égale à la séquence de caractères donnée. La recherche commence à pos et procède de droite à gauche (ainsi, la sous-chaîne trouvée, si elle existe, ne peut pas commencer à une position suivant pos ). Si npos ou toute valeur non inférieure à size() - 1 est passée comme pos , la chaîne entière sera recherchée.

1) Trouve la dernière sous-chaîne égale à str .
2) Trouve la dernière sous-chaîne égale à la plage [ s , s + count ) . Cette plage peut inclure des caractères nuls.
Si [ s , s + count ) n'est pas un intervalle valide , le comportement est indéfini.
3) Trouve la dernière sous-chaîne égale à la chaîne de caractères pointée par s . La longueur de la chaîne est déterminée par le premier caractère nul en utilisant Traits :: length ( s ) .
Si [ s , s + Traits :: length ( s ) ) n'est pas un intervalle valide , le comportement est indéfini.
4) Trouve le dernier caractère égal à ch .
5) Convertit implicitement t en une vue de chaîne sv comme si par std:: basic_string_view < CharT, Traits > sv = t ; , puis trouve la dernière sous-chaîne égale au contenu de sv .
Cette surcharge participe à la résolution de surcharge seulement si std:: is_convertible_v < const StringViewLike & ,
std:: basic_string_view < CharT, Traits >>
est true et std:: is_convertible_v < const StringViewLike & , const CharT * > est false .

Dans tous les cas, l'égalité est vérifiée en appelant Traits::eq .

Table des matières

Paramètres

str - chaîne à rechercher
pos - position à laquelle commencer la recherche
count - longueur de la sous-chaîne à rechercher
s - pointeur vers une chaîne de caractères à rechercher
ch - caractère à rechercher
t - objet (convertible en std::basic_string_view ) à rechercher

Valeur de retour

Position du premier caractère de la sous-chaîne trouvée ou npos si aucune sous-chaîne de ce type n'est trouvée. Notez qu'il s'agit d'un décalage depuis le début de la chaîne, et non depuis la fin.

Si on recherche une chaîne vide (c'est-à-dire, str. size ( ) , count , ou Traits :: length ( s ) vaut zéro), la chaîne vide est trouvée immédiatement et rfind retourne :

  • pos , si pos < size ( ) ;
  • size ( ) sinon, y compris le cas où pos == npos .

Sinon, si size() est zéro, npos est toujours retourné.

Exceptions

1,4) Ne lance rien.
5)
noexcept spécification :
noexcept ( std:: is_nothrow_convertible_v < const T & , std:: basic_string_view < CharT, Traits >> )

Si une exception est levée pour quelque raison que ce soit, cette fonction n'a aucun effet ( garantie forte de sûreté face aux exceptions ).

Exemple

#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";
    // recherche en arrière depuis la fin de la chaîne
    n = s.rfind("is");
    print(n, 2, s);
    // recherche en arrière depuis la position 4
    n = s.rfind("is", 4);
    print(n, 2, s);
    // trouver un caractère unique
    n = s.rfind('s');
    print(n, 1, s);
    // trouver un caractère unique
    n = s.rfind('q');
    print(n, 1, s);
    // trouver le préfixe (voir aussi s.starts_with("This"))
    n = s.rfind("This", 0);
    print(n, 4, s);
}

Sortie :

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 847 C++98 il n'y avait aucune garantie de sécurité des exceptions garantie de sécurité forte des exceptions ajoutée
LWG 2064 C++11 les surcharges (3,4) étaient noexcept supprimé
LWG 2946 C++17 la surcharge (5) causait une ambiguïté dans certains cas évité en la rendant template
P1148R0 C++11
C++17
noexcept pour les surcharges (4,5) a été
accidentellement supprimé par LWG2064/LWG2946
restauré

Voir aussi

trouve la première occurrence de la sous-chaîne donnée
(fonction membre publique)
trouve la première occurrence de caractères
(fonction membre publique)
trouve la première absence de caractères
(fonction membre publique)
trouve la dernière occurrence de caractères
(fonction membre publique)
trouve la dernière absence de caractères
(fonction membre publique)
trouve la dernière occurrence d'une sous-chaîne
(fonction membre publique de std::basic_string_view<CharT,Traits> )