15.

C++ advanced (III): Functors and

Lambda
Generic Programming: higher order functions

414
Functors: Motivation
A simple output filter
template <typename T, typename Function>
void filter(const T& collection, Function f){
for (const auto& x: collection)
if (f(x)) std::cout << x << " ";
std::cout << "\n";
}

Question: when does a call of the filter template function work?

415
Functors: Motivation
A simple output filter
template <typename T, typename Function>
void filter(const T& collection, Function f){
for (const auto& x: collection)
if (f(x)) std::cout << x << " ";
std::cout << "\n";
}

Question: when does a call of the filter template function work?

Answer: works if the first argument offers an iterator and if the second argu-
ment can be applied to elements of the iterator with a return value that can
be converted to bool.

415
Functors: Motivation

template <typename T, typename Function>

void filter(const T& collection, Function f);

template <typename T>

bool even(T x){
return x % 2 == 0;
}

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
filter(a,even<int>); // output: 2,4,6,16

416
Context and Overview
Recent C++-lecture: make code parametric on the data it operates
Pair<T> for element types T
print<C> for iterable containers C
Now: make code parameteric on a (part of) the algorithm
filter(container, predicate)
apply(signal, transformation/filter)
We learn about
Higher-order functions: fucntions that take functions as arguments
Functors: objects with overloaded function operator ().
Lambda-Expressions: anonymous functors (syntactic sugar)
Closures: lambdas that capture their environment

417
Functors: Motivation
template <typename T, typename Function>
void filter(const T& collection, Function f){
for (const auto& x: collection)
if (f(x)) std::cout << x << " ";
std::cout << "\n";
}
Requirements on f: must be callable/applicable (...)
f must be a kind of function ⇒ filter is a function that takes a
function as argument
A function taking (or returning) a function is called a higher order
function
Higher order functions are parameteric in their functionality (or they
generate functions)
418
What if...
the filter should be more flexible:
template <typename T, typename function>
void filter(const T& collection, function f);

template <typename T>

bool largerThan(T x, T y){
return x > y;
}

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
int val = 8;
filter(a,largerThan<int>( ? ,val));

419
What if...
the filter should be more flexible:
template <typename T, typename function>
void filter(const T& collection, function f);

template <typename T>

bool largerThan(T x, T y){
return x > y;
}

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
int val = 8;
filter(a,largerThan<int>( ? ,val)); (No, this does not exist)

419
Functor: Object with Overloaded Operator ()
class GreaterThan{
int value; // state
public:
GreaterThan(int x):value{x}{} A Functor is a callable ob-
ject. Can be understood as
bool operator() (int par) const { a stateful function.
return par > value;
}
};

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
int value=8;
filter(a,GreaterThan(value)); // 9,11,16,19

420
Functor: object with overloaded operator ()
template <typename T>
class GreaterThan{
T value;
public:
GreaterThan(T x):value{x}{} (this also works with a tem-
plate, of course)
bool operator() (T par) const{
return par > value;
}
};

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
int value=8;
filter(a,GreaterThan<int>(value)); // 9,11,16,19
421
Observations
Need to give the predicate a name

template <typename T> Often unnecessary, many are

class GreaterThan{ unsed only once
T value;
public: Descriptive names not
GreaterThan(T x):value{x}{} always possible
Distance (in the code)
bool operator() (T par) const{ between declaration and use
return par > value; Overhead: stateful predicates as
}
functors
};
cumbersome for what is
ultimately only par > value
422
The same with a Lambda-Expression

Anonymous functions with lambda-expressions:

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
int value=8;

filter(a, [value](int x) {return x > value;} );

That is just syntactic sugar, from which the compiler generates a suitable
functor.

423
Interlude: Sorting with Custom Comparator

std::sort is generic
in the iterator-type
in the values iterated over
in the used comparator

std::sort (v.begin(), v.end(), std::less());

The comparator returns true if the elements are ordered as wished.

424
Sorting by Different Order
// pre: i >= 0
// post: returns sum of digits of i
int q(int i){
int res =0;
for(;i>0;i/=10)
res += i % 10;
return res;
}

std::vector<int> v {10,12,9,7,28,22,14};
std::sort (v.begin(), v.end(),
[] (int i, int j) { return q(i) < q(j);}
);

425
Sorting by Different Order
// pre: i >= 0
// post: returns sum of digits of i
int q(int i){
int res =0;
for(;i>0;i/=10)
res += i % 10;
return res;
}

std::vector<int> v {10,12,9,7,28,22,14};
std::sort (v.begin(), v.end(),
[] (int i, int j) { return q(i) < q(j);}
);
Now v =
425
Sorting by Different Order
// pre: i >= 0
// post: returns sum of digits of i
int q(int i){
int res =0;
for(;i>0;i/=10)
res += i % 10;
return res;
}

std::vector<int> v {10,12,9,7,28,22,14};
std::sort (v.begin(), v.end(),
[] (int i, int j) { return q(i) < q(j);}
);
Now v =10, 12, 22, 14, 7, 9, 28 (sorted by sum of digits)
425
Lambda-Expressions in Detail

[value] (int x) ->bool {return x > value;}

capture parameters return statement

type

426
Closure

[value] (int x) ->bool {return x > value;}

Lambda expressions evaluate to a temporary object – a closure

The closure retains the execution context of the function - the captured
objects.
Lambda expressions can be implemented as functors.

427
Simple Lambda Expression

[]()->void {std::cout << "Hello World";}

428
Simple Lambda Expression

[]()->void {std::cout << "Hello World";}

call:
[]()->void {std::cout << "Hello World";}();

428
Simple Lambda Expression

[]()->void {std::cout << "Hello World";}

call:
[]()->void {std::cout << "Hello World";}();

assignment:
auto f = []()->void {std::cout << "Hello World";};

428
Minimal Lambda Expression

[]{}

Return type can be inferred if no or only one return statement is

present.18
[]() {std::cout << "Hello World";}

If no parameters and no explicit return type, then () can be omitted.

[]{std::cout << "Hello World";}
[...] can never be omitted.
18
Since C++14 also several returns possible, provided that the same return type is
deduced
429
Examples

[](int x, int y) {std::cout << x * y;} (4,5);

Output:

430
Examples

[](int x, int y) {std::cout << x * y;} (4,5);

Output: 20

430
Examples

int k = 8;
auto f = [](int& v) {v += v;};
f(k);
std::cout << k;
Output:

431
Examples

int k = 8;
auto f = [](int& v) {v += v;};
f(k);
std::cout << k;
Output: 16

431
Examples

int k = 8;
auto f = [](int v) {v += v;};
f(k);
std::cout << k;
Output:

432
Examples

int k = 8;
auto f = [](int v) {v += v;};
f(k);
std::cout << k;
Output: 8

432
Commonly Used: std::foreach

Common task: iterate over a container and do something with each

element

for (auto& name: names) {

std::cout << name << ’ ’;
}

This pattern is typically implemented as higher-order function for_each

for_each(names, [](auto name) {std::cout << name << " ";});

433
Sum of Elements – Old School

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
int sum = 0;
for (auto x: a)
sum += x;
std::cout << sum << std::endl; // 83

434
Sum of Elements – Old School

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
int sum = 0;
....
std::cout << sum << std::endl; // 83

Task: increase sum for each call in for_each

Problem: for_each requires accesst to the context (here sum)
Other example filter: store each element of a vector into a different
vector according to some condition.

435
Sum of Elements – with Functor
template <typename T>
struct Sum{
T value = 0;

void operator() (T par){ value += par; }

};

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
Sum<int> sum;
// for_each copies sum: we need to copy the result back
sum = std::for_each(a.begin(), a.end(), sum);
std::cout << sum.value << std::endl; // 83

436
Sum of Elements – with Functor
template <typename T>
struct Sum{
T value = 0;

void operator() (T par){ value += par; }

};

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
Sum<int> sum;
// for_each copies sum: we need to copy the result back
sum = std::for_each(a.begin(), a.end(), sum);
std::cout << sum.value << std::endl; // 83

Ok: solves the problem but does not operate on the sum variable
436
Sum of Elements – with References
template <typename T>
struct SumR{
T& value;
SumR (T& v):value{v} {}

void operator() (T par){ value += par; }

};

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};
int s=0;
SumR<int> sum{s};
// cannot (and do not need to) assign to sum here
std::for_each(a.begin(), a.end(), sum);
std::cout << s << std::endl; // 83
437
Of course this works, very similarly, using pointers
Sum of Elements – with Λ

std::vector<int> a {1,2,3,4,5,6,7,9,11,16,19};

int s=0;

std::for_each(a.begin(), a.end(), [&s] (int x) {s += x;} );

std::cout << s << std::endl;

438
Capture – Lambdas

For Lambda-expressions the capture list determines the context accessible

Syntax:
[x]: Access a copy of x (read-only)
[&x]: Capture x by reference
[&x,y]: Capture x by reference and y by value
[&]: Default capture all objects by reference in the scope of the lambda
expression
[=]: Default capture all objects by value in the context of the
Lambda-Expression

439
Capture – Lambdas

std::vector<int> v = {1,2,4,8,16};

int elements=0;
int sum=0;
std::for_each(v.begin(), v.end(),
[&] (int k) {sum += k; elements++;} // capture all by reference
)

std::cout << "sum=" << sum << " elements=" << elements << std::endl;

Output:

440
Capture – Lambdas

std::vector<int> v = {1,2,4,8,16};

int elements=0;
int sum=0;
std::for_each(v.begin(), v.end(),
[&] (int k) {sum += k; elements++;} // capture all by reference
)

std::cout << "sum=" << sum << " elements=" << elements << std::endl;

Output: sum=31 elements=5

440
Capture – Lambdas

template <typename T>

void sequence(vector<int> & v, T done){
int i=0;
while (!done()) v.push_back(i++);
}

vector<int> s;
sequence(s, [&] {return s.size() >= 5;} )

now v =

441
Capture – Lambdas

template <typename T>

void sequence(vector<int> & v, T done){
int i=0;
while (!done()) v.push_back(i++);
}

vector<int> s;
sequence(s, [&] {return s.size() >= 5;} )

now v = 0 1 2 3 4

441
Capture – Lambdas

template <typename T>

void sequence(vector<int> & v, T done){
int i=0;
while (!done()) v.push_back(i++);
}

vector<int> s;
sequence(s, [&] {return s.size() >= 5;} )

now v = 0 1 2 3 4
The capture list refers to the context of the lambda expression.

441
Capture – Lambdas

When is the value captured?

int v = 42;
auto func = [=] {std::cout << v << "\n"};
v = 7;
func();

Output:

442
Capture – Lambdas

When is the value captured?

int v = 42;
auto func = [=] {std::cout << v << "\n"};
v = 7;
func();

Output: 42
Values are assigned when the lambda-expression is created.

442
Capture – Lambdas
(Why) does this work?
class Limited{
int limit = 10;
public:
// count entries smaller than limit
int count(const std::vector<int>& a){
int c = 0;
std::for_each(a.begin(), a.end(),
[=,&c] (int x) {if (x < limit) c++;}
);
return c;
}
};

443
Capture – Lambdas
(Why) does this work?
class Limited{
int limit = 10;
public:
// count entries smaller than limit
int count(const std::vector<int>& a){
int c = 0;
std::for_each(a.begin(), a.end(),
[=,&c] (int x) {if (x < limit) c++;}
);
return c;
}
};
The this pointer is implicitly copied by value
443
Capture – Lambdas

struct mutant{
int i = 0;
void action(){ [=] {i=42;}();}
};

mutant m;
m.action();
std::cout << m.i;

Output:

444
Capture – Lambdas

struct mutant{
int i = 0;
void action(){ [=] {i=42;}();}
};

mutant m;
m.action();
std::cout << m.i;

Output: 42
The this pointer is implicitly copied by value

444
Lambda Expressions are Functors

[x, &y] () {y = x;}

can be implemented as
unnamed {x,y};

with
class unnamed {
int x; int& y;
unnamed (int x_, int& y_) : x (x_), y (y_) {}
void operator () () {y = x;}
};

445
Lambda Expressions are Functors

[=] () {return x + y;}

can be implemented as
unnamed {x,y};

with
class unnamed {
int x; int y;
unnamed (int x_, int y_) : x (x_), y (y_) {}
int operator () () const {return x + y;}
};

446
Polymorphic Function Wrapper std::function

#include <functional>

int k= 8;
std::function<int(int)> f;
f = [k](int i){ return i+k; };
std::cout << f(8); // 16

can be used in order to store lambda expressions.

Other Examples
std::function<int(int,int)>; std::function<void(double)> ...
http://en.cppreference.com/w/cpp/utility/functional/function

447
Example

template <typename T>

auto toFunction(std::vector<T> v){
return [v] (T x) -> double {
int index = (int)(x+0.5);
if (index < 0) index = 0;
if (index >= v.size()) index = v.size()-1;
return v[index];
};
}

448
Example
auto Gaussian(double mu, double sigma){
return [mu,sigma](double x) {
const double a = ( x - mu ) / sigma;
return std::exp( -0.5 * a * a );
};
}

template <typename F, typename Kernel>

auto smooth(F f, Kernel kernel){
return [kernel,f] (auto x) {
// compute convolution ...
// and return result
};
}
449
Example

std::vector<double> v {1,2,5,3};
auto f = toFunction(v);
auto k = Gaussian(0,0.1);
auto g = smooth(f,k);

450
Conclusion

Higher-order functions are parametric in their functionality: more

flexible → more widely applicable → more code reuse
Being able to pass around functions means being able to pass around
entire computations.
Lambda expressions facilitate the use of “one-off” functions, which are
often used in combination with higher-order functions.
Returning lambdas enables implementing function generators, that can
generate whole families of functions.
In C++, lambda expressions desugare into function objects (functors).
Higher-order functions and lambdas are an important, and nowadays
mainstream, building block of the functional programming paradigm.

451