<algorithm>

Artikel
03/26/2013

Definiert Container-Vorlagenfunktionen der Standardvorlagenbibliothek (STL), die Algorithmen ausführen.

namespace std {
template<class InputIterator, class Predicate>
    bool all_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    bool any_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    bool none_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Function>
    Fn1 for_each (
        InputIterator _First, 
        InputIterator _Last, 
        Function _Func
    );
template<class InputIterator, class Type>
    InputIterator find (
        InputIterator _First, 
        InputIterator _Last, 
        const Type& _Val
    );
template<class InputIterator, class Predicate>
    InputIterator find_if (
        InputIterator _First, 
        InputIterator _Last, 
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    InputIterator find_if_not (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    ); 
template<class ForwardIterator1, class ForwardIterator2>
    ForwardIterator1 find_end (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2
    );
template<class ForwardIterator1, class ForwardIterator2, 
         class Predicate>
    ForwardIterator1 find_end (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2, 
        Predicate _Pred
    );
template<class InputIterator, class ForwardIterator>
    InputIterator1 find_first_of (
        InputIterator _First1, 
        InputIterator _Last1,
        ForwardIterator _First2, 
        ForwardIterator _Last2
    );
template<class InputIterator, class ForwardIterator, 
         class Predicate>
    InputIterator1 find_first_of (
        InputIterator _First1, 
        InputIterator _Last1,
        ForwardIterator _First2, 
        ForwardIterator _Last2, 
        Predicate _Pred
    );
template<class ForwardIterator>
    ForwardIterator adjacent_find (
        ForwardIterator _First, 
        ForwardIterator _Last
    );
template<class ForwardIterator, class Predicate>
    ForwardIterator adjacent_find (
        ForwardIterator _First, 
        ForwardIterator _Last, 
        Predicate _Pred
    );
template<class InputIterator, class Type>
    typename iterator_traits<InputIterator>::difference_type
        count (
            InputIterator _First, 
            InputIterator _Last,
            const Type& _Val
        );
template<class InputIterator, class Predicate>
    typename iterator_traits<InputIterator>::difference_type
        count_if (
            InputIterator _First, 
            InputIterator _Last,
            Predicate _Pred
        );
template<class InputIterator1, class InputIterator2>
    pair<InputIterator1, InputIterator2> 
        mismatch (
            InputIterator1 _First1, 
            InputIterator1 _Last1,
            InputIterator2 _First2
        );
template<class InputIterator1, class InputIterator2, class Predicate>
    pair<InputIterator1, InputIterator2> 
        mismatch (
            InputIterator1 _First1, 
            InputIterator1 _Last1,
            InputIterator2 _First2, 
            Predicate _Pred
        );
template<class InputIterator1, class InputIterator2>
    bool equal (
        InputIterator1 _First1, 
        InputIterator1 _Last1, 
        InputIterator2 _First2
    );
template<class InputIterator1, class InputIterator2, class Predicate>
    bool equal (
        InputIterator1 _First1, 
        InputIterator1 _Last1, 
        InputIterator2 _First2, 
        Predicate _Pred
    );
template<class ForwardIterator1, class ForwardIterator2>
    ForwardIterator1 search (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2
    );
template<class ForwardIterator1, class ForwardIterator2, 
         class Predicate>
    ForwardIterator1 search (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2, 
        Predicate _Pred
    );
template<class ForwardIterator, class Size, class Type>
    ForwardIterator search_n (
        ForwardIterator _First, 
        ForwardIterator _Last,
        Size _Count, 
        const Type& _Val
    );
template<class ForwardIterator, class Size, class Type, 
         class Predicate>
    ForwardIterator search_n (
        ForwardIterator _First, 
        ForwardIterator _Last,
        Size _Count, 
        const Type& _Val, 
        Predicate _Pred
    );

Hinweise

Die STL-Algorithmen sind generisch, da sie eine Vielzahl von Datenstrukturen ausgeführt werden können.Die Datenstrukturen, zu denen sie gehören ausgeführt werden können nicht nur die STL-Containerklassen wie vector und list, sondern auch Programm-definierte Datenstrukturen und Arrays Elemente, die den Anforderungen eines bestimmten Algorithmus erfüllen.STL-Algorithmen erzielen diese Ebene des Allgemeinen, indem sie indirekt auf die Elemente eines Containers durch Iteratoren zugreifen und durchlaufen.

STL-Algorithmen verarbeiten Iteratorbereiche, die normalerweise von ihren Start- oder Zielpositionen angegeben werden.Die Bereiche, die verwiesen wird, müssen im Sinne gültig sein, dass alle Zeiger in den Bereichen dereferenzierbar sein müssen und, innerhalb der Sequenzen jedes Bereichs, die letzte Position von der ersten durch Zunahme erreichbar sein muss.

Die STL-Algorithmen erweitern die Aktionen, die von der Vorgänge die Memberfunktionen und jedes STL-Containers unterstützt werden und ermöglichen Funktion beispielsweise mit verschiedenen Typen von Containerobjekten gleichzeitig.Zwei Suffixe sind verwendet, um Informationen über den Zweck der Algorithmen zu übergeben.

, wenn Suffix angibt, dass der Algorithmus mit den Funktionsobjekten verwendet wird, die für die Werte der Elemente statt für die Werte der Elemente selbst eignet.Der find_if Algorithmus sucht nach Elementen, deren Werte das Kriterium erfüllen, das von einem Funktionsobjekt angegeben wird, und der find Algorithmus sucht für einen bestimmten Wert.
Das _copy Suffix, gibt an, dass der Algorithmus nicht nur die Werte der Elemente verarbeitet, aber auch kopiert die geänderten Werte in einen Zielbereich.Der reverse Algorithmus gibt die Reihenfolge der Elemente in einem Bereich um, und der reverse_copy Algorithmus kopiert auch das Ergebnis in einen Zielbereich.

STL-Algorithmen werden häufig in Gruppen klassifiziert, die einige über ihren Zweck oder Anforderungen angeben.Diese schließen das Ändern von Algorithmen ein, die den Wert von Elementen verglichen mit nonmodifying Algorithmen ändern, die nicht.Ändernde Algorithmen kann die Reihenfolge von Elementen, jedoch nicht die Werte ihrer Elemente.Das Entfernen von Algorithmen kann Elemente aus einem Bereich oder einer Kopie eines Bereichs vermeiden.Sortieralgorithmen ordnen die Elemente in einem Bereich auf verschiedene Arten neu und sortierte Bereichsalgorithmen angewendet werden nur nach Algorithmen, deren Elemente auf bestimmte Weise sortiert wurden.

Die numerischen STL-Algorithmen, die für das numerische Verarbeitung bereitgestellt werden, verfügen über eigene Headerdatei <numeric>, und Funktionsobjekte und Adapter werden in den <functional>-Headerfunktionsobjekten definiert, die boolesche Werte zurückgeben, die als Prädikate bekannt sind.Das standardmäßige binäre Prädikat ist der Vergleich operator<.Im Allgemeinen, die Elemente, die bestellte Anforderung sind sind weniger als vergleichbar, damit, alle zwei Elemente angegeben, es jedem bestimmt werden kann, dass sie äquivalent sind (insofern, dass kein kleiner ist als die andere ist), oder dass ein kleiner als das andere ist.Dies ergibt eine Reihenfolge unter den antivalenten Elementen.

Funktionen

adjacent_find	Suchen von zwei angrenzenden Elemente, die entweder gleich sind oder eine bestimmte Bedingung erfüllen.
all_of	Gibt true zurück, wenn eine Bedingung an jedem Element im angegebenen Bereich vorhanden ist.
any_of	Gibt true zurück, wenn eine Bedingung mindestens einmal im angegebenen Bereich von Elementen vorhanden ist.
binary_search	Testet, ob ein Element in einem sortierten Bereich gibt, der gleich einem angegebenen Wert ist, oder, der darauf auf eine Weise entspricht, durch ein binäres Prädikat angegeben hat.
copy	Weist die Werte der Elemente eines Quellbereich zu einem Zielbereich zu, durchläuft die Quellfolge von gelöschte durch und ggf. weist ihnen neue Positionen zu.
copy_backward	Weist die Werte der Elemente eines Quellbereich zu einem Zielbereich zu, durchläuft die Quellfolge von - rückwärts durch und weist ihnen neue Positionen zu.
copy_if	Kopieren Sie alle Elemente in einem angegebenen Bereich, die true für eine angegebene Bedingung testen
copy_n	Kopiert eine angegebene Anzahl an Elementen.
count	Gibt die Anzahl der Elemente in einem Bereich zurück, dessen Werte einen angegebenen Wert übereinstimmen.
count_if	Gibt die Anzahl der Elemente in einem Bereich zurück, dessen Werte eine angegebene Bedingung übereinstimmen.
gleich	Vergleicht das Element mit zwei Bereichen durch Element entweder für die Gleichheit oder Äquivalenz auf eine Weise, die durch ein binäres Prädikat angegeben werden.
equal_range	Sucht ein Paar Positionen in einer geordneten Bereich, im ersten weniger als oder in der entsprechend der Position eines bestimmten Elements und der zweiten größeren als die Position des Elements, in der der Sinne möglicherweise der Äquivalenz oder der Reihenfolge, die verwendet werden, um die Positionen in der Sequenz festzulegen, durch ein binäres Prädikat angegeben wird.
fill	Weist den gleichen neuen Wert zu jedem Element in einem angegebenen Bereich zu.
fill_n	Weist einen neuen Wert auf eine angegebene Anzahl von Elementen in einem Bereich zu, der einem bestimmten Element beginnt.
find	Sucht die Position des ersten Vorkommens eines Elements in einem Bereich, der einen angegebenen Wert enthält.
find_end	Sucht in einem Bereich nach der letzten Untersequenz, die einer angegebenen Reihenfolge identisch ist, oder auf eine Weise angegeben durch ein binäres Prädikat entsprechendes ist.
find_first_of	Sucht das erste Vorkommen von einem mehrerer Werte innerhalb eines Zielbereichs oder für das erste Vorkommen von einem mehrerer Elemente, die auf eine Weise angegeben durch ein binäres Prädikat zu einem angegebenen Satz der Elemente entsprechendes sind.
find_if	Sucht die Position des ersten Vorkommens eines Elements in einem Bereich, der eine angegebene Bedingung erfüllt.
find_if_not	Gibt das erste Element im angegebenen Bereich zurück, der keine Bedingung erfüllt.
for_each	Wendet einen angegebenen Funktionsobjekt an jedes Element in einem Terminauftrag innerhalb eines Bereichs und gibt das Funktionsobjekt zurück.
generieren Sie	Weist die Werte, die durch ein Funktionsobjekt an jedes Element in einem Bereich generiert werden.
generate_n	Weist die Werte, die durch ein Funktionsobjekt an einer angegebenen Anzahl des Elements generiert werden, ist ein Bereich zurückgibt und der Position eine bestimmte Vergangenheit der letzte Wert.
enthält ein	Testet, ob ein sortierter Bereich alle Elemente enthält, die sofort enthalten sind, sortierte Bereich, in dem das Reihenfolge oder Äquivalenzkriterium möglicherweise zwischen Elementen durch ein binäres Prädikat angegeben wird.
inplace_merge	Kombiniert die Elemente von zwei aufeinander sortierten Bereiche in einen einzelnen sortierten Bereich, in dem das Sortierkriterium möglicherweise durch ein binäres Prädikat angegeben wird.
is_heap	Gibt true zurück, wenn die Elemente im angegebenen Bereich einen Heap bilden.
is_heap_until	Gibt true zurück, wenn der angegebene Bereich einen Heap bis das letzte Element bildet.
is_partitioned	Gibt true zurück, wenn alle Elemente im angegebenen Bereich, die true für eine Bedingung testen, vor allen Elementen stammen, die false testen.
is_sorted	Gibt true zurück, wenn die Elemente im angegebenen Bereich in sortierter Reihenfolge befinden.
is_sorted_until	Gibt true zurück, wenn die Elemente im angegebenen Bereich in sortierter Reihenfolge befinden.
iter_swap	Austausch zwei Werte sprachen durch ein Paar angegebene Iteratoren an.
lexicographical_compare	Vergleicht Element durch Element zwischen zwei Sequenzen, um zu bestimmen, das kleiner der zwei ist.
lower_bound	Sucht die Position des ersten Elements in einem geordneten Bereich, der einen Wert hat, der größer als oder Äquivalent zu einem angegebenen Wert angegeben wird, in dem Sortierkriterium möglicherweise durch ein binäres Prädikat.
make_checked_array_iterator	Erstellt checked_array_iterator, das von anderen Algorithmen verwendet werden kann.
make_heap	Konvertiert Elemente aus einem angegebenen Bereichs in einen Heap, in dem das erste Element das größte ist und, für die ein Sortierungskriterium möglicherweise mit einem binären Prädikat angegeben wird.
max	Vergleicht zwei Objekte und gibt das größere der beiden zurück, wobei Sortierkriterium möglicherweise durch ein binäres Prädikat angegeben wird.
max_element	Sucht das erste Vorkommen des größten Elements in einem angegebenen Bereich, in dem das Sortierkriterium möglicherweise durch ein binäres Prädikat angegeben wird.
zusammenführen	Führt alle Elemente aus zwei sortierten Quellbereichen in einem einzelnen, sortierten Zielbereich, in dem Sortierkriterium möglicherweise durch ein binäres Prädikat angegeben wird.
min	Vergleicht zwei Objekte und gibt die kleinere der beiden zurück, wobei Sortierkriterium möglicherweise durch ein binäres Prädikat angegeben wird.
min_element	Sucht das erste Vorkommen des kleinsten Elements in einem angegebenen Bereich, in dem das Sortierkriterium möglicherweise durch ein binäres Prädikat angegeben wird.
minmax	Vergleicht zwei Eingabeparameter und gibt sie als Paar, in der Reihenfolge weniger zu größtem zurück.
minmax_element	Führt die Aufgaben aus, die von min_element und max_element in einem Aufruf ausgeführt wird.
Konflikt	Vergleicht das Element mit zwei Bereichen durch Element entweder für die Gleichheit oder Entsprechung auf eine Weise, die durch ein binäres Prädikat angegeben werden und sucht die erste Position, in der ein Unterschied auftritt.
<alg> move	Verschiebungselemente zugeordnet mit einem angegebenen Bereich.
move_backward	Verschiebt die Elemente aus einem Iterator auf andere.Die Verschiebungsanfänge mit dem letzten Element in einem angegebenen Bereich und endet mit dem ersten Element in diesem Bereich.
next_permutation	Ordnet die Elemente in einem Bereich neu damit die ursprüngliche Reihenfolge durch die folgenden lexikografisch größere Permutation ersetzt wird, wenn vorhanden, wo der Sinne möglicherweise von als Nächstes mit einem binären Prädikat angegeben wird.
none_of	Gibt true zurück, wenn eine Bedingung nie mit Elementen im angegebenen Bereich vorhanden ist.
nth_element	Partitioniert einen Bereich von Elementen und ordnungsgemäß sucht das n-te-Element der Sequenz im Bereich, damit alle Elemente davor kleiner oder gleich ihn sind und alle Elemente, die Sie in der Sequenz folgen, sie größer oder gleich sind.
partial_sort	Ordnet eine angegebene Anzahl kleinerer Elemente in einem Bereich in eine nondescending Reihenfolge oder gemäß einem Sortierkriterium an, das durch ein binäres Prädikat angegeben wird.
partial_sort_copy	Kopiert Elemente aus einem Quellbereich in einen Zielbereich, in dem die Quellelemente entweder durch kleiner oder einem anderen angegebenen binäres Prädikat sortiert werden.
Partition	Klassifiziert Elemente in einem Bereich in zwei disjunkte Sätze, wenn diese Elemente ein unäres Prädikat erfüllen, das die vorausgeht, die es nicht erfüllen können.
partition_copy	Kopiert Elemente, für die eine Bedingung true zu einem Ziel ist, und, für die die Bedingung false zu anderen ist.Die Elemente müssen von einem angegebenen Bereich stammen.
partition_point	Gibt das erste Element im angegebenen Bereich zurück, der die Bedingung nicht erfüllt.Die Elemente werden sortiert, sodass die, die die Bedingung erfüllen, vor denen stammen, die nicht.
pop_heap	Entfernt das größte Element aus der Beginn eines Heaps der zweitletzten-Position im Bereich und bildet dann einen neuen Heap von den übrigen Elemente.
prev_permutation	Ordnet die Elemente in einem Bereich neu damit die ursprüngliche Reihenfolge durch die folgenden lexikografisch größere Permutation ersetzt wird, wenn vorhanden, wo der Sinne möglicherweise von als Nächstes mit einem binären Prädikat angegeben wird.
push_heap	Fügt ein Element hinzu, das am Ende eines Bereichs einen vorhandenen Heap ist, der aus früheren Elemente im Bereich besteht.
random_shuffle	Ordnet eine Sequenz von N-Elementen in einem Bereich in einen von N neu!mögliche Anordnungen zufällig ausgewählt.
remove	Eliminiert einen angegebenen Wert eines angegebenen Bereich, ohne die Reihenfolge der verbleibenden Elemente zu beeinträchtigen und das Ende eines neuen Bereichs zurückzugeben, der vom angegebenen Wert frei ist.
remove_copy	Kopiert Elemente aus einem Quellbereich zu einem Zielbereich, außer dass Elemente eines angegebenen Werts werden kopiert, nicht, ohne die Reihenfolge der verbleibenden Elemente zu beeinträchtigen und das Ende eines neuen Zielbereichs zurückzugeben.
remove_copy_if	Kopiert Elemente aus einem Quellbereich zu einem Zielbereich, außer dass, ein Prädikat zufrieden stellend, werden kopiert, nicht, ohne die Reihenfolge der verbleibenden Elemente zu beeinträchtigen und das Ende eines neuen Zielbereichs zurückzugeben.
remove_if	Eliminiert Elemente, die ein Prädikat aus einem angegebenen Bereich erfüllen, ohne die Reihenfolge der verbleibenden Elemente zu beeinträchtigen und das Ende eines neuen Bereichs zurückzugeben, der vom angegebenen Wert frei ist.
replace	Überprüft jedes Element in einem Bereich und ersetzt, sofern einen angegebenen Wert entspricht.
replace_copy	Überprüft jedes Element in einem Quellbereich und ersetzt, sofern einen angegebenen Wert beim Kopieren des Ergebnisses in einen neuen Zielbereich entspricht.
replace_copy_if	Überprüft jedes Element in einem Quellbereich und ersetzt, sofern ein angegebenes Prädikat beim Kopieren des Ergebnisses in einen neuen Zielbereich erfüllt.
replace_if	Überprüft jedes Element in einem Bereich und ersetzt, sofern ein angegebenes Prädikat erfüllt.
zurück	Gibt die Reihenfolge der Elemente in einem Bereich um.
reverse_copy	Gibt die Reihenfolge der Elemente innerhalb eines Quellbereichs beim Kopieren in einen Zielbereich um
Drehen	Tauscht die benachbarten Elementen in zwei Bereiche aus.
rotate_copy	Tauscht die Elemente in zwei angrenzenden Bereichen innerhalb eines Quellbereichs aus und kopiert das Ergebnis in einen Zielbereich.
Suche	Sucht das erste Vorkommen einer Sequenz innerhalb eines Zielbereichs, dessen Elemente gleich der in einer angegebenen Sequenz von Elementen sind, oder dessen Elemente auf eine Weise angegeben durch ein binäres Prädikat auf Elemente in der angegebenen Reihenfolge entsprechendes sind.
search_n	Suchen nach der erste Untersequenz in einem Bereich der aus einer angegebenen Anzahl von Elementen, die einen bestimmten Wert oder eine Beziehung zu diesem Wert haben, wie durch ein binäres Prädikat angegeben.
set_difference	Vereinigt alle Elemente, die einem sortierten Quellbereich gehören, jedoch nicht auf eine Sekunde sortierte Quellbereich, in ein einzelnes, sortierte Zielbereich, in dem Sortierkriterium möglicherweise durch ein binäres Prädikat angegeben wird.
set_intersection	Vereinigt alle Elemente, die beiden sortierten Quellbereichen in einen einzelnen gehören, sortierten Zielbereich, in dem Sortierkriterium möglicherweise durch ein binäres Prädikat angegeben wird.
set_symmetric_difference	Vereinigt alle Elemente, die einem gehören, jedoch nicht beide, der sortierten Quellbereiche in einem einzelnen, sortierten Zielbereich, in dem Sortierkriterium möglicherweise durch ein binäres Prädikat angegeben wird.
set_union	Vereinigt alle Elemente, die bis mindestens einen von zwei sortierten Quellbereichen in einen einzelnen gehören, sortierten Zielbereich, in dem Sortierkriterium möglicherweise durch ein binäres Prädikat angegeben wird.
sort	Ordnet die Elemente in einem angegebenen Bereich in eine nondescending Reihenfolge oder gemäß einem Sortierkriterium an, das durch ein binäres Prädikat angegeben wird.
sort_heap	Konvertiert einen Heap in einen sortierten Bereich.
stable_partition	Klassifiziert Elemente in einem Bereich in zwei disjunkte Sätze, wenn diese Elemente ein unäres Prädikat erfüllen, das die vorausgeht, die es nicht erfüllen können und behält die relative Reihenfolge der übereinstimmenden Elemente bei.
stable_sort	Ordnet die Elemente in einem angegebenen Bereich in eine nondescending Reihenfolge oder gemäß einem Sortierkriterium an, das durch ein binäres Prädikat angegeben ist und behält die relative Reihenfolge der übereinstimmenden Elemente bei.
Austausch	Tauscht die Werte der Elemente zwischen zwei Typen Objekte aus und weist den Inhalt des ersten Objekts bis des zweiten Objekts und den Inhalt des zweiten zum ersten zu.
swap_ranges	Tauscht die Elemente eines Bereichs mit den Elementen von anderen, - groß Bereich mit gleicher aus.
Transformation	Wendet einen angegebenen Funktionsobjekt an jedes Element in einem Quellbereich oder einem Paar von Elementen aus zwei Quellbereichen und kopiert die Rückgabewerte des Funktionsobjekts in einen Zielbereich.
unique	Entfernt doppelte Elemente, die neben einander in einem angegebenen Bereich sind.
unique_copy	Kopiert Elemente aus einem Quellbereich in einen Zielbereich außer doppelte Elemente, die nebeneinander angeordnet sind.
upper_bound	Sucht die Position des ersten Elements in einem geordneten Bereich, der hat einen Wert angegeben wird, der größer als ein angegebener Wert ist, in dem Sortierkriterium möglicherweise durch ein binäres Prädikat.

Siehe auch

Referenz

Threadsicherheit in der C++-Standardbibliothek

Standardvorlagenbibliothek

Weitere Ressourcen

Headerdateien

Freigeben über