数值算法之adjacent_difference

一、接口实现

功能：计算区间[first, end)中两个相邻元素的差值。

template<class _InIt,
	class _OutIt,
	class _Fn2,
	class _Ty> inline
	_OutIt _Adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func, _Ty *)
	{	// compute adjacent differences into _Dest, using _Func
	_Ty _Val = *_First;
	for (*_Dest = _Val; ++_First != _Last; )
		{	// compute another difference
		_Ty _Tmp = *_First;
		*++_Dest = _Func(_Tmp, _Val);
		_Val = _STD move(_Tmp);
		}
	return (++_Dest);
	}

 #if _ITERATOR_DEBUG_LEVEL == 0
template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_First == _Last ? _Dest
		: _Adjacent_difference(_Unchecked(_First), _Unchecked(_Last),
			_Dest, _Func, _Val_type(_First)));
	}

 #else /* _ITERATOR_DEBUG_LEVEL == 0 */
template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Adjacent_difference2(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func,
		input_iterator_tag, _Mutable_iterator_tag)
	{	// compute adjacent differences into _Dest, arbitrary iterators
	return (_Adjacent_difference(_First, _Last,
		_Dest, _Func, _Val_type(_First)));
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Adjacent_difference2(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func,
		random_access_iterator_tag, random_access_iterator_tag)
	{	// compute adjacent differences into _Dest, random-access iterators
	_OutIt _Ans = _Dest + (_Last - _First);	// also checks range
	_Adjacent_difference(_First, _Last,
		_Unchecked(_Dest), _Func, _Val_type(_First));
	return (_Ans);
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Adjacent_difference2(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func, true_type)
	{	// compute adjacent differences into _Dest, using _Func
	return (_Adjacent_difference2(_First, _Last,
		_Dest, _Func, _Iter_cat(_First), _Iter_cat(_Dest)));
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
_SCL_INSECURE_DEPRECATE
	_OutIt _Adjacent_difference2(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func, false_type)
	{	// compute adjacent differences into _Dest, using _Func
	return (_Adjacent_difference2(_First, _Last,
		_Dest, _Func, _Iter_cat(_First), _Iter_cat(_Dest)));
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Dest);
	_DEBUG_POINTER(_Func);
	return (_First == _Last ? _Dest
		: _Adjacent_difference2(_Unchecked(_First), _Unchecked(_Last),
			_Dest, _Func, _Is_checked(_Dest)));
	}

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt,
	class _OutTy,
	size_t _OutSize,
	class _Fn2> inline
	_OutTy *adjacent_difference(_InIt _First, _InIt _Last,
		_OutTy (&_Dest)[_OutSize], _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_Unchecked(
		_STD adjacent_difference(_First, _Last,
			_Array_iterator<_OutTy, _OutSize>(_Dest), _Func)));
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */
 #endif /* _ITERATOR_DEBUG_LEVEL == 0 */

		// TEMPLATE FUNCTION adjacent_difference
template<class _InIt,
	class _OutIt> inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest)
	{	// compute adjacent differences into _Dest
	return (_STD adjacent_difference(_First, _Last, _Dest,
		minus<>()));
	}

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt,
	class _OutTy,
	size_t _OutSize> inline
	_OutTy *adjacent_difference(_InIt _First, _InIt _Last,
		_OutTy (&_Dest)[_OutSize])
	{	// compute adjacent differences into _Dest
	return (_STD adjacent_difference(_First, _Last, _Dest,
		minus<>()));
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

二、使用

#include <numeric>
#include <vector>
#include <iostream>

using namespace std;

template<typename List>
void print_element(const List& list)
{
	for (const auto& it : list)
		cout << it << " ";
	cout << endl;
}

int main(int argc, char* argv[])
{
	vector<int> vecs{1, 2, 3, 4, 5, 6};

	vector<int> result(vecs.size());
	adjacent_difference(vecs.begin(), vecs.end(), result.begin());
	print_element(result);

	vector<int> result2(vecs.size());
	adjacent_difference(vecs.begin(), vecs.end(), result2.begin(), plus<int>());
	print_element(result2);

	return 0;
}

result：

分析：

1、adjacent_difference(vecs.begin(), vecs.end(), result.begin());

    1 --> result[0]，2-1 --> result[1]，3-2 --> result[2]，4-3 -- result[3]，5-4 -- result[4]，6-5 -- result[5]。

2、adjacent_difference(vecs.begin(), vecs.end(), result2.begin(), plus<int>());

    1 --> result[0]，2+1 --> result[1]，3+2 --> result[2]，4+3 -- result[3]，5+4 -- result[4]，6+5 -- result[5]。