std:: 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.

Gegeben binary_op als die tatsächliche binäre Operation:

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

• Für Überladungen (1-4) , falls binary_op ( * first, * first ) nicht konvertierbar zum value type von decltype ( first ) ist, ist das Programm fehlerhaft.

• Für Überladungen (5,6) , falls einer der folgenden Werte nicht in T konvertierbar ist, ist das Programm fehlerhaft:

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

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

• Für Überladungen (1-4) ist der Werttyp von decltype ( first ) nicht MoveConstructible .
• Für Überladungen (5,6) ist T nicht MoveConstructible .
• binary_op modifiziert irgendein Element von [ first , last ) .
• binary_op macht irgendeinen 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.

Beispiel

#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
    std::vector data{3, 1, 4, 1, 5, 9, 2, 6};
    std::cout << "Exclusive sum: ";
    std::exclusive_scan(data.begin(), data.end(),
                        std::ostream_iterator<int>(std::cout, " "),
                        0);
    std::cout << "\nInclusive sum: ";
    std::inclusive_scan(data.begin(), data.end(),
                        std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\n\nExclusive product: ";
    std::exclusive_scan(data.begin(), data.end(),
                        std::ostream_iterator<int>(std::cout, " "),
                        1, std::multiplies<>{});
    std::cout << "\nInclusive product: ";
    std::inclusive_scan(data.begin(), data.end(),
                        std::ostream_iterator<int>(std::cout, " "),
                        std::multiplies<>{});
}

Exclusive sum: 0 3 4 8 9 14 23 25
Inclusive sum: 3 4 8 9 14 23 25 31
Exclusive product: 1 3 3 12 12 60 540 1080
Inclusive product: 3 3 12 12 60 540 1080 6480

Siehe auch