Namespaces
Variants

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

From 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://en.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 eine Reihe von Elementen an einen neuen Speicherort
(Funktions-Template)
kopiert eine Reihe von Elementen in umgekehrter Reihenfolge
(Funktions-Template)
erstellt eine Kopie eines Bereichs, der umgekehrt ist
(Funktions-Template)
kopiert eine Anzahl von Elementen an einen neuen Speicherort
(Funktions-Template)
weist einer Reihe von Elementen einen bestimmten Wert zu
(Funktions-Template)
kopiert eine Reihe von Elementen unter Auslassung derjenigen, die bestimmte Kriterien erfüllen
(Funktions-Template)