.. _Lambda_Expressions:
Lambda Expressions
==================
C++11 lambda expressions make the |full_name|
``parallel_for`` much easier to use. A lambda expression lets
the compiler do the tedious work of creating a function object.
Below is the example from the previous section, rewritten with a lambda
expression. The lambda expression, replaces both the declaration and construction of function object ``ApplyFoo`` in the
example of the previous section.
::
#include "oneapi/tbb.h"
using namespace oneapi::tbb;
void ParallelApplyFoo( float* a, size_t n ) {
parallel_for( blocked_range<size_t>(0,n),
[=](const blocked_range<size_t>& r) {
for(size_t i=r.begin(); i!=r.end(); ++i)
Foo(a[i]);
}
);
}
The [=] introduces the lambda expression. The expression creates a
function object very similar to ``ApplyFoo``. When local variables like
``a`` and ``n`` are declared outside the lambda expression, but used
inside it, they are "captured" as fields inside the function object. The
[=] specifies that capture is by value. Writing [&] instead would
capture the values by reference. After the [=] is the parameter list and
definition for the ``operator()`` of the generated function object. The
compiler documentation says more about lambda expressions and other
implemented C++11 features. It is worth reading more complete
descriptions of lambda expressions than can fit here, because lambda
expressions are a powerful feature for using template libraries in
general.
C++11 support is off by default in the compiler. The following table
shows the option for turning it on.
.. container:: tablenoborder
.. list-table::
:header-rows: 1
* - Environment
- Intel® C++ Compiler Classic
- Intel® oneAPI DPC++/C++ Compiler
* - Windows\* OS systems
- \ ``icl /Qstd=c++11 foo.cpp``
- \ ``icx /Qstd=c++11 foo.cpp``
* - Linux\* OS systems
- \ ``icc -std=c++11 foo.cpp``
- \ ``icx -std=c++11 foo.cpp``
For further compactness, oneTBB has a form of ``parallel_for`` expressly
for parallel looping over a consecutive range of integers. The
expression ``parallel_for(first,last,step,f)`` is like writing
``for(auto i=first; i<last; i+=step)f(i)`` except that
each f(i) can be evaluated in parallel if resources permit. The ``step``
parameter is optional. Here is the previous example rewritten in the
compact form:
::
#include "oneapi/tbb.h"
using namespace oneapi::tbb;
#pragma warning(disable: 588)
void ParallelApplyFoo(float a[], size_t n) {
parallel_for(size_t(0), n, [=](size_t i) {Foo(a[i]);});
}
The compact form supports only unidimensional iteration spaces of
integers and the automatic chunking feature detailed on the following
section.
Generated by dwww version 1.15 on Sun Jun 16 07:22:58 CEST 2024.