Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::accumulate(3)	      C++ Standard Libary	    std::accumulate(3)

NAME
       std::accumulate - std::accumulate

Synopsis
	  Defined in header <numeric>
	  template< class InputIt, class T >
	  T  accumulate(  InputIt  first,  InputIt  last, T		(until
       C++20)
	  init );
	  template< class InputIt, class T >
	  constexpr T  accumulate(  InputIt  first,  InputIt		(since
       C++20)
	  last,	T init );
	  template< class InputIt, class T, class
	  BinaryOperation >

	  T    accumulate(    InputIt	first,	 InputIt   last,   T	   (1)
       (until C++20)
	  init,

	  BinaryOperation op );				       (2)
	  template< class InputIt, class T, class
	  BinaryOperation >

	  constexpr	T     accumulate(     InputIt	   first,      InputIt
       (since C++20)
	  last,	T init,

	  BinaryOperation op );

	  Computes  the	 sum  of  the given value init and the elements	in the
       range [first,
	  last). The first version uses	operator+ to sum up the	elements,  the
       second version
	  uses the given binary	function op
	  , both applying std::move to their operands on the left hand side
	  (since C++20).

	  op	     must	  not	      have	  side	      effects.
       (until C++11)
	  op must not invalidate any iterators,	including the  end  iterators,
       nor (since C++11)
	  modify any elements of the range involved, nor *last.

Parameters
	  first, last -	the range of elements to sum
	  init	      -	initial	value of the sum
			binary operation function object that will be applied.
       The binary
			operator  takes	the current accumulation value a (ini-
       tialized	to init)
			and the	value of the current element b.

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

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

			The signature does not need to have const &.
			The  type  Type1 must be such that an object of	type T
       can be implicitly
			converted to Type1. The	type Type2 must	be  such  that
       an object of type
			InputIt	 can  be dereferenced and then implicitly con-
       verted to Type2.
			The type Ret must be such that an object of type T can
       be assigned a
			value of type Ret.

Type requirements
	  -
	  InputIt must meet the	requirements of	LegacyInputIterator.
	  -
	  T  must  meet	 the  requirements  of	CopyAssignable	and   CopyCon-
       structible.

Return value
	  1) The sum of	the given value	and elements in	the given range.
	  2) The result	of left	fold of	the given range	over op

Notes
	  std::accumulate  performs  a	left fold. In order to perform a right
       fold, one must
	  reverse the order of the arguments to	the binary operator,  and  use
       reverse
	  iterators.

	   Common mistakes

	  If left to type inference, op	operates on values of the same type as
       init which can
	  result in unwanted casting of	the iterator elements. For example,
	  std::accumulate(v.begin(),  v.end(), 0) likely does not give the re-
       sult one	wishes
	  for when v is	std::vector<double>.

Possible implementation
First version
	  template<class InputIt, class	T>
	  constexpr // since C++20
	  T accumulate(InputIt first, InputIt last, T init)
	  {
	      for (; first != last; ++first) {
		  init = std::move(init) + *first; // std::move	since C++20
	      }
	      return init;
	  }

Second version
	  template<class InputIt, class	T, class BinaryOperation>
	  constexpr // since C++20
	  T accumulate(InputIt first, InputIt last, T init,
		       BinaryOperation op)
	  {
	      for (; first != last; ++first) {
		  init = op(std::move(init), *first); // std::move since C++20
	      }
	      return init;
	  }

Example
       // Run this code

	#include <iostream>
	#include <vector>
	#include <numeric>
	#include <string>
	#include <functional>

	int main()
	{
	    std::vector<int> v{1, 2, 3,	4, 5, 6, 7, 8, 9, 10};

	    int	sum = std::accumulate(v.begin(), v.end(), 0);

	    int	product	= std::accumulate(v.begin(), v.end(),  1,  std::multi-
       plies<int>());

	    auto dash_fold = [](std::string a, int b) {
				 return	     std::move(a)      +     '-'     +
       std::to_string(b);
			     };

	    std::string	s = std::accumulate(std::next(v.begin()), v.end(),
					    std::to_string(v[0]),   //	 start
       with first element
					    dash_fold);

	    // Right fold using	reverse	iterators
	    std::string	rs = std::accumulate(std::next(v.rbegin()), v.rend(),
					     std::to_string(v.back()),	    //
       start with last element
					     dash_fold);

	    std::cout << "sum: " << sum	<< '\n'
		      << "product: " <<	product	<< '\n'
		      << "dash-separated string: " << s	<< '\n'
		      << "dash-separated string	(right-folded):	 "  <<	rs  <<
       '\n';
	}

Output:
	sum: 55
	product: 3628800
	dash-separated string: 1-2-3-4-5-6-7-8-9-10
	dash-separated string (right-folded): 10-9-8-7-6-5-4-3-2-1

See also
	  adjacent_difference  computes	 the differences between adjacent ele-
       ments in	a range
			      (function	template)
	  inner_product	      computes the inner product of two	ranges of ele-
       ments
			      (function	template)
	  partial_sum	      computes the partial sum of a range of elements
			      (function	template)
	  reduce	      similar to std::accumulate, except out of	order
	  (C++17)	      (function	template)

http://cppreference.com		  2022.07.31		    std::accumulate(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::accumulate&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help