STL上的C ++ lambda函数机制累积

Question

I am learning new C++ 11 lambda features, how exactly is this code calculating the product of an array (doubles) using lambdas?

double product2 = accumulate(begin(doubles), end(doubles), 1.0,
    [](double partialresult, double d){return partialresult*d; });

I want to understand where the variables partialresult and d are coming from/going.

Answer 1

the specialization of std::accumulate for doubles, will have an implementation conceptually similar to the following (template arguments syntax removed for simplicity):

double accumulate(
    iterator_type begin, iterator_type end,
    double initial, functor_type f)
{
    double partialResult = initial;
    while(begin != end)
        partialResult = f(partialResult, *begin++);
    return partialResult;
}

Basically, the partial result is the intermediate result of the accumulation at each step. d will be the value pointed to by the iterator.

Answer 2

The old way of doing this was to make a class that overloaded operator() (known as functors or function objects)m, or use a free function to do it:

class product
{
public:

    double operator()(double a, double b) const
    {
        return a * b;
    }
};

or simply:

double product(double a, double b) { return a * b; }

Under the hood, lambdas are translated by the compiler to something like the form above:

class <implementation_defined_unique_name>
{
    // Implementation of operator() effectively as before
};

For understanding how accumulate works, looking at a possible implementation might help (from en.cppreference.com):

template<class InputIt, class T, class BinaryOperation>
T accumulate(InputIt first, InputIt last, T init, 
             BinaryOperation op)
{
    for (; first != last; ++first) {
        init = op(init, *first);
    }
    return init;
}

Here, it simply calls the supplied function, starting with the initial value and the first value in the sequence. It then stores this, and calls the function with the result of the first call as the first parameter, and the next value in the sequence as the second parameter, and so on.

Answer 3

That to understand how the algorithm works I advice to write yourself a code that calculates the product. It can look the following way

double doubles[] = { /* some initializers for the array */ };

double init = 1.0;

double acc = init;
for ( auto it = begin( doubles ); it != end( doubles ); ++it )
{
   acc = acc * *it;
} 

You can rewrite the code as a function

double accumulate( double *first, double *last, double init_value )
{
   double acc = init;

   for ( ; first != last; ++first )
   {
      acc = acc * *first;
   }

   return ( acc );
}  

The function call will look

accumulate( begin( doubles ), end( doubles ), 1.0 );

However the standard algorithm std::accumulate uses operator + instead of operator *. So if you need substitute operator + for operator * you could rewrite the function the following way

double accumulate( double *first, double *last, double init_value, std::multiplies<double> Op )
{
   double acc = init;

   for ( ; first != last; ++first )
   {
      acc = Op( acc, *first );
   }

   return ( acc );
}  

Instead of std::multiplies you could use any binary operation if the function would be defined as a template function. So further I will refer to the standard algorithm. You could write your original code as above that is using standard binary operation std::multiplies

double product2 = accumulate( begin( doubles ), end( doubles ), 1.0,
    multipliers<double>() );

As the function is a template function you can substitute std::multipliers for your lambda expression

double product2 = accumulate(begin(doubles), end(doubles), 1.0,
    [](double partialresult, double d){return partialresult*d; });

It can be written more clear if we assign the lambda expression a name

auto multipliers = [](double partialresult, double d){return partialresult*d; };

Whenthe call of the algorithm will look

double product2 = accumulate(begin(doubles), end(doubles), 1.0,
    multipliers() );

And inside its body instead of standard functional object std::multipliers operator function of your lambda expression will be called.