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 valueclass 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 valuelong 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 counterpos = remove_if(coll.begin(),coll.end(), // range[&count] (int) { // remove criterionreturn ++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 personfor_each(coll.begin(), coll.end(),[](const Person& p) {p.print();});cout << endl;// call member function print2() with additional argument for each personfor_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 spacestemplate <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.htmltemplate <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 seedtemplate <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 argumentstemplate <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 functionauto hash = [](const Customer& c) {return hash_val(c.firstname(), c.lastname(), c.number());};// lambda for user-defined equality criterionauto eq = [](const Customer& c1, const Customer& c2) {return c1.number() == c2.number();};// create unordered set with user-defined behaviorunordered_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);}