Namespaces
Variants

    std::experimental::ranges:: copy, std::experimental::ranges:: copy_if

    From de.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    template < InputIterator I, Sentinel < I > S, WeaklyIncrementable O >

    erfordert IndirectlyCopyable < I, O >
    ranges:: tagged_pair < tag:: in ( I ) , tag:: out ( O ) >

    copy ( I first, S last, O result ) ;
    		(1) (ranges TS)
    template < InputRange R, WeaklyIncrementable O >

    erfordert IndirectlyCopyable < ranges:: iterator_t < R > , O >
    ranges:: tagged_pair < tag:: in ( ranges:: safe_iterator_t < R > ) , tag:: out ( O ) >

    copy ( R && r, O result ) ;
    		(2) (ranges TS)
    template < InputIterator I, Sentinel < I > S, WeaklyIncrementable O,

    class Proj = ranges:: identity ,
    IndirectUnaryPredicate < projected < I, Proj >> Pred >
    requires IndirectlyCopyable < I, O >
    ranges:: tagged_pair < tag:: in ( I ) , tag:: out ( O ) >

    copy_if ( I first, S last, O result, Pred pred, Proj proj = Proj { } ) ;
    		(3) (ranges TS)
    template < InputRange R, WeaklyIncrementable O,

    class Proj = ranges:: identity ,
    IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >
    requires IndirectlyCopyable < iterator_t < R > , O >
    ranges:: tagged_pair < tag:: in ( ranges:: safe_iterator_t < R > ) , tag:: out ( O ) >

    copy_if ( R && r, O result, Pred pred, Proj proj = Proj { } ) ;
    		(4) (ranges TS)

    Kopiert Elemente im Quellbereich ( [ first , last ) oder r ) in den Zielbereich beginnend bei result , startend vom ersten Element im Quellbereich und fortfahrend bis zum letzten.

    1) Kopiert alle Elemente im Bereich [ first , last ) . Für jede nicht-negative Ganzzahl n < (last - first) , führt * ( result + n ) = * ( first + n ) aus. Das Verhalten ist undefiniert, wenn result innerhalb des Bereichs [ first , last ) liegt. In diesem Fall kann stattdessen ranges::copy_backward verwendet werden.
    2) Gleich wie (1) , verwendet jedoch r als Quellbereich, als ob durch ranges:: copy ( ranges:: begin ( r ) , ranges:: end ( r ) , result ) ; außer dass result möglicherweise nicht kopiert wird.
    3) Kopiert nur die Elemente, für die das Prädikat pred den Wert true zurückgibt, wenn es auf den durch die Projektion proj projizierten Elementwert angewendet wird. Die Reihenfolge der kopierten Elemente bleibt erhalten. Das Verhalten ist undefiniert, wenn sich die Quell- und Zielbereiche überlappen.
    4) Gleich wie (3) , verwendet jedoch r als Quellbereich, als ob durch ranges:: copy_if ( ranges:: begin ( r ) , ranges:: end ( r ) , result, pred, proj ) ; außer dass result , pred und proj möglicherweise nicht kopiert werden dürfen.

    Ungeachtet der oben dargestellten Deklarationen sind die tatsächliche Anzahl und Reihenfolge der Template-Parameter für Algorithmusdeklarationen nicht spezifiziert. Daher ist das Programm wahrscheinlich nicht portabel, wenn explizite Template-Argumente beim Aufruf eines Algorithmus verwendet werden.

    Inhaltsverzeichnis

    Parameter

    first, last - der Bereich der zu kopierenden Elemente
    r - der Bereich der zu kopierenden Elemente
    result - der Anfang des Zielbereichs
    pred - Prädikat, das auf die projizierten Elemente angewendet wird
    proj - Projektion, die auf die Elemente angewendet wird

    Rückgabewert

    Ein tagged_pair -Objekt, das die folgenden zwei Elemente enthält:

    • Das erste Element, mit dem Tag tag::in , ist der Past-the-End-Iterator des Quellbereichs (also ein Iterator vom Typ I , der gleich dem Sentinel last ist).
    • Das zweite Element, mit dem Tag tag::out , ist der Past-the-End-Iterator des Ergebnisbereichs.

    Komplexität

    1) Genau ranges:: distance ( first, last ) Zuweisungen.
    2) Genau ranges:: distance ( r ) Zuweisungen.
    3) Exakt ranges:: distance ( first, last ) Anwendungen der entsprechenden Projektion und Prädikat.
    4) Genau ranges:: distance ( r ) Anwendungen der entsprechenden Projektion und des Prädikats.

    Mögliche Implementierungen

    Erste Version 
    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O>
    requires IndirectlyCopyable<I, O>()
ranges::tagged_pair<tag::in(I), tag::out(O)>
    copy(I first, S last, O result)
{
    for (; first != last; ++first, (void)++result)
        *result = *first;
    return {first, result};
}
    Zweite Version 
    template<InputRange R, WeaklyIncrementable O>
    requires IndirectlyCopyable<ranges::iterator_t<R>, O>()
ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>), tag::out(O)>
    copy(R&& r, O result)
{
   return ranges::copy(ranges::begin(r), ranges::end(r), result);
}
    Dritte Version 
    template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
         class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
    requires IndirectlyCopyable<I, O>()
ranges::tagged_pair<tag::in(I), tag::out(O)>
    copy_if(I first, S last, O result, Pred pred, Proj proj = Proj{})
{
    for (; first != last; ++first)
        if (ranges::invoke(pred, ranges::invoke(proj, *first)))
        {
            *result = *first;
            ++result;
        }
    return {first, result};
}
    Vierte Version 
    template<InputRange R, WeaklyIncrementable O,
         class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<ranges::iterator_t<R>, Proj>> Pred>
    requires IndirectlyCopyable<ranges::iterator_t<R>, O>()
ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>), tag::out(O)>
    copy_if(R&& r, O result, Pred pred, Proj proj = Proj{})
{
    return ranges::copy_if(ranges::begin(r), ranges::end(r), result, pred, proj);
}

    Beispiel

    Der folgende Code verwendet copy, um sowohl den Inhalt eines Vektors in einen anderen zu kopieren als auch den resultierenden Vektor anzuzeigen:

    Diesen Code ausführen 
    #include <experimental/ranges/algorithm>
#include <experimental/ranges/iterator>
#include <iostream>
#include <numeric>
#include <vector>
int main()
{
    // see https://de.cppreference.net/w/cpp/language/namespace_alias
    namespace ranges = std::experimental::ranges;
    std::vector<int> from_vector(10);
    std::iota(from_vector.begin(), from_vector.end(), 0);
    std::vector<int> to_vector;
    ranges::copy_if(from_vector.begin(), from_vector.end(),
                    ranges::back_inserter(to_vector),
                    [](const auto i)
                    {
                       return i % 3;
                    });
// or, alternatively,
//  std::vector<int> to_vector(from_vector.size());
//  std::copy(from_vector, to_vector.begin());
    std::cout << "to_vector contains: ";
    ranges::copy(to_vector, ranges::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
}

    Ausgabe: 

    to_vector contains: 1 2 4 5 7 8

    Siehe auch

    (C++11)
    		 kopiert einen Bereich von Elementen an einen neuen Speicherort
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)(C++20)
    		kopiert einen Bereich von Elementen in umgekehrter Reihenfolge
    (Funktionstemplate)
    		erstellt eine Kopie eines Bereichs, die umgekehrt ist
    (Funktionstemplate)
    		kopiert eine Anzahl von Elementen an einen neuen Speicherort
    (Funktionstemplate)
    		weist einem Bereich von Elementen einen bestimmten Wert zu
    (Funktionstemplate)
    		kopiert einen Bereich von Elementen und lässt diejenigen aus, die bestimmte Kriterien erfüllen
    (Funktionstemplate)