home | help 
std::basic_string::rfind(3)    C++ Standard Libary   std::basic_string::rfind(3)

NAME
     std::basic_string::rfind - std::basic_string::rfind

Synopsis
	size_type  rfind(  const basic_string& str, size_type pos  (1) (noexcept
     since C++11)
	= npos ) const; 					      (constexpr
     since C++20)
	size_type  rfind( const CharT* s, size_type pos,	  (2) (constexpr
     since C++20)
	size_type count ) const;
	size_type rfind( const CharT* s, size_type pos = npos )  (3)  (constexpr
     since C++20)
	const;
	size_type  rfind(  CharT ch, size_type pos = npos ) const; (4) (noexcept
     since C++11)
								     (constexpr
     since C++20)
	template< class StringViewLike >

	size_type rfind(  const  StringViewLike&  t,		     (5)  (since
     C++17)
								     (constexpr
     since C++20)
			 size_type pos = npos ) const
	noexcept(/* see below */);

	Finds  the last substring that is equal to the given character sequence.
     The search
	begins at pos and proceeds from right to  left	(thus,	the  found  sub-
     string, if any,
	cannot	begin  in  a  position	following pos). If npos or any value not
     smaller than
	size() - 1 is passed as pos, the whole string will be searched.

	1) Finds the last substring equal to str.
	2) Finds the last substring equal to the range	[s,  s	+  count).  This
     range can
	include null characters.
	If [s, s + count) is not a valid range, the behavior is undefined.
	3)  Finds the last substring equal to the character string pointed to by
     s. The
	length of the string is determined by the first null character using
	Traits::length(s).
	If [s, s + Traits::length(s)) is not a valid range, the behavior is  un-
     defined.
	4) Finds the last character equal to ch.
	5)  Implicitly	converts  t  to  a  string  view  sv  as  if by std::ba-
     sic_string_view<CharT,
	Traits> sv = t;, then finds the last substring equal to the contents  of
     sv.
	This overload participates in overload resolution only if
	std::is_convertible_v<const StringViewLike&,
			      std::basic_string_view<CharT, Traits>> is true and
	std::is_convertible_v<const StringViewLike&, const CharT*> is false.

	In all cases, equality is checked by calling Traits::eq.

Parameters
	str   - string to search for
	pos   - position at which to begin searching
	count - length of substring to search for
	s     - pointer to a character string to search for
	ch    - character to search for
	t     - object (convertible to std::basic_string_view) to search for

Return value
	Position  of  the  first  character of the found substring or npos if no
     such substring
	is found. Note that this is an offset from the start of the string,  not
     the end.

	If   searching	 for  an  empty  string  (i.e.,  str.size(),  count,  or
     Traits::length(s) is
	zero), the empty string is found immediately and rfind returns:

	  * pos, if pos < size();
	  * size() otherwise, including the case where pos == npos.

	Otherwise, if size() is zero, npos is always returned.

Exceptions
	1,4) Throws nothing.
	5)
	noexcept specification:
	noexcept(std::is_nothrow_convertible_v<const	    T&, 	std::ba-
     sic_string_view<CharT,
	Traits>>)

	If  an	exception  is thrown for any reason, this function has no effect
     (strong
	exception safety guarantee).

Example
     // Run this code

      #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";

	  // search backwards from end of string
	  n = s.rfind("is");
	  print(n, 2, s);

	  // search backwards from position 4
	  n = s.rfind("is", 4);
	  print(n, 2, s);

	  // find a single character
	  n = s.rfind('s');
	  print(n, 1, s);

	  // find a single character
	  n = s.rfind('q');
	  print(n, 1, s);

	  // find the prefix (see also s.starts_with("This"))
	  n = s.rfind("This", 0);
	  print(n, 4, s);
      }

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

	Defect reports

	The  following	behavior-changing  defect  reports were applied retroac-
     tively to
	previously published C++ standards.

	   DR	 Applied to	      Behavior as published		 Correct
     behavior
	LWG 847  C++98	    there was  no  exception  safety  guarantee    added
     strong exception
								      safety
     guarantee
	LWG 2064 C++11	    overloads (3,4) were noexcept	      removed
	LWG 2946 C++17	    overload (5) caused ambiguity in some     avoided by
     making it a
			    cases				      template
	P1148R0  C++11	    noexcept for overloads (4,5) were	      restored
		 C++17	    accidently dropped by LWG2064/LWG2946

See also
	find		  finds the first occurrence of the given substring
			  (public member function)
	find_first_of	  find first occurrence of characters
			  (public member function)
	find_first_not_of find first absence of characters
			  (public member function)
	find_last_of	  find last occurrence of characters
			  (public member function)
	find_last_not_of  find last absence of characters
			  (public member function)
			  find the last occurrence of a substring
	rfind		      (public	  member     function	  of	std::ba-
     sic_string_view<CharT,Traits>)

Category:
	  * conditionally noexcept

http://cppreference.com 	   2024.06.10	     std::basic_string::rfind(3)
home | help