std:: transform_inclusive_scan

Die verallgemeinerte nichtkommutative Summe einer Folge von Elementen über eine binäre Operation binary_op ist wie folgt definiert:

• Wenn die Sequenz nur ein Element hat, ist die Summe der Wert des Elements.
• Andernfalls werden die folgenden Operationen in dieser Reihenfolge ausgeführt:

1. Wählt zwei beliebige benachbarte Elemente elem1 und elem2 aus der Sequenz aus.
2. Berechnet binary_op ( elem1, elem2 ) und ersetzt die beiden Elemente in der Sequenz mit dem Ergebnis.
3. Wiederholt Schritt 1 und 2, bis nur noch ein Element in der Sequenz vorhanden ist.

Das Ergebnis ist nicht-deterministisch, falls die binary_op nicht assoziativ ist (wie beispielsweise die Fließkomma-Addition).

Für Überladungen (1,2) , wenn binary_op ( unary_op ( * first ) , unary_op ( * first ) ) nicht konvertierbar zum Werttyp von decltype ( first ) ist, ist das Programm fehlerhaft.

Für Überladungen (3,4) , falls 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 Überladungen (1,2) ist der Werttyp von decltype ( first ) nicht MoveConstructible .
• Für Überladungen (3,4) ist T nicht MoveConstructible .
• unary_op oder binary_op modifiziert irgendein Element von [ first , last ) .
• unary_op oder binary_op invalidiert irgendeinen Iterator oder Teilbereich von [ first , last ] .

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