Namespaces
Variants

std:: partition_copy

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
partition_copy
(C++11)
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Definiert im Header <algorithm>
template < class InputIt, class OutputIt1,

class OutputIt2, class UnaryPred >
std:: pair < OutputIt1, OutputIt2 >
partition_copy ( InputIt first, InputIt last,
OutputIt1 d_first_true, OutputIt2 d_first_false,

UnaryPred p ) ;
(1) (seit C++11)
(constexpr seit C++20)
template < class ExecutionPolicy, class ForwardIt1, class ForwardIt2,

class ForwardIt3, class UnaryPred >
std:: pair < ForwardIt2, ForwardIt3 >
partition_copy ( ExecutionPolicy && policy,
ForwardIt1 first, ForwardIt1 last,
ForwardIt2 d_first_true, ForwardIt3 d_first_false,

UnaryPred p ) ;
(2) (seit C++17)
1) Kopiert die Elemente aus dem Bereich [ first , last ) in zwei verschiedene Bereiche, abhängig vom durch das Prädikat p zurückgegebenen Wert.
  • Die Elemente, die das Prädikat p erfüllen, werden in den bei d_first_true beginnenden Bereich kopiert.
  • Die restlichen Elemente werden in den bei d_first_false beginnenden Bereich kopiert.
2) Gleich wie (1) , aber ausgeführt gemäß policy .
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, 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)

Wenn * first nicht beschreibbar für d_first_true oder d_first_false ist, ist das Programm fehlerhaft.

Wenn sich unter dem Eingabebereich und den beiden Ausgabebereichen zwei Bereiche überlappen, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Parameter

first, last - das Iteratorpaar, das den Quell- Bereich der zu kopierenden Elemente definiert
d_first_true - der Anfang des Ausgabebereichs für die Elemente, die p erfüllen
d_first_false - der Anfang des Ausgabebereichs für die Elemente, die p nicht erfüllen
policy - die zu verwendende Ausführungsrichtlinie
p - unäres Prädikat, das ​ true zurückgibt, wenn das Element in d_first_true platziert werden soll.

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 VT & nicht zulässig , ebenso wenig wie VT , es sei denn, für VT ist eine Verschiebung äquivalent zu einer Kopie (seit C++11) . ​

Typanforderungen
-
InputIt muss die Anforderungen von LegacyInputIterator erfüllen.
-
OutputIt1, OutputIt2 muss die Anforderungen von LegacyOutputIterator erfüllen.
-
ForwardIt1, ForwardIt2, ForwardIt3 muss die Anforderungen von LegacyForwardIterator erfüllen.
-
UnaryPred muss die Anforderungen von Predicate erfüllen.

Rückgabewert

Ein std::pair konstruiert aus dem Iterator zum Ende des d_first_true -Bereichs und dem Iterator zum Ende des d_first_false -Bereichs.

Komplexität

Genau std:: distance ( first, last ) Anwendungen von p .

Für die Überladung (2) kann es zu Leistungseinbußen kommen, wenn ForwardIt 's Werttyp nicht CopyConstructible ist.

Ausnahmen

Die Überladung mit einem Template-Parameter namens ExecutionPolicy meldet 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

partition_copy (1) 
template<class InputIt, class OutputIt1,
         class OutputIt2, class UnaryPred>
constexpr //< seit C++20
std::pair<OutputIt1, OutputIt2>
    partition_copy(InputIt first, InputIt last,
                   OutputIt1 d_first_true, OutputIt2 d_first_false,
                   UnaryPred p)
{
    for (; first != last; ++first)
    {
        if (p(*first))
        {
            *d_first_true = *first;
            ++d_first_true;
        }
        else
        {
            *d_first_false = *first;
            ++d_first_false;
        }
    }
    return std::pair<OutputIt1, OutputIt2>(d_first_true, d_first_false);
}

Beispiel

Diesen Code ausführen 
#include <algorithm>
#include <iostream>
#include <utility>
void print(auto rem, const auto& v)
{
    for (std::cout << rem; const auto& x : v)
        std::cout << x << ' ';
    std::cout << '\n';
}
int main()
{
    int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int true_arr[5] = {0};
    int false_arr[5] = {0};
    std::partition_copy(std::begin(arr), std::end(arr),
                        std::begin(true_arr), std::begin(false_arr),
                        [](int i) { return 4 < i; });
    print("true_arr:  ", true_arr);
    print("false_arr: ", false_arr);
}

Ausgabe: 

true_arr:  5 6 7 8 9
false_arr: 0 1 2 3 4

Fehlerberichte

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

DR Angewendet auf Veröffentlichtes Verhalten Korrektes Verhalten
P0896R4 C++11
C++17 		1. der Werttyp von InputIt (C++11)/ ForwardIt1 (C++17)
musste CopyAssignable sein
2. die zwei Ausgabebereiche konnten sich überlappen 		1. nicht erforderlich
2. das Verhalten ist
in diesem Fall undefiniert

Siehe auch

unterteilt eine Reihe von Elementen in zwei Gruppen
(Funktions-Template)
unterteilt Elemente in zwei Gruppen unter Beibehaltung ihrer relativen Reihenfolge
(Funktions-Template)
(C++11)
kopiert eine Reihe von Elementen an einen neuen Speicherort
(Funktions-Template)
kopiert eine Reihe von Elementen unter Auslassung derjenigen, die bestimmte Kriterien erfüllen
(Funktions-Template)
(C++20)
kopiert eine Reihe und unterteilt die Elemente in zwei Gruppen
(Algorithmus-Funktionsobjekt)