std::ranges::copy, std::ranges::copy_if, std::ranges::copy_result, std::ranges::copy_if_result
Von de.cppreference.net
| Definiert in Header <algorithm>
|
||
| Aufrufsignatur |
||
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O >
requires std::indirectly_copyable<I, O>
constexpr copy_result<I, O>
copy( I first, S last, O result );
|
(1) | (seit C++20) |
template< ranges::input_range R, std::weakly_incrementable O >
requires std::indirectly_copyable<ranges::iterator_t<R>, O>
constexpr copy_result<ranges::borrowed_iterator_t<R>, O>
copy( R&& r, O result );
|
(2) | (seit C++20) |
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O,
class Proj = std::identity,
std::indirect_unary_predicate<std::projected<I, Proj>> Pred >
requires std::indirectly_copyable<I, O>
constexpr copy_if_result<I, O>
copy_if( I first, S last, O result, Pred pred, Proj proj = {} );
|
(3) | (seit C++20) |
template< ranges::input_range R, std::weakly_incrementable O,
class Proj = std::identity,
std::indirect_unary_predicate<
std::projected<ranges::iterator_t<R>, Proj>> Pred >
requires std::indirectly_copyable<ranges::iterator_t<R>, O>
constexpr copy_if_result<ranges::borrowed_iterator_t<R>, O>
copy_if( R&& r, O result, Pred pred, Proj proj = {} );
|
(4) | (seit C++20) |
| Hilfstypen |
||
template< class I, class O >
using copy_result = ranges::in_out_result<I, O>;
|
(5) | (seit C++20) |
template< class I, class O >
using copy_if_result = ranges::in_out_result<I, O>;
|
(6) | (seit C++20) |
Kopiert die Elemente im Bereich, definiert durch [first, last), in einen anderen Bereich, der bei result beginnt.
1) Kopiert alle Elemente im Bereich
[first, last) beginnend bei first bis last - 1. Das Verhalten ist undefiniert, wenn result innerhalb des Bereichs [first, last) liegt. In diesem Fall kann stattdessen ranges::copy_backward verwendet werden.3) Kopiert nur die Elemente, für die das Prädikat
pred true liefert. Die relative Reihenfolge der kopierten Elemente bleibt erhalten. Das Verhalten ist undefiniert, wenn sich Quell- und Zielbereich überschneiden.2,4) Wie (1,3), verwendet aber
r als Quellbereich, als ob ranges::begin(r) als first und ranges::end(r) als last verwendet würde.Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als Niebloide bekannt), das heißt:
- Explizite Vorlagenargumentlisten können nicht angegeben werden, wenn eine von ihnen aufgerufen wird.
- Keine von ihnen ist für argumentabhängige Namenssuche sichtbar.
- Wenn eine von ihnen durch normale unqualifizierte Namenssuche als Name links vom Funktionsaufrufoperator gefunden wird, wird argumentabhängige Namenssuche unterdrückt.
Parameter
| first, last | - | das Iterator-Sentinel-Paar, das den Bereich der zu kopierenden Elemente definiert |
| 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 ranges::in_out_result mit einem Eingabe-Iterator gleich last und einem Ausgabe-Iterator nach dem letzten kopierten Element.
Komplexität
1,2) Genau
last - first Zuweisungen.3,4) Genau
last - first Anwendungen des Prädikats und der Projektion, zwischen 0 und last - first Zuweisungen (Zuweisung für jedes Element, für das das Prädikat true liefert, abhängig vom Prädikat und den Eingabedaten).Anmerkungen
In der Praxis vermeiden Implementierungen von ranges::copy mehrere Zuweisungen und verwenden Massenkopierfunktionen wie std::memmove, wenn der Werttyp TriviallyCopyable ist und die Iteratortypen contiguous_iterator erfüllen.
Beim Kopieren überlappender Bereiche ist ranges::copy geeignet, wenn nach links kopiert wird (Anfang des Zielbereichs liegt außerhalb des Quellbereichs), während ranges::copy_backward geeignet ist, wenn nach rechts kopiert wird (Ende des Zielbereichs liegt außerhalb des Quellbereichs).
Mögliche Implementierung
| copy (1)(2) |
|---|
struct copy_fn
{
template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O>
requires std::indirectly_copyable<I, O>
constexpr ranges::copy_result<I, O> operator()(I first, S last, O result) const
{
for (; first != last; ++first, (void)++result)
*result = *first;
return {std::move(first), std::move(result)};
}
template<ranges::input_range R, std::weakly_incrementable O>
requires std::indirectly_copyable<ranges::iterator_t<R>, O>
constexpr ranges::copy_result<ranges::borrowed_iterator_t<R>, O>
operator()(R&& r, O result) const
{
return (*this)(ranges::begin(r), ranges::end(r), std::move(result));
}
};
inline constexpr copy_fn copy;
|
| copy_if (3)(4) |
struct copy_if_fn
{
template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O,
class Proj = std::identity,
std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
requires std::indirectly_copyable<I, O>
constexpr ranges::copy_if_result<I, O>
operator()(I first, S last, O result, Pred pred, Proj proj = {}) const
{
for (; first != last; ++first)
if (std::invoke(pred, std::invoke(proj, *first)))
{
*result = *first;
++result;
}
return {std::move(first), std::move(result)};
}
template<ranges::input_range R, std::weakly_incrementable O,
class Proj = std::identity,
std::indirect_unary_predicate<
std::projected<ranges::iterator_t<R>, Proj>> Pred>
requires std::indirectly_copyable<ranges::iterator_t<R>, O>
constexpr ranges::copy_if_result<ranges::borrowed_iterator_t<R>, O>
operator()(R&& r, O result, Pred pred, Proj proj = {}) const
{
return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
std::ref(pred), std::ref(proj));
}
};
inline constexpr copy_if_fn copy_if;
|
Beispiel
Der folgende Code verwendet ranges::copy, um sowohl den Inhalt eines std::vector in einen anderen zu kopieren als auch das resultierende std::vector anzuzeigen.
Diesen Code ausführen
#include <algorithm>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
std::vector<int> source(10);
std::iota(source.begin(), source.end(), 0);
std::vector<int> destination;
std::ranges::copy(source.begin(), source.end(), std::back_inserter(destination));
// or, alternatively,
// std::vector<int> destination(source.size());
// std::ranges::copy(source.begin(), source.end(), destination.begin());
// either way is equivalent to
// std::vector<int> destination = source;
std::cout << "Destination contains: ";
std::ranges::copy(destination, std::ostream_iterator<int>(std::cout, " "));
std::cout << '\n';
std::cout << "Odd numbers in destination are: ";
std::ranges::copy_if(destination, std::ostream_iterator<int>(std::cout, " "),
[](int x) { return (x % 2) == 1; });
std::cout << '\n';
}
Ausgabe:
Destination contains: 0 1 2 3 4 5 6 7 8 9
Odd numbers in destination are: 1 3 5 7 9
Siehe auch
(C++20) |
kopiert einen Bereich von Elementen in umgekehrter Reihenfolge (Algorithmus-Funktionsobjekt) |
(C++20) |
erzeugt eine umgekehrte Kopie eines Bereichs (Algorithmus-Funktionsobjekt) |
(C++20) |
kopiert eine bestimmte Anzahl von Elementen an eine neue Position (Algorithmus-Funktionsobjekt) |
(C++20) |
weist einem Bereich von Elementen einen bestimmten Wert zu (Algorithmus-Funktionsobjekt) |
(C++20)(C++20) |
kopiert einen Bereich von Elementen und lässt diejenigen aus, die bestimmte Kriterien erfüllen (Algorithmus-Funktionsobjekt) |
(C++11) |
kopiert einen Bereich von Elementen an eine neue Position (Funktionstemplate) |