C++ AMP: Lambda表达式的示例

// declaring_lambda_expressions1.cpp
#include <functional>
int main()
{
// Assign the lambda expression that adds two numbers to an auto variable.
auto f1 = [] (int x, int y) { return x + y; };
// Assign the same lambda expression to a function object.
function<int (int, int)> f2 = [] (int x, int y) { return x + y; };
}

// declaring_lambda_expressions2.cpp
// compile with: /EHsc
#include <iostream>
#include <functional>
int main()
{
using namespace std;
int i = 3;
int j = 5;
// The following lambda expression captures i by value and
// j by reference.
function<int (void)> f = [i, &j] { return i + j; };
// Change the values of i and j.
i = 22;
j = 44;
// Call f and print its result.
cout << f() << endl;
}

47

// calling_lambda_expressions1.cpp
// compile with: /EHsc
#include <iostream>
int main()
{
using namespace std;
int n = [] (int x, int y) { return x + y; }(5, 4);
cout << n << endl;
}

9

// calling_lambda_expressions2.cpp
// compile with: /EHsc
#include <list>
#include <algorithm>
#include <iostream>
int main()
{
using namespace std;
// Create a list of integers with a few initial elements.
list<int> numbers;
numbers.push_back(13);
numbers.push_back(17);
numbers.push_back(42);
numbers.push_back(46);
numbers.push_back(99);
// Use the find_if function and a lambda expression to find the
// first even number in the list.
const list<int>::const_iterator result =
find_if(numbers.begin(), numbers.end(),
[](int n) { return (n % 2) == 0; });
// Print the result.
if (result != numbers.end())
{
cout << "The first even number in the list is "
<< (*result)
<< "."
<< endl;
}
else
{
cout << "The list contains no even numbers."
<< endl;
}
}

The first even number in the list is 42.

// calling_lambda_expressions3.cpp
// compile with: /EHsc
#include <iostream>
int main()
{
using namespace std;
// Assign the lambda expression that adds two numbers to an
// auto variable.
auto f = [] (int x, int y) { return x + y; };
// Invoke the function object and print its result.
cout << f(21, 12) << endl;
}

33

// nesting_lambda_expressions.cpp
// compile with: /EHsc
#include <iostream>
int main()
{
using namespace std;
// The following lambda expression contains a nested lambda
// expression.
int m = [](int x)
{ return [](int y) { return y * 2; }(x) + 3; }(5);
// Print the result.
cout << m << endl;
}

13

// higher_order_lambda_expression.cpp
// compile with: /EHsc
#include <iostream>
#include <functional>
int main()
{
using namespace std;
// The following code declares a lambda expression that returns
// another lambda expression that adds two numbers.
// The returned lambda expression captures parameter x by value.
auto g = [](int x) -> function<int (int)>
{ return [=](int y) { return x + y; }; };
// The following code declares a lambda expression that takes another
// lambda expression as its argument.
// The lambda expression applies the argument z to the function f
// and adds 1.
auto h = [](const function<int (int)>& f, int z)
{ return f(z) + 1; };
// Call the lambda expression that is bound to h.
auto a = h(g(7), 8);
// Print the result.
cout << a << endl;
}

16

// method_lambda_expression.cpp
// compile with: /EHsc
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
class Scale
{
public:
// The constructor.
explicit Scale(int scale)
: _scale(scale)
{
}
// Prints the product of each element in a vector object
// and the scale value to the console.
void ApplyScale(const vector<int>& v) const
{
for_each(v.begin(), v.end(),
[this](int n) { cout << n * _scale << endl; });
}
private:
int _scale;
};
int main()
{
vector<int> values;
values.push_back(3);
values.push_back(6);
values.push_back(9);
// Create a Scale object that scales elements by 3 and apply
// it to the vector object.
Scale s(3);
s.ApplyScale(values);
}

9
18
27

void ApplyScale(const vector<int>& v) const
{
for_each(v.begin(), v.end(),
[this](int n) { cout << n * this->_scale << endl; });
}

void ApplyScale(const vector<int>& v) const
{
for_each(v.begin(), v.end(),
[=](int n) { cout << n * _scale << endl; });
}

// template_lambda_expression.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
// Negates each element in the vector object.
template <typename T>
void negate_all(vector<T>& v)
{
for_each(v.begin(), v.end(), [] (T& n) { n = -n; } );
}
// Prints to the console each element in the vector object.
template <typename T>
void print_all(const vector<T>& v)
{
for_each(v.begin(), v.end(), [] (const T& n) { cout << n << endl; } );
}
int main()
{
// Create a vector of integers with a few initial elements.
vector<int> v;
v.push_back(34);
v.push_back(-43);
v.push_back(56);
// Negate each element in the vector.
negate_all(v);
// Print each element in the vector.
print_all(v);
}

-34
43
-56

// eh_lambda_expression.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
int main()
{
// Create a vector that contains 3 elements.
vector<int> elements(3);
// Create another vector that contains index values.
vector<int> indices(3);
indices[0] = 0;
indices[1] = -1; // This is not a subscript. It will trigger the exception.
indices[2] = 2;
// Use the values from the vector of index values to
// fill the elements vector. This example uses a
// try/catch block to handle invalid access to the
// elements vector.
try
{
for_each(indices.begin(), indices.end(),
[&] (int index) { elements.at(index) = index; });
}
catch (const out_of_range& e)
{
cerr << "Caught '" << e.what() << "'." << endl;
};
}

Caught 'invalid vector<T> subscript'.

// managed_lambda_expression.cpp
// compile with: /clr
using namespace System;
int main()
{
char ch = '!'; // a local unmanaged variable
// The following lambda expression captures local variables
// by value and takes a managed String object as its parameter.
[=] (String ^s)
{ Console::WriteLine(s + Convert::ToChar(ch)); }("Hello");
}

Hello!