adjacent_difference

Artigo
03/14/2013

Calcula as diferenças entre sucessivas cada elemento e seu antecessor em um intervalo de entrada e saída os resultados para um intervalo de destino ou calcula o resultado de um procedimento generalizado onde a operação da diferença é substituída por outra, operação binário especificada.

template<class InputIterator, class OutIterator>
   OutputIterator adjacent_difference(
      InputIterator _First, 
      InputIterator _Last,
      OutputIterator _Result 
   );

template<class InputIterator, class OutIterator, class BinaryOperation>
   OutputIterator adjacent_difference(
      InputIterator _First, 
      InputIterator _Last,
      OutputIterator _Result, 
      BinaryOperation _Binary_op
   );

Parâmetros

_First
Um iterador de entrada que trata o primeiro elemento no intervalo de entrada cujos elementos devem ser differenced com seus respectivos antecessores ou em onde os pares de valores deve ser operado sobre por outra operação binário especificada.
_Last
Um iterador de entrada que trata o último elemento no intervalo de entrada cujos elementos devem ser differenced com seus respectivos antecessores ou em onde os pares de valores deve ser operado sobre por outra operação binário especificada.
_Result
Um iterador de saída que trata o primeiro elemento um intervalo de destino onde a série de diferenças ou de resultados da operação especificada deve ser armazenada.
_Binary_op
A operação binário que deve ser aplicada a operação generalizada que substitui a operação de subtração no procedimento differencing.

Valor de retorno

Um iterador de saída que trata o final do intervalo de destino: _Result + (_Last - _First).

Comentários

O iterador de saída _Result é permitido iterador ser o mesmo que o iterador de entrada _First, para que adjacent_differences pode ser calculadas no lugar.

Para uma seqüência dos valores a1, a2, a3, em um intervalo de entrada, a primeira função do modelo armazena partial_differencesão s a1, a2- a1, a3 – a2, o intervalo de destino.

Para uma seqüência dos valores a1, a2, a3, em um intervalo de entrada, os segundos armazenamentos partial_differencesão s a1de função do modelo, a2_Binary_opa1, a3_Binary_opa2, o intervalo de destino.

A operação binário _Binary_op não é necessária ser ou associativa ou comutativo, porque a ordem das operações se aplica é especificado pelo.

adjacent_difference tem dois formulários relacionados:

Se você passar um iterador verificado para um dos formulários de adjacent_difference, você obtém o comportamento de iterador verificado. Se você passar um iterador não-verificada, você obtém o comportamento não-verificada.Para mais informações, consulte Iteradores selecionados.

Exemplo

// numeric_adj_diff.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <numeric>
#include <functional>
#include <iostream>

int main( ) 
{
   using namespace std;
   
   vector<int> V1( 10 ), V2( 10 );
   vector<int>::iterator VIter1, VIter2, VIterend, VIterend2;

   list <int> L1;
   list <int>::iterator LIter1, LIterend, LIterend2;

   int t;
   for ( t = 1 ; t <= 10 ; t++ )
   {
      L1.push_back( t * t );
   }

   cout << "The input list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != L1.end( ) ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;

   // The first member function for the adjacent_differences of
   // elements in a list output to a vector
   VIterend = adjacent_difference ( L1.begin ( ) , L1.end ( ) , 
      V1.begin ( ) );
   
   cout << "Output vector containing adjacent_differences is:\n ( " ;
   for ( VIter1 = V1.begin( ) ; VIter1 != VIterend ; VIter1++ )
      cout << *VIter1 << " ";
   cout << ")." << endl;

   // The second member function used to compute
   // the adjacent products of the elements in a list
   VIterend2 = adjacent_difference ( L1.begin ( ) , L1.end ( ) , V2.begin ( ) , 
      multiplies<int>( ) );
   
   cout << "The output vector with the adjacent products is:\n ( " ;
   for ( VIter2 = V2.begin( ) ; VIter2 != VIterend2 ; VIter2++ )
      cout << *VIter2 << " ";
   cout << ")." << endl;

   // Computation of adjacent_differences in place
   LIterend2 = adjacent_difference ( L1.begin ( ) , L1.end ( ) , L1.begin ( ) );
   cout << "In place output adjacent_differences in list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != LIterend2 ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;
}

Saída

The input list L1 is:
 ( 1 4 9 16 25 36 49 64 81 100 ).
Output vector containing adjacent_differences is:
 ( 1 3 5 7 9 11 13 15 17 19 ).
The output vector with the adjacent products is:
 ( 1 4 36 144 400 900 1764 3136 5184 8100 ).
In place output adjacent_differences in list L1 is:
 ( 1 3 5 7 9 11 13 15 17 19 ).

Requisitos

Cabeçalho: <numeric>

namespace: STD

Consulte também

Referência

adjacent_difference e vector::push_back

Standard Template Library

Partilhar via