lambda

#include<functional>
#include<iostream>

std::function<int(int, int)> returnLambda()
{
return [](int x, int y) {
return x*y;
};
}

int main()
{
auto lf = returnLambda();
std::cout << lf(6, 7) << std::endl;
}

输出结果：42

lambda 与 bind对比

#include <functional>
#include <iostream>

int main()
{
auto plus10 = std::bind(std::plus<int>(),
std::placeholders::_1,
10);
std::cout << "+10:    " << plus10(7) << std::endl;

auto plus10times2 = std::bind(std::multiplies<int>(),
std::bind(std::plus<int>(),
std::placeholders::_1,
10),
2);
std::cout << "+10 *2: " << plus10times2(7) << std::endl;

auto pow3 = std::bind(std::multiplies<int>(),
std::bind(std::multiplies<int>(),
std::placeholders::_1,
std::placeholders::_1),
std::placeholders::_1);
std::cout << "x*x*x:  " << pow3(7) << std::endl;

auto inversDivide = std::bind(std::divides<double>(),
std::placeholders::_2,
std::placeholders::_1);
std::cout << "invdiv: " << inversDivide(49, 7) << std::endl;
}

#include <iostream>
int main()
{
auto plus10 = [](int i) {
return i + 10;
};
std::cout << "+10: " << plus10(7) << std::endl;
auto plus10times2 = [](int i) {
return (i + 10) * 2;
};
std::cout << "+10 *2: " << plus10times2(7) << std::endl;
auto pow3 = [](int i) {
return i*i*i;
};
std::cout << "x*x*x: " << pow3(7) << std::endl;
auto inversDivide = [](double d1, double d2) {
return d2 / d1;
};
std::cout << "invdiv: " << inversDivide(49, 7) << std::endl;
}

lambda与function objects

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// function object to process the mean value
class MeanValue {
private:
long num;    // number of elements
long sum;    // sum of all element values
public:
// constructor
MeanValue () : num(0), sum(0) {
}

// "function call"
// - process one more element of the sequence
void operator() (int elem) {
++num;          // increment count
sum += elem;    // add value
}

// return mean value
double value () {
return static_cast<double>(sum) / static_cast<double>(num);
}
};

int main()
{
vector<int> coll = { 1, 2, 3, 4, 5, 6, 7, 8 };

// process and print mean value
MeanValue mv = for_each (coll.begin(), coll.end(),  // range
MeanValue());              // operation //for_each() has the unique ability to return its function object
cout << "mean value: " << mv.value() << endl;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
vector<int> coll = { 1, 2, 3, 4, 5, 6, 7, 8 };

// process and print mean value
long sum = 0;
for_each(coll.begin(), coll.end(),  // range
[&sum](int elem) {
sum += elem;
});
double mv = static_cast<double>(sum) / static_cast<double>(coll.size());
cout << "mean value: " << mv << endl;
}

lambda与stateful function objects

#include <iostream>
#include <list>
#include <algorithm>
#include "print.hpp"
using namespace std;

class Nth {    // function object that returns true for the nth call
private:
int nth;       // call for which to return true
int count;     // call counter
public:
Nth (int n) : nth(n), count(0) {
}
bool operator() (int) {
return ++count == nth;
}
};

int main()
{
list<int> coll = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
PRINT_ELEMENTS(coll,"coll:        ");

// remove third element
list<int>::iterator pos;
pos = remove_if(coll.begin(),coll.end(),  // range
Nth(3));                  // remove criterion
coll.erase(pos,coll.end());

PRINT_ELEMENTS(coll,"3rd removed: ");
}

输出结果：

coll:        1 2 3 4 5 6 7 8 9 10

3rd removed: 1 2 4 5 7 8 9 10

#include <iostream>
#include <list>
#include <algorithm>
#include "print.hpp"
using namespace std;

int main()
{
list<int> coll = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
PRINT_ELEMENTS(coll,"coll:        ");

// remove third element
list<int>::iterator pos;
int count=0;     // call counter
pos = remove_if(coll.begin(),coll.end(),   // range
[count] (int) mutable {   // remove criterion
return ++count == 3;
});
coll.erase(pos,coll.end());

PRINT_ELEMENTS(coll,"3rd removed: ");
}

coll: 1 2 3 4 5 6 7 8 9 10

3rd removed: 1 2 4 5 7 8 9 10

If you pass the argument by reference and don’t use mutable, the behavior is as expected,

because both lambda objects internally used by remove_if() share the same state. Thus, with

the following:

int count=0; // call counter
pos = remove_if(coll.begin(),coll.end(), // range
[&count] (int) { // remove criterion
return ++count == 3;
});

the output is:

coll: 1 2 3 4 5 6 7 8 9 10

3rd removed: 1 2 4 5 6 7 8 9 10

#include <iostream>
#include <algorithm>
#include <functional>
#include <locale>
#include <string>
using namespace std;
using namespace std::placeholders;

char myToupper (char c)
{
std::locale loc;
return std::use_facet<std::ctype<char> >(loc).toupper(c);
}

int main()
{
string s("Internationalization");
string sub("Nation");

// search substring case insensitive
string::iterator pos;
pos = search (s.begin(),s.end(),           // string to search in
sub.begin(),sub.end(),       // substring to search
bind(equal_to<char>(),       // compar. criterion
bind(myToupper,_1),
bind(myToupper,_2)));
if (pos != s.end()) {
cout << "\"" << sub << "\" is part of \"" << s << "\""
<< endl;
}
}

#include <iostream>
#include <algorithm>
#include <locale>
#include <string>
using namespace std;

char myToupper (char c)
{
std::locale loc;
return std::use_facet<std::ctype<char> >(loc).toupper(c);
}

int main()
{
string s("Internationalization");
string sub("Nation");

// search substring case insensitive
string::iterator pos;
pos = search (s.begin(),s.end(),           // string to search in
sub.begin(),sub.end(),       // substring to search
[] (char c1, char c2) {      // compar. criterion
return myToupper(c1)==myToupper(c2);
});
if (pos != s.end()) {
cout << "\"" << sub << "\" is part of \"" << s << "\""
<< endl;
}
}

calling member functions

#include <functional>
#include <algorithm>
#include <vector>
#include <iostream>
#include <string>
using namespace std;
using namespace std::placeholders;

class Person {
private:
string name;
public:
Person (const string& n) : name(n) {
}
void print () const {
cout << name << endl;
}
void print2 (const string& prefix) const {
cout << prefix << name << endl;
}
//...
};

int main()
{
vector<Person> coll
= { Person("Tick"), Person("Trick"), Person("Track") };

// call member function print() for each person
for_each (coll.begin(), coll.end(),
bind(&Person::print,_1));
cout << endl;

// call member function print2() with additional argument for each person
for_each (coll.begin(), coll.end(),
bind(&Person::print2,_1,"Person: "));
cout << endl;

// call print2() for temporary Person
bind(&Person::print2,_1,"This is: ")(Person("nico"));
}

#include <functional>
#include <algorithm>
#include <vector>
#include <iostream>
#include <string>
using namespace std;
using namespace std::placeholders;

class Person {
private:
string name;
public:
Person(const string& n) : name(n) {
}
void print() const {
cout << name << endl;
}
void print2(const string& prefix) const {
cout << prefix << name << endl;
}
//...
};

int main()
{
vector<Person> coll
= { Person("Tick"), Person("Trick"), Person("Track") };

// call member function print() for each person
for_each(coll.begin(), coll.end(),
[](const Person& p) {
p.print();
});
cout << endl;

// call member function print2() with additional argument for each person
for_each(coll.begin(), coll.end(),
[](const Person& p) {
p.print2("Person: ");
});
}

Using lambdas as hash function and equivalence criterion

//print.hpp
#include <iostream>
#include <string>

// PRINT_ELEMENTS()
// - prints optional string optstr followed by
// - all elements of the collection coll
// - in one line, separated by spaces
template <typename T>
inline void PRINT_ELEMENTS(const T& coll,
const std::string& optstr = "")
{
std::cout << optstr;
for (const auto& elem : coll) {
std::cout << elem << ' ';
}
std::cout << std::endl;
}


//hashval.hpp
#pragma once
#include <functional>

// from boost (functional/hash):
// see http://www.boost.org/doc/libs/1_35_0/doc/html/hash/combine.html template <typename T>
inline void hash_combine(std::size_t& seed, const T& val)
{
seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

// auxiliary generic functions to create a hash value using a seed
template <typename T>
inline void hash_val(std::size_t& seed, const T& val)
{
hash_combine(seed, val);
}
template <typename T, typename... Types>
inline void hash_val(std::size_t& seed,
const T& val, const Types&... args)
{
hash_combine(seed, val);
hash_val(seed, args...);
}

// auxiliary generic function to create a hash value out of a heterogeneous list of arguments
template <typename... Types>
inline std::size_t hash_val(const Types&... args)
{
std::size_t seed = 0;
hash_val(seed, args...);
return seed;
}

//main.cpp
#include <string>
#include <iostream>
#include <unordered_set>
#include "hashval.hpp"
#include <functional>
#include "print.hpp"
using namespace std;

class Customer {
private:
string fname;
string lname;
long   no;
public:
Customer(const string& fn, const string& ln, long n)
: fname(fn), lname(ln), no(n) {
}
string firstname() const {
return fname;
};
string lastname() const {
return lname;
};
long number() const {
return no;
};
friend ostream& operator << (ostream& strm, const Customer& c) {
return strm << "[" << c.fname << "," << c.lname << "," << c.no << "]";
}
};

int main()
{
// lambda for user-defined hash function
auto hash = [](const Customer& c) {
return hash_val(c.firstname(), c.lastname(), c.number());
};

// lambda for user-defined equality criterion
auto eq = [](const Customer& c1, const Customer& c2) {
return c1.number() == c2.number();
};

// create unordered set with user-defined behavior
unordered_set<Customer, decltype(hash), decltype(eq)> custset(10, hash, eq);
// ERROR: unordered_set<Customer,function<size_t(Customer,Customer)>,decltype(eq)> custset(10,hash,eq);

custset.insert(Customer("nico", "josuttis", 42));
PRINT_ELEMENTS(custset);

}