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

From cppreference.net

**Anmerkungen zur Übersetzung:** - Nur der Text außerhalb der Code-Blöcke wurde übersetzt - "(since C++20)" wurde zu "(seit C++20)" übersetzt - Alle HTML-Tags, Attribute und C++-spezifischen Begriffe wurden unverändert belassen - Die Formatierung und Struktur des HTML-Codes wurde vollständig beibehalten (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags und Attribute leer sind. Gemäß den Anforderungen wurden keine HTML-Tags, Attribute oder spezifische C++-Begriffe übersetzt.)

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 > erfordert 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 > erfordert 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 der 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ürde.

3) Die binäre Operation binary_op wird auf Elementpaare aus zwei Bereichen angewendet: einem definiert durch

first1

last1

und dem anderen definiert durch

first2

last2

(nach jeweiliger 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ürde, und analog für r2 .

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

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 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

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

Inhaltsverzeichnis

Parameter

Rückgabewert

Komplexität

Mögliche Implementierung

Hinweise

Beispiel

Siehe auch