std::find, std::find_if, std::find_if_not

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Algorithmenbibliothek

Beschränkte Algorithmen und Algorithmen für Bereiche (C++20)
Beschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
Ausführungsrichtlinien (C++17)
is_execution_policy (C++17)   execution::seqexecution::parexecution::par_unseqexecution::unseq (C++17)    (C++17)(C++17)(C++20)	execution::sequenced_policyexecution::parallel_policyexecution::parallel_unsequenced_policyexecution::parallel_unsequenced (C++17)(C++17)(C++17)(C++20)
Nicht-modifizierende Sequenzoperationen Stapeloperationen for_each for_each_n (C++17) Suchoperationen all_ofany_ofnone_of (C++11)                (C++11)(C++11) countcount_if mismatch equal findfind_iffind_if_not (C++11) find_end find_first_of adjacent_find search search_n Modifizierende Sequenzoperationen Kopieroperationen copycopy_if (C++11) copy_backward copy_n (C++11) move (C++11) move_backward (C++11) Tauschoperationen swap iter_swap swap_ranges Transformationsoperationen replacereplace_if transform replace_copyreplace_copy_if Generierungsoperationen fill fill_n generate generate_n Entfernungsoperationen removeremove_if unique remove_copyremove_copy_if unique_copy Ordnungsändernde Operationen reverse reverse_copy rotate rotate_copy random_shuffleshuffle (bis C++17)(C++11) shift_leftshift_right (C++20)(C++20) Stichprobenoperationen sample (C++17)	Sortier- und verwandte Operationen Partitionierungsoperationen partition partition_copy (C++11)   stable_partition is_partitioned (C++11) partition_point (C++11) Sortieroperationen sort stable_sort partial_sort partial_sort_copy is_sorted (C++11) is_sorted_until (C++11) nth_element Binäre Suchoperationen (auf partitionierten Bereichen) lower_bound upper_bound equal_range binary_search Mengenoperationen (auf sortierten Bereichen) includes set_union set_intersection set_difference set_symmetric_difference Zusammenführungsoperationen (auf sortierten Bereichen) merge inplace_merge Heapoperationen push_heap pop_heap make_heap sort_heap is_heap (C++11) is_heap_until (C++11) Minimum/Maximum-Operationen max min minmax (C++11) clamp (C++17) max_element min_element minmax_element (C++11) Lexikographische Vergleichsoperationen lexicographical_compare lexicographical_compare_three_way (C++20) Permutationsoperationen next_permutation prev_permutation is_permutation (C++11) C-Bibliothek qsort bsearch
Numerische Operationen
iota (C++11) inner_product adjacent_difference    accumulate reduce (C++17) transform_reduce (C++17)	partial_sum inclusive_scan (C++17)    exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
Operationen auf uninitialisiertem Speicher
uninitialized_copy uninitialized_move (C++17)    uninitialized_fill uninitialized_copy_n (C++11) uninitialized_move_n (C++17) uninitialized_fill_n	destroy (C++17) destroy_n (C++17) destroy_at (C++17) construct_at (C++20)       uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17)

 

Definiert in Header <algorithm>
	(1)
template< class InputIt, class T > InputIt find( InputIt first, InputIt last, const T& value );			(constexpr seit C++20) (bis C++26)
template< class InputIt, class T = typename std::iterator_traits                                        <InputIt>::value_type > constexpr InputIt find( InputIt first, InputIt last, const T& value );			(seit C++26)
		(2)
template< class ExecutionPolicy, class ForwardIt, class T > ForwardIt find( ExecutionPolicy&& policy,                 ForwardIt first, ForwardIt last, const T& value );				(seit C++17) (bis C++26)
template< class ExecutionPolicy,           class ForwardIt, class T = typename std::iterator_traits                                          <ForwardIt>::value_type > ForwardIt find( ExecutionPolicy&& policy,                 ForwardIt first, ForwardIt last, const T& value );				(seit C++26)
template< class InputIt, class UnaryPred > InputIt find_if( InputIt first, InputIt last, UnaryPred p );			(3)	(constexpr seit C++20)
template< class ExecutionPolicy, class ForwardIt, class UnaryPred > ForwardIt find_if( ExecutionPolicy&& policy,                    ForwardIt first, ForwardIt last, UnaryPred p );			(4)	(seit C++17)
template< class InputIt, class UnaryPred > InputIt find_if_not( InputIt first, InputIt last, UnaryPred q );			(5)	(seit C++11) (constexpr seit C++20)
template< class ExecutionPolicy, class ForwardIt, class UnaryPred > ForwardIt find_if_not( ExecutionPolicy&& policy,                        ForwardIt first, ForwardIt last, UnaryPred q );			(6)	(seit C++17)

Gibt einen Iterator zum ersten Element im Bereich [first, last) zurück, das bestimmte Kriterien erfüllt (oder last, wenn kein solches Element existiert).

1) find sucht nach einem Element, das gleich value ist (unter Verwendung von operator==).

3) find_if sucht nach einem Element, für das der Prädikat p true zurückgibt.

5) find_if_not sucht nach einem Element, für das der Prädikat q false zurückgibt.

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

Diese Überladungen nehmen an der Auflösungsauflösung teil, nur wenn alle folgenden Bedingungen erfüllt sind

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> ist true.	(bis C++20)
std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> ist true.	(seit C++20)

Parameter

first, last	-	das Iteratorenpaar, das den Bereich der zu untersuchenden Elemente definiert
value	-	Wert, mit dem die Elemente verglichen werden sollen
policy	-	die Ausführungsrichtlinie, die verwendet werden soll
p	-	unäres Prädikat, das für das gesuchte Element ​true zurückgibt. Der Ausdruck p(v) muss für jedes Argument v vom Typ (möglicherweise const) VT, wobei VT der Werttyp von InputIt ist, unabhängig von der Wertkategorie, in bool konvertierbar sein und darf v nicht modifizieren. Daher ist ein Parametertyp von VT&nicht zulässig, ebenso wenig wie VT, es sei denn, für VT ist ein Move äquivalent zu einer Kopie(seit C++11). ​
q	-	unäres Prädikat, das für das gesuchte Element ​false zurückgibt. Der Ausdruck q(v) muss für jedes Argument v vom Typ (möglicherweise const) VT, wobei VT der Werttyp von InputIt ist, unabhängig von der Wertkategorie, in bool konvertierbar sein und darf v nicht modifizieren. Daher ist ein Parametertyp von VT&nicht zulässig, ebenso wenig wie VT, es sei denn, für VT ist ein Move äquivalent zu einer Kopie(seit C++11). ​
Typanforderungen
- InputIt muss die Anforderungen von LegacyInputIterator erfüllen.
- ForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.
- UnaryPredicate muss die Anforderungen eines Prädikats erfüllen.

Rückgabewert

Der erste Iterator it im Bereich [first, last), der die folgende Bedingung erfüllt, oder last, wenn kein solcher Iterator existiert.

1,2) *it == value ist true.

3,4) p(*it) ist true.

5,6) q(*it) ist false.

Komplexität

Gegeben sei \(\scriptsize N\)N als std::distance(first, last).

1,2) Höchstens \(\scriptsize N\)N Vergleiche mit value unter Verwendung von operator==.

3,4) Höchstens \(\scriptsize N\)N Anwendungen des Prädikats p.

5,6) Höchstens \(\scriptsize N\)N Anwendungen des Prädikats q.

Ausnahmen

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

• Wenn die Ausführung einer Funktion, die als Teil des Algorithmus aufgerufen wird, eine Ausnahme auslöst und ExecutionPolicy eine der Standardrichtlinien ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsabhängig.
• Wenn dem Algorithmus der Speicher zur Neuzuweisung fehlt, wird std::bad_alloc ausgelöst.

Mögliche Implementierung

find (1)
template<class InputIt, class T = typename std::iterator_traits<InputIt>::value_type> constexpr InputIt find(InputIt first, InputIt last, const T& value) { for (; first != last; ++first) if (*first == value) return first;   return last; }
find_if (3)
template<class InputIt, class UnaryPred> constexpr InputIt find_if(InputIt first, InputIt last, UnaryPred p) { for (; first != last; ++first) if (p(*first)) return first;   return last; }
find_if_not (5)
template<class InputIt, class UnaryPred> constexpr InputIt find_if_not(InputIt first, InputIt last, UnaryPred q) { for (; first != last; ++first) if (!q(*first)) return first;   return last; }

Anmerkungen

Wenn C++11 nicht verfügbar ist, kann eine Alternative zu std::find_if_not die Verwendung von std::find_if mit dem negierten Prädikat sein.

template<class InputIt, class UnaryPred> InputIt find_if_not(InputIt first, InputIt last, UnaryPred q) { return std::find_if(first, last, std::not1(q)); }

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_algorithm_default_value_type	202403	(C++26)	Listeninitialisierung für Algorithmen (1,2)

Beispiel

Das folgende Beispiel sucht nach Zahlen in gegebenen Sequenzen.

Führen Sie diesen Code aus

#include <algorithm>
#include <array>
#include <cassert>
#include <complex>
#include <initializer_list>
#include <iostream>
#include <vector>
 
bool is_even(int i)
{
    return i % 2 == 0;
}
 
void example_contains()
{
    const auto haystack = {1, 2, 3, 4};
 
    for (const int needle : {3, 5})
        if (std::find(haystack.begin(), haystack.end(), needle) == haystack.end())
            std::cout << "haystack does not contain " << needle << '\n';
        else
            std::cout << "haystack contains " << needle << '\n';
}
 
void example_predicate()
{
    for (const auto& haystack : {std::array{3, 1, 4}, {1, 3, 5}})
    {
        const auto it = std::find_if(haystack.begin(), haystack.end(), is_even);
        if (it != haystack.end())
            std::cout << "haystack contains an even number " << *it << '\n';
        else
            std::cout << "haystack does not contain even numbers\n";
    }
}
 
void example_list_init()
{
    std::vector<std::complex<double>> haystack{{4.0, 2.0}};
#ifdef __cpp_lib_algorithm_default_value_type
    // T gets deduced making list-initialization possible
    const auto it = std::find(haystack.begin(), haystack.end(), {4.0, 2.0});
#else
    const auto it = std::find(haystack.begin(), haystack.end(), std::complex{4.0, 2.0});
#endif
    assert(it == haystack.begin());  
}
 
int main()
{
    example_contains();
    example_predicate();
    example_list_init();
}

Ausgabe

haystack contains 3
haystack does not contain 5
haystack contains an even number 4
haystack does not contain even numbers

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 283	C++98	T musste EqualityComparable sein, aber der Werttyp von InputIt ist möglicherweise nicht T	Anforderung entfernt

Siehe auch

adjacent_find	Findet die ersten beiden benachbarten Elemente, die gleich sind (oder eine gegebene Bedingung erfüllen) (Funktionstempelat)
find_end	Findet die letzte Sequenz von Elementen in einem bestimmten Bereich (Funktionstempelat)
find_first_of	Sucht nach einem der Elemente aus einer Menge von Elementen (Funktionstempelat)
mismatch	Findet die erste Position, an der sich zwei Bereiche unterscheiden (Funktionstempelat)
search	Sucht nach dem ersten Vorkommen eines Elementbereichs (Funktionstempelat)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	Findet das erste Element, das bestimmte Kriterien erfüllt (Algorithmus-Funktionsobjekt)