std::adjacent_difference

template< class InputIt, class OutputIt >
OutputIt adjacent_difference( InputIt first, InputIt last,
                              OutputIt d_first );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2 >
ForwardIt2 adjacent_difference( ExecutionPolicy&& policy,
                                ForwardIt1 first, ForwardIt1 last,
                                ForwardIt2 d_first );

template< class InputIt, class OutputIt, class BinaryOp >
OutputIt adjacent_difference( InputIt first, InputIt last, 
                              OutputIt d_first, BinaryOp op );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2, class BinaryOp >
ForwardIt2 adjacent_difference( ExecutionPolicy&& policy,
                                ForwardIt1 first, ForwardIt1 last, 
                                ForwardIt2 d_first, BinaryOp op );

Sei T der Werttyp von decltype(first).

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

• Wenn eine der folgenden Bedingungen erfüllt ist, ist das Programm fehlerhaft:

• Für Überladungen (1,3):

• T ist nicht aus *first konstruierbar.
• acc ist nicht beschreibbar nach d_first.
• Das Ergebnis von binary_op(val, acc)(bis C++20)binary_op(val, std::move(acc))(seit C++20) ist nicht beschreibbar nach d_first.

• Für Überladungen (2,4):

• *first ist nicht beschreibbar nach d_first.
• Das Ergebnis von binary_op(*first, *first) ist nicht beschreibbar nach d_first.

• Gegeben d_last als der zurückzugebende Iterator, ist das Verhalten undefiniert, wenn eine der folgenden Bedingungen erfüllt ist:

• Für Überladungen (2,4) überschneiden sich [first, last) und [d_first, d_last).
• binary_op verändert jedes Element von [first, last) oder [d_first, d_last).
• binary_op macht jeden Iterator oder Teilbereich in [first, last] oder [d_first, d_last] ungültig.

Parameter

Rückgabewert

Iterator auf das Element hinter dem letzten geschriebenen Element, oder d_first, wenn [first, last) leer ist.

Komplexität

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

Ausnahmen

Die Überladungen mit einem Vorlagenparameter namens ExecutionPolicy melden Fehler wie folgt:

• Wenn die Ausführung einer im Rahmen des Algorithmus aufgerufenen Funktion eine Ausnahme auslöst und ExecutionPolicy eine der Standardstrategien ist, wird std::terminate aufgerufen. Für jedes andere ExecutionPolicy ist das Verhalten implementationsdefiniert.
• Wenn der Algorithmus keinen Speicher zuweisen kann, wird std::bad_alloc ausgelöst.

Mögliche Implementierung

template<class InputIt, class OutputIt>
constexpr // since C++20
OutputIt adjacent_difference(InputIt first, InputIt last, OutputIt d_first)
{
    if (first == last)
        return d_first;
    
    typedef typename std::iterator_traits<InputIt>::value_type value_t;
    value_t acc = *first;
    *d_first = acc;
    
    while (++first != last)
    {
        value_t val = *first;
        *++d_first = val - std::move(acc); // std::move since C++20
        acc = std::move(val);
    }
    
    return ++d_first;
}

template<class InputIt, class OutputIt, class BinaryOp>
constexpr // since C++20
OutputIt adjacent_difference(InputIt first, InputIt last, 
                             OutputIt d_first, BinaryOp op)
{
    if (first == last)
        return d_first;
    
    typedef typename std::iterator_traits<InputIt>::value_type value_t;
    value_t acc = *first;
    *d_first = acc;
    
    while (++first != last)
    {
        value_t val = *first;
        *++d_first = op(val, std::move(acc)); // std::move since C++20
        acc = std::move(val);
    }
    
    return ++d_first;
}

Anmerkungen

acc wurde aufgrund der Auflösung von LWG-Issue 539 eingeführt. Der Grund für die Verwendung von acc anstatt der direkten Berechnung der Differenzen ist, dass die Semantik der letzteren verwirrend ist, wenn die folgenden Typen nicht übereinstimmen:

• der Werttyp von InputIt
• die beschreibbaren Typen von OutputIt
• die Typen der Parameter von operator- oder op
• der Rückgabetyp von operator- oder op

acc dient als Zwischenobjekt zum Zwischenspeichern von Werten der iterierten Elemente:

• sein Typ ist der Werttyp von InputIt
• der in d_first geschriebene Wert (der Rückgabewert von operator- oder op) wird ihm zugewiesen
• sein Wert wird an operator- oder op

char i_array[4] = {100, 100, 100, 100};
int  o_array[4];
 
// OK: performs conversions when needed
// 1. creates “acc” of type char (the value type)
// 2. “acc” is assigned to the first element of “o_array”
// 3. the char arguments are used for long multiplication (char -> long)
// 4. the long product is assigned to the output range (long -> int)
// 5. the next value of “i_array” is assigned to “acc”
// 6. go back to step 3 to process the remaining elements in the input range
std::adjacent_difference(i_array, i_array + 4, o_array, std::multiplies<long>{});

übergeben

#include <array>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>

void println(auto comment, const auto& sequence)
{
    std::cout << comment;
    for (const auto& n : sequence)
        std::cout << n << ' ';
    std::cout << '\n';
};

int main()
{
    // Default implementation - the difference between two adjacent items
    std::vector v{4, 6, 9, 13, 18, 19, 19, 15, 10};
    println("Initially, v = ", v);
    std::adjacent_difference(v.begin(), v.end(), v.begin());
    println("Modified v = ", v);
    
    // Fibonacci
    std::array<int, 10> a {1};
    std::adjacent_difference(std::begin(a), std::prev(std::end(a)),
                             std::next(std::begin(a)), std::plus<>{});
    println("Fibonacci, a = ", a);
}

Initially, v = 4 6 9 13 18 19 19 15 10 
Modified v = 4 2 3 4 5 1 0 -4 -5 
Fibonacci, a = 1 1 2 3 5 8 13 21 34 55

Ausgabe:

Fehlerberichte

Siehe auch