Espaços nominais
Variantes
Acções

std::adjacent_difference

Da cppreference.com
< cpp‎ | algorithm

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

 
C++
 
Biblioteca algoritmo
Funções
Original:
Functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Não modificar operações de seqüência
Original:
Non-modifying sequence operations
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Modificando operações de seqüência
Original:
Modifying sequence operations
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Particionamento operações
Original:
Partitioning operations
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Operações de classificação (em intervalos ordenados)
Original:
Sorting operations (on sorted ranges)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Binários operações de busca (em intervalos ordenados)
Original:
Binary search operations (on sorted ranges)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Definir operações (em intervalos ordenados)
Original:
Set operations (on sorted ranges)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Operações de pilha
Original:
Heap operations
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Mínimo / máximo de operações
Original:
Minimum/maximum operations
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Operações numéricas
Original:
Numeric operations
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
adjacent_difference
C biblioteca
Original:
C library
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
 
Definido no cabeçalho <numeric>
template< class InputIt, class OutputIt >

OutputIt adjacent_difference( InputIt first, InputIt last,

                                    OutputIt d_first );
 (1)
template< class InputIt, class OutputIt, class BinaryOperation >

OutputIt adjacent_difference( InputIt first, InputIt last,
                                    OutputIt d_first,

                                    BinaryOperation op );
 (2)
Calcula as diferenças entre a segunda e a primeira de cada par adjacente de elementos da gama [first, last) e grava-os da gama de d_first + 1. Cópia sem modificações de first é escrito para d_first. A primeira versão utiliza operator- para calcular as diferenças, a segunda versão utiliza a função binária dada op.
Original:
Computes the differences between the second and the first of each adjacent pair of elements of the range [first, last) and writes them to the range beginning at d_first + 1. Unmodified copy of first is written to d_first. The first version uses operator- to calculate the differences, the second version uses the given binary function op.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Operação equivalente:
Original:
Equivalent operation:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
*(d_first)   = *first;
*(d_first+1) = (*first+1) - *(first);
*(d_first+2) = (*first+2) - *(first+1);
*(d_first+3) = (*first+3) - *(first+2);
...

Índice

[editar] Parâmetros

first, last -
o intervalo de elementos
Original:
the range of elements
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
d_first -
o início do intervalo de destino
Original:
the beginning of the destination range
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
op - binary operation function object that will be applied.

The signature of the function should be equivalent to the following:

 Ret fun(const Type1 &a, const Type2 &b);

The signature does not need to have const &.
The types  Type1 and  Type2 must be such that an object of type iterator_traits<InputIt>::value_type can be implicitly converted to both of them. The type  Ret must be such that an object of type OutputIt can be dereferenced and assigned a value of type  Ret. ​

Type requirements
-
InputIt must meet the requirements of InputIterator.
-
OutputIt must meet the requirements of OutputIterator.

[editar] Valor de retorno

Ao elemento passado o último elemento escrito.
Original:
It to the element past the last element written.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Complexidade

Exatamente (last - first) - 1 aplicações da operação binária
Original:
Exactly (last - first) - 1 applications of the binary operation
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Possível implementação

First version 
template<class InputIt, class OutputIt>
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 - acc;
        acc = std::move(val);
    }
    return ++d_first;
}
Second version 
template<class InputIt, class T, class BinaryOperation>
OutputIt adjacent_difference(InputIt first, InputIt last, 
                             OutputIt d_first, BinaryOperation 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, acc);
        acc = std::move(val);
    }
    return ++d_first;
}

[editar] Exemplo

O código a seguir converte uma seqüência de números pares de repetições do número 2 e converte uma seqüência de uns a uma seqüência de números de Fibonacci .
Original:
The following code converts a sequence of even numbers to repetitions of the number 2 and converts a sequence of ones to a sequence of Fibonacci numbers.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

​#include <numeric>
#include <vector>
#include <iostream>
#include <functional>
int main()
{
    std::vector<int> v{2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
    std::adjacent_difference(v.begin(), v.end(), v.begin());
 
    for(auto n: v) {
        std::cout << n << ' ';
    }
    std::cout << '\n';
 
    v = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
    std::adjacent_difference(v.begin(), v.end()-1, v.begin()+1, std::plus<int>()
 
    for(auto n: v) {
        std::cout << n << ' ';
    }
    std::cout << '\n';
}​

Saída: 

2 2 2 2 2 2 2 2 2 2
1 1 2 3 5 8 13 21 34 55

[editar] Veja também
calcula a soma parcial de um conjunto de elementos
Original:
computes the partial sum of a range of elements
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(modelo de função) [edit]
resume uma série de elementos
Original:
sums up a range of elements
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(modelo de função) [edit]
Obtida de "https://pt.cppreference.com/mwiki/index.php?title=cpp/algorithm/adjacent_difference&oldid=19902"