Namespaces
Variants

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

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

size_type find ( const StringViewLike & t,

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

Findet die erste Teilzeichenfolge, die der gegebenen Zeichenfolge entspricht. Die Suche beginnt bei pos , d.h. die gefundene Teilzeichenfolge darf nicht an einer Position vor pos beginnen.

1) Findet die erste Teilzeichenkette gleich str .
2) Findet den ersten Teilstring, der 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 den ersten Teilstring, der gleich der Zeichenkette ist, auf die s zeigt. Die Länge der Zeichenkette wird durch das erste Nullzeichen unter Verwendung von Traits :: length ( s ) bestimmt.
Falls [ s , s + Traits :: length ( s ) ) kein gültiger Bereich ist, ist das Verhalten undefiniert.
4) Findet das erste Zeichen ch (behandelt als Einzelzeichen-Teilzeichenkette gemäß den nachfolgenden formalen Regeln).
5) Konvertiert implizit t zu einem String-View sv als ob durch std:: basic_string_view < CharT, Traits > sv = t ; , findet dann die erste Teilzeichenkette gleich sv .
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.

Formal wird eine Teilzeichenkette str an Position xpos als gefunden bezeichnet, wenn alle folgenden Bedingungen true sind:

  • xpos >= pos
  • xpos + str. size ( ) <= size ( )
  • für alle Positionen n in str , Traits :: eq ( at ( xpos + n ) , str. at ( n ) ) .

Dies impliziert insbesondere, dass

  • Eine Teilzeichenfolge kann nur gefunden werden, wenn pos <= size ( ) - str. size ( )
  • Eine leere Teilzeichenfolge wird an Position pos gefunden, genau dann wenn pos <= size ( )
  • Für eine nicht-leere Teilzeichenfolge gilt: wenn pos >= size ( ) , gibt die Funktion immer npos zurück.

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.

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(int id, std::string::size_type n, std::string const& s)
{
    std::cout << id << ") ";
    if (std::string::npos == n)
        std::cout << "not found! n == npos\n";
    else
        std::cout << "found @ n = " << n << ", substr(" << n << ") = "
                  << std::quoted(s.substr(n)) << '\n';
}
int main()
{
    std::string::size_type n;
    std::string const s = "This is a string"; /*
                             ^  ^  ^
                             1  2  3          */
    // Suche vom Anfang des Strings
    n = s.find("is");
    print(1, n, s);
    // Suche ab Position 5
    n = s.find("is", 5);
    print(2, n, s);
    // Einzelnes Zeichen suchen
    n = s.find('a');
    print(3, n, s);
    // Einzelnes Zeichen suchen
    n = s.find('q');
    print(4, n, s);
}

Ausgabe:

1) found @ n = 2, substr(2) = "is is a string"
2) found @ n = 5, substr(5) = "is a string"
3) found @ n = 8, substr(8) = "a string"
4) not found! n == npos

Fehlerberichte

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

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes 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 einer Teilzeichenkette
(Funktion)
findet das erste Vorkommen einer Breitzeichenkette in einer anderen Breitzeichenkette
(Funktion)
findet das erste Vorkommen eines Zeichens
(Funktion)
findet das erste Vorkommen eines Breitzeichens in einer Breitzeichenkette
(Funktion)
findet das letzte Vorkommen einer Teilzeichenkette
(öffentliche Elementfunktion)
findet das erste Vorkommen von Zeichen
(öffentliche Elementfunktion)
findet die erste Abwesenheit von Zeichen
(öffentliche Elementfunktion)
findet das letzte Vorkommen von Zeichen
(öffentliche Elementfunktion)
findet die letzte Abwesenheit von Zeichen
(öffentliche Elementfunktion)
findet Zeichen in der View
(öffentliche Elementfunktion von std::basic_string_view<CharT,Traits> )
sucht nach dem ersten Vorkommen eines Elementbereichs
(Funktions-Template)