std::transform_inclusive_scan

template< class InputIt, class OutputIt,
          class BinaryOp, class UnaryOp >
OutputIt transform_inclusive_scan
    ( InputIt first, InputIt last, OutputIt d_first,
      BinaryOp binary_op, UnaryOp unary_op );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2,
          class BinaryOp, class UnaryOp >
ForwardIt2 transform_inclusive_scan
    ( ExecutionPolicy&& policy,
      ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
      BinaryOp binary_op, UnaryOp unary_op );

template< class InputIt, class OutputIt,
          class BinaryOp, class UnaryOp, class T >
OutputIt transform_inclusive_scan
    ( InputIt first, InputIt last, OutputIt d_first,
      BinaryOp binary_op, UnaryOp unary_op, T init );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2,
          class BinaryOp, class UnaryOp, class T >
ForwardIt2 transform_inclusive_scan
    ( ExecutionPolicy&& policy,
      ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
      BinaryOp binary_op, UnaryOp unary_op, T init );

Die verallgemeinerte nichtkommutative Summe einer Sequenz von Elementen bezüglich einer binären Operation binary_op ist wie folgt definiert:

• Hat die Sequenz nur ein Element, so ist die Summe der Wert des Elements.
• Andernfalls werden nacheinander die folgenden Operationen ausgeführt:

1. Wähle zwei beliebige benachbarte Elemente elem1 und elem2 aus der Sequenz.
2. Berechne binary_op(elem1, elem2) und ersetze die beiden Elemente in der Sequenz durch das Ergebnis.
3. Wiederhole die Schritte 1 und 2, bis nur noch ein Element in der Sequenz vorhanden ist.

Das Ergebnis ist nichtdeterministisch, wenn binary_op nicht assoziativ ist (z. B. Gleitkomma-Addition).

Für die Überladungen (1,2): Wenn binary_op(unary_op(*first), unary_op(*first)) nicht in den Werttyp von decltype(first) konvertierbar ist, ist das Programm fehlerhaft.

Für die Überladungen (3,4): Wenn einer der folgenden Werte nicht in T konvertierbar ist, ist das Programm fehlerhaft:

• binary_op(init, init)
• binary_op(init, unary_op(*first))
• binary_op(unary_op(*first), unary_op(*first))

Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:

• Für die Überladungen (1,2): Der Werttyp von decltype(first) ist nicht MoveConstructible.
• Für die Überladungen (3,4): T ist nicht MoveConstructible.
• unary_op oder binary_op modifiziert ein Element von [first, last).
• unary_op oder binary_op macht einen Iterator oder Teilbereich von [first, last] ungültig.

Parameter

Rückgabewert

Iterator auf das Element nach dem letzten geschriebenen Element.

Komplexität

Gegeben \(\scriptsize N\) N als std:: distance ( first, last ) :

Ausnahmen

Die Überladungen mit einem Template-Parameter namens ExecutionPolicy melden Fehler wie folgt:

• Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
• Wenn der Algorithmus keinen Speicher allozieren kann, wird std::bad_alloc geworfen.

Hinweise

unary_op wird niemals auf init angewendet.

Der Parameter init steht an letzter Stelle, anders als bei std::transform_exclusive_scan , da er für diese Funktion optional ist.

Beispiel

#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
    std::vector data{3, 1, 4, 1, 5, 9, 2, 6};
    auto times_10 = [](int x) { return x * 10; };
    std::cout << "10-fache exklusive Summe: ";
    std::transform_exclusive_scan(data.begin(), data.end(),
                                  std::ostream_iterator<int>(std::cout, " "),
                                  0, std::plus<int>{}, times_10);
    std::cout << "\n10-fache inklusive Summe: ";
    std::transform_inclusive_scan(data.begin(), data.end(),
                                  std::ostream_iterator<int>(std::cout, " "),
                                  std::plus<int>{}, times_10);
    std::cout << '\n';
}

10-fache exklusive Summe: 0 30 40 80 90 140 230 250 
10-fache inklusive Summe: 30 40 80 90 140 230 250 310

Siehe auch