std::ranges:: copy, std::ranges:: copy_if, std::ranges:: copy_result, std::ranges:: copy_if_result

From cppreference.net

(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)

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 beginnend bei result .

1) Kopiert alle Elemente im Bereich

first

last

beginnend bei first und fortfahrend 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 den Wert true zurückgibt. Die relative Reihenfolge der kopierten Elemente bleibt erhalten. Das Verhalten ist undefiniert, wenn sich die Quell- und Zielbereiche überlappen.

2,4) Gleich wie (1,3) , verwendet jedoch 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 Algorithm Function Objects (informell bekannt als Niebloids ), das heißt:

Explizite Template-Argumentlisten können beim Aufruf keiner von ihnen angegeben werden.
Keiner von ihnen ist sichtbar für argument-dependent lookup .
Wenn einer von ihnen durch normal unqualified lookup als Name links vom Funktionsaufrufoperator gefunden wird, wird argument-dependent lookup unterdrückt.

Inhaltsverzeichnis

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 das einen Eingabe-Iterator gleich last und einen Ausgabe-Iterator hinter dem zuletzt kopierten Element enthält.

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 zurückgibt, abhängig von Prädikat und Eingabedaten).

Hinweise

In der Praxis vermeiden Implementierungen von ranges::copy mehrfache 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

Kopieren (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 den resultierenden std::vector anzuzeigen.

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

ranges::copy_backward (C++20)	kopiert einen Elementbereich in umgekehrter Reihenfolge (Algorithmus-Funktionsobjekt)
ranges::reverse_copy (C++20)	erstellt eine Kopie eines umgekehrten Bereichs (Algorithmus-Funktionsobjekt)
ranges::copy_n (C++20)	kopiert eine Anzahl von Elementen an einen neuen Speicherort (Algorithmus-Funktionsobjekt)
ranges::fill (C++20)	weist einem Elementbereich einen bestimmten Wert zu (Algorithmus-Funktionsobjekt)
ranges::remove_copy ranges::remove_copy_if (C++20) (C++20)	kopiert einen Elementbereich unter Auslassung bestimmter Kriterien (Algorithmus-Funktionsobjekt)
copy copy_if (C++11)	kopiert einen Elementbereich an einen neuen Speicherort (Funktionstemplate)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants