std::ranges::transform, std::ranges::unary_transform_result, std::ranges::binary_transform_result

Definiert in Header `<algorithm>`
Aufrufsignatur
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, std::copy_constructible F, class Proj = std::identity > requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<I, Proj>>> constexpr unary_transform_result<I, O> transform( I first1, S last1, O result, F op, Proj proj = {} );	(1)	(seit C++20)
template< ranges::input_range R, std::weakly_incrementable O, std::copy_constructible F, class Proj = std::identity > requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<ranges::iterator_t<R>, Proj>>> constexpr unary_transform_result<ranges::borrowed_iterator_t<R>, O> transform( R&& r, O result, F op, Proj proj = {} );	(2)	(seit C++20)
template< std::input_iterator I1, std::sentinel_for<I1> S1, std::input_iterator I2, std::sentinel_for<I2> S2, std::weakly_incrementable O, std::copy_constructible F, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<I1, Proj1>, std::projected<I2, Proj2>>> constexpr binary_transform_result<I1, I2, O> transform( I1 first1, S1 last1, I2 first2, S2 last2, O result, F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {} );	(3)	(seit C++20)
template< ranges::input_range R1, ranges::input_range R2, std::weakly_incrementable O, std::copy_constructible F, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<ranges::iterator_t<R1>, Proj1>, std::projected<ranges::iterator_t<R2>, Proj2>>> constexpr binary_transform_result<ranges::borrowed_iterator_t<R1>, ranges::borrowed_iterator_t<R2>, O> transform( R1&& r1, R2&& r2, O result, F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {} );	(4)	(seit C++20)
Hilfstypen
template< class I, class O > using unary_transform_result = ranges::in_out_result<I, O>;	(5)	(seit C++20)
template< class I1, class I2, class O > using binary_transform_result = ranges::in_in_out_result<I1, I2, O>;	(6)	(seit C++20)

Wendet die gegebene Funktion auf einen Bereich an und speichert das Ergebnis in einem anderen Bereich, beginnend bei result.

1) Die unäre Operation op wird auf den durch [first1, last1) definierten Bereich angewendet (nach Projektion mit der Projektion proj).

2) Gleich wie (1), verwendet jedoch r als Quellbereich, als ob ranges::begin(r) als first und ranges::end(r) als last verwendet würden.

3) Die binäre Operation binary_op wird auf Paare von Elementen aus zwei Bereichen angewendet: einen definiert durch [first1, last1) und den anderen definiert durch [first2, last2) (jeweils nach Projektion mit den Projektionen proj1 und proj2).

4) Gleich wie (3), verwendet jedoch r1 als ersten Quellbereich, als ob ranges::begin(r1) als first1 und ranges::end(r1) als last1 verwendet würden, und ebenso für r2.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell bekannt als Niebloids), das heißt:

Explizite Vorlagenargumentlisten können beim Aufruf einer von ihnen nicht angegeben werden.
Keine von ihnen ist für argumentabhängige Suche sichtbar.
Wenn eine von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird argumentabhängige Suche unterdrückt.

Parameter

first1, last1	-	das Iterator-Sentinel-Paar, das den ersten Bereich der zu transformierenden Elemente definiert
r, r1	-	der erste Bereich der zu transformierenden Elemente
first2, last2	-	das Iterator-Sentinel-Paar, das den zweiten Bereich der zu transformierenden Elemente definiert
r2	-	der zweite Bereich der zu transformierenden Elemente
result	-	der Anfang des Zielbereichs, kann gleich first1 oder first2 sein
op, binary_op	-	Operation, die auf die projizierten Element(e) angewendet wird
proj1	-	Projektion, die auf die Elemente im ersten Bereich angewendet wird
proj2	-	Projektion, die auf die Elemente im zweiten Bereich angewendet wird

Rückgabewert

1,2) Ein


        unary_transform_result

enthält einen Eingabeiterator gleich last und einen Ausgabeiterator auf das Element nach dem letzten transformierten Element.

3,4) Ein


        binary_transform_result

enthält Eingabeiteratoren zu den letzten transformierten Elementen aus den Bereichen

first1

last1

und

first2

last2

als

in1

bzw.

in2

, und den Ausgabeiterator zum Element nach dem letzten transformierten Element als

out

.

Komplexität

1,2) Exakt ranges:: distance ( first1, last1 ) Anwendungen von op und proj .

3,4) Genau ranges:: min ( ranges:: distance ( first1, last1 ) , ranges:: distance ( first2, last2 ) ) Anwendungen von binary_op und Projektionen.

Mögliche Implementierung

struct transform_fn
{
    // Erste Version
    template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O,
             std::copy_constructible F, class Proj = std::identity>
    requires std::indirectly_writable<O, std::indirect_result_t<F&,
                                                                std::projected<I, Proj>>>
    constexpr ranges::unary_transform_result<I, O>
        operator()(I first1, S last1, O result, F op, Proj proj = {}) const
    {
        for (; first1 != last1; ++first1, (void)++result)
            *result = std::invoke(op, std::invoke(proj, *first1));
        return {std::move(first1), std::move(result)};
    }
    // Zweite Version
    template<ranges::input_range R, std::weakly_incrementable O,
             std::copy_constructible F, class Proj = std::identity>
    requires std::indirectly_writable<O,
                 std::indirect_result_t<F&, std::projected<ranges::iterator_t<R>, Proj>>>
    constexpr ranges::unary_transform_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result, F op, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
                       std::move(op), std::move(proj));
    }
    // Dritte Version
    template<std::input_iterator I1, std::sentinel_for<I1> S1,
             std::input_iterator I2, std::sentinel_for<I2> S2,
             std::weakly_incrementable O,
             std::copy_constructible F,
             class Proj1 = std::identity, class Proj2 = std::identity>
    requires std::indirectly_writable<O,
                 std::indirect_result_t<F&,
                                        std::projected<I1, Proj1>,
                                        std::projected<I2, Proj2>>>
    constexpr ranges::binary_transform_result<I1, I2, O>
        operator()(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                   F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        for (; first1 != last1 && first2 != last2;
             ++first1, (void)++first2, (void)++result)
            *result = std::invoke(binary_op,
                                  std::invoke(proj1, *first1),
                                  std::invoke(proj2, *first2));
        return {std::move(first1), std::move(first2), std::move(result)};
    }
    // Vierte Version
    template<ranges::input_range R1, ranges::input_range R2,
             std::weakly_incrementable O, std::copy_constructible F,
             class Proj1 = std::identity, class Proj2 = std::identity>
    requires std::indirectly_writable<O,
                 std::indirect_result_t<F&,
                     std::projected<ranges::iterator_t<R1>, Proj1>,
                     std::projected<ranges::iterator_t<R2>, Proj2>>>
    constexpr ranges::binary_transform_result<ranges::borrowed_iterator_t<R1>,
                                              ranges::borrowed_iterator_t<R2>, O>
        operator()(R1&& r1, R2&& r2, O result,
                   F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        return (*this)(ranges::begin(r1), ranges::end(r1),
                       ranges::begin(r2), ranges::end(r2),
                       std::move(result), std::move(binary_op),
                       std::move(proj1), std::move(proj2));
    }
};
inline constexpr transform_fn transform;

Hinweise

ranges::transform garantiert keine geordnete Anwendung von op oder binary_op . Um eine Funktion in geordneter Reihenfolge auf eine Sequenz anzuwenden oder eine Funktion zu verwenden, die die Elemente einer Sequenz modifiziert, verwenden Sie ranges::for_each .

Beispiel

Der folgende Code verwendet ranges::transform , um einen String direkt in Großbuchstaben umzuwandeln, unter Verwendung der std::toupper -Funktion, und transformiert dann jedes char in seinen Ordinalwert. Dann wird ranges::transform mit einer Projektion verwendet, um Elemente von std:: vector < Foo > in Zeichen umzuwandeln, um einen std::string zu füllen.

Code ausführen

#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
int main()
{
    std::string s{"hello"};
    auto op = [](unsigned char c) -> unsigned char { return std::toupper(c); };
    namespace ranges = std::ranges;
    // den String direkt in Großbuchstaben umwandeln
    ranges::transform(s.begin(), s.end(), s.begin(), op );
    std::vector<std::size_t> ordinals;
    // jedes char in size_t umwandeln
    ranges::transform(s, std::back_inserter(ordinals),
                      [](unsigned char c) -> std::size_t { return c; });
    std::cout << s << ':';
    for (auto ord : ordinals)
        std::cout << ' ' << ord;
    // jeden Ordinalwert verdoppeln
    ranges::transform(ordinals, ordinals, ordinals.begin(), std::plus{});
    std::cout << '\n';
    for (auto ord : ordinals)
        std::cout << ord << ' ';
    std::cout << '\n';
    struct Foo { char bar; };
    const std::vector<Foo> f = {{'h'},{'e'},{'l'},{'l'},{'o'}};
    std::string result;
    // projizieren, dann in Großbuchstaben umwandeln
    ranges::transform(f, std::back_inserter(result), op, &Foo::bar);
    std::cout << result << '\n';
}

Ausgabe:

HELLO: 72 69 76 76 79
144 138 152 152 158
HELLO

Siehe auch

ranges::for_each (C++20)	wendet ein unäres Funktionsobjekt auf Elemente aus einem Bereich an (Algorithmus-Funktionsobjekt)
ranges::transform_view views::transform (C++20)	eine `view` einer Sequenz, die eine Transformationsfunktion auf jedes Element anwendet (Klassentemplate) (Bereichsadapterobjekt)
transform	wendet eine Funktion auf einen Elementbereich an und speichert Ergebnisse in einem Zielbereich (Funktionstemplate)

Compiler-Unterstützung
Freistehend und gehostet
Sprache
Standardbibliothek
Standardbibliothek-Header
Benannte Anforderungen
Feature-Test-Makros (C++20)
Sprachunterstützungsbibliothek
Konzeptbibliothek (C++20)
Diagnosebibliothek
Speicherverwaltungsbibliothek
Metaprogrammierungsbibliothek (C++11)
Allgemeine Dienstprogrammbibliothek
Containerbibliothek
Iteratorenbibliothek
Bereichsbibliothek (C++20)
Algorithmenbibliothek
Zeichenkettenbibliothek
Textverarbeitungsbibliothek
Numerikbibliothek
Datums- und Zeitbibliothek
Ein-/Ausgabebibliothek
Dateisystembibliothek (C++17)
Nebenläufigkeitsunterstützungsbibliothek (C++11)
Ausführungssteuerungsbibliothek (C++26)
Technische Spezifikationen
Symbolverzeichnis
Externe Bibliotheken

de.cppreference.net

Namespaces

Variants