std::search

Definiert in Header `<algorithm>`
template< class ForwardIt1, class ForwardIt2 > ForwardIt1 search( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last );	(1)	(constexpr seit C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > ForwardIt1 search( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last );	(2)	(seit C++17)
template< class ForwardIt1, class ForwardIt2, class BinaryPred > ForwardIt1 search( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPred p );	(3)	(constexpr seit C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred > ForwardIt1 search( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPred p );	(4)	(seit C++17)
template< class ForwardIt, class Searcher > ForwardIt search( ForwardIt first, ForwardIt last, const Searcher& searcher );	(5)	(seit C++17) (constexpr seit C++20)

1-4) Durchsucht den Bereich [s_first, s_last) nach dem ersten Vorkommen der Elementsequenz [first, last).

1) Elemente werden mit operator== verglichen.

3) Elemente werden mit dem gegebenen binären Prädikat p verglichen.

2,4) Gleich wie (1,3), aber gemäß policy ausgeführt.

Diese Überladungen nehmen nur an der Überladungsauflösung teil, wenn der Wert des folgenden Ausdrucks true ist:

`std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>`	(bis C++20)
`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>`	(seit C++20)

5) Durchsucht den Bereich [first, last) nach dem im Konstruktor von searcher angegebenen Muster.

Die Standardbibliothek stellt die folgenden Sucher bereit:

default_searcher (C++17)	Implementierung des Standardsuchalgorithmus der C++-Bibliothek (Klassenvorlage)
boyer_moore_searcher (C++17)	Implementierung des Boyer-Moore-Suchalgorithmus (Klassenvorlage)
boyer_moore_horspool_searcher (C++17)	Implementierung des Boyer-Moore-Horspool-Suchalgorithmus (Klassenvorlage)

(seit C++17)

Parameter

first, last	-	das Paar von Iteratoren, das den Bereich der zu untersuchenden Elemente definiert
s_first, s_last	-	das Paar von Iteratoren, das den Bereich der zu suchenden Elemente definiert
policy	-	die zu verwendende Ausführungsrichtlinie
searcher	-	der Searcher, der den Suchalgorithmus und das zu suchende Muster kapselt
p	-	binäres Prädikat, das true zurückgibt, wenn die Elemente als gleich behandelt werden sollen. Die Signatur der Prädikatfunktion sollte äquivalent zu Folgendem sein: bool pred ( const Type1 & a, const Type2 & b ) ; Obwohl die Signatur nicht const & benötigt, darf die Funktion die übergebenen Objekte nicht modifizieren und muss alle Werte der Typen (möglicherweise const) `Type1` und `Type2` unabhängig von der Wertkategorie akzeptieren können (daher ist Type1 & nicht erlaubt , ebenso wenig wie Type1 , es sei denn, für `Type1` ist eine Verschiebung äquivalent zu einer Kopie (seit C++11) ). Die Typen Type1 und Type2 müssen so beschaffen sein, dass Objekte der Typen ForwardIt1 und ForwardIt2 dereferenziert und dann implizit in Type1 bzw. Type2 konvertiert werden können.
Typanforderungen
- `ForwardIt1, ForwardIt2` müssen die Anforderungen von LegacyForwardIterator erfüllen.
- `BinaryPred` müssen die Anforderungen von BinaryPredicate erfüllen.

Rückgabewert

1-4) Iterator zum Anfang des ersten Vorkommens der Sequenz

s_first

s_last

im Bereich

first

last

. Wenn kein solches Vorkommen gefunden wird, wird last zurückgegeben.

Wenn

s_first

s_last

leer ist, first wird zurückgegeben.

5) searcher ( first, last ) . first .

Komplexität

1-4) Gegeben

N

als std:: distance ( first, last ) und

S

als std:: distance ( s_first, s_last ) :

1,2) Höchstens

N\cdotS

Vergleiche unter Verwendung von operator == .

3,4) Höchstens

N\cdotS

Anwendungen des Prädikats p .

5) Hängt ab von searcher .

Ausnahmen

Die Überladungen mit einem Template-Parameter namens ExecutionPolicy melden Fehler wie folgt:

Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
Wenn der Algorithmus keinen Speicher allokieren kann, wird std::bad_alloc geworfen.

Mögliche Implementierung

search (1)

template<class ForwardIt1, class ForwardIt2>
constexpr //< since C++20
ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
                  ForwardIt2 s_first, ForwardIt2 s_last)
{
    while (true)
    {
        ForwardIt1 it = first;
        for (ForwardIt2 s_it = s_first; ; ++it, ++s_it)
        {
            if (s_it == s_last)
                return first;
            if (it == last)
                return last;
            if (!(*it == *s_it))
                break;
        }
        ++first;
    }
}

search (3)

template<class ForwardIt1, class ForwardIt2, class BinaryPred>
constexpr //< since C++20
ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
                  ForwardIt2 s_first, ForwardIt2 s_last, BinaryPred p)
{
    while (true)
    {
        ForwardIt1 it = first;
        for (ForwardIt2 s_it = s_first; ; ++it, ++s_it)
        {
            if (s_it == s_last)
                return first;
            if (it == last)
                return last;
            if (!p(*it, *s_it))
                break;
        }
        ++first;
    }
}

Beispiel

Diesen Code ausführen

#include <algorithm>
#include <cassert>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string_view>
#include <vector>
using namespace std::literals;
bool contains(const auto& cont, std::string_view s)
{
    // str.find() (oder str.contains(), seit C++23) kann ebenfalls verwendet werden
    return std::search(cont.begin(), cont.end(), s.begin(), s.end()) != cont.end();
}
int main()
{
    const auto str{"why waste time learning, when ignorance is instantaneous?"sv};
    assert(contains(str, "learning"));
    assert(not contains(str, "lemming"));
    const std::vector vec(str.begin(), str.end());
    assert(contains(vec, "learning"));
    assert(not contains(vec, "leaning"));
    // Demonstration der C++17-Überladung mit Suchern:
    constexpr auto quote
    {
        "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed "
        "do eiusmod tempor incididunt ut labore et dolore magna aliqua"sv
    };
    for (const auto word : {"pisci"sv, "Pisci"sv})
    {
        std::cout << "The string " << std::quoted(word) << ' ';
        const std::boyer_moore_searcher searcher(word.begin(), word.end());
        const auto it = std::search(quote.begin(), quote.end(), searcher);
        if (it == quote.end())
            std::cout << "not found\n";
        else
            std::cout << "found at offset " << std::distance(quote.begin(), it) << '\n';
    }
}

Ausgabe:

The string "pisci" found at offset 43
The string "Pisci" not found

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 1205	C++98	der Rückgabewert war unklar, falls `[` s_first `,` s_last `)` leer ist	gibt in diesem Fall first zurück
LWG 1338	C++98	die Lösung von LWG Issue 1205 wurde falsch angewendet, wodurch first zurückgegeben wurde, falls kein Vorkommen gefunden wurde	gibt in diesem Fall last zurück
LWG 2150	C++98	die Bedingung für "Sequenzvorkommen" war inkorrekt	korrigiert

Siehe auch

find_end	findet die letzte Sequenz von Elementen in einem bestimmten Bereich (Funktionsschablone &Algorithmus-Funktionsobjekt)
ranges::find_end (C++20)
includes	bestimmt, ob eine Folge eine Teilfolge einer anderen ist (Funktionsschablone &Algorithmus-Funktionsobjekt)
ranges::includes (C++20)
equal	bestimmt, ob zwei Mengen von Elementen gleich sind (Funktionsschablone &Algorithmus-Funktionsobjekt)
ranges::equal (C++20)
findfind_iffind_if_not (C++11)	findet das erste Element, das bestimmte Kriterien erfüllt (Funktionsschablone &Algorithmus-Funktionsobjekt)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)
lexicographical_compare	vergleicht zwei Bereiche lexikografisch (Funktionsschablone &Algorithmus-Funktionsobjekt)
ranges::lexicographical_compare (C++20)
mismatch	findet die erste Position, an der sich zwei Bereiche unterscheiden (Funktionsschablone &Algorithmus-Funktionsobjekt)
ranges::mismatch (C++20)
search_n	sucht nach dem ersten Vorkommen einer Anzahl aufeinanderfolgender Kopien eines Elements in einem Bereich (Funktionsschablone &Algorithmus-Funktionsobjekt)
ranges::search_n (C++20)
default_searcher (C++17)	Implementierung des Suchalgorithmus der Standard-C++-Bibliothek (Klassenschablone)
boyer_moore_searcher (C++17)	Implementierung des Boyer-Moore-Suchalgorithmus (Klassenschablone)
boyer_moore_horspool_searcher (C++17)	Implementierung des Boyer-Moore-Horspool-Suchalgorithmus (Klassenschablone)
ranges::search (C++20)	sucht nach dem ersten Vorkommen eines Bereichs von Elementen (Algorithmus-Funktionsobjekt)

Compiler-Unterstützung
Freistehend und gehostet
Sprache
Standardbibliothek
Standardbibliotheks-Header
Benannte Anforderungen
Feature-Test-Makros (C++20)
Sprachunterstützungsbibliothek
Konzeptbibliothek (C++20)
Diagnosebibliothek
Speicherverwaltungsbibliothek
Metaprogrammierungsbibliothek (C++11)
Allgemeine Werkzeugbibliothek
Containerbibliothek
Iteratorenbibliothek
Bereichsbibliothek (C++20)
Algorithmenbibliothek
Zeichenkettenbibliothek
Textverarbeitungsbibliothek
Numerikbibliothek
Datums- und Zeitbibliothek
Ein-/Ausgabebibliothek
Dateisystembibliothek (C++17)
Nebenläufigkeitsunterstützungsbibliothek (C++11)
Ausführungssteuerungsbibliothek (C++26)
Technische Spezifikationen
Symbolverzeichnis
Externe Bibliotheken

de.cppreference.net

Namespaces

Variants