C++ functional callable lambda algorithm

callable

#include <iostream>
#include <sys/types.h>

using std::cout;
using std::endl;

class Callable
{
private:
    int32_t m_id;
public:
    void operator()(int32_t id)
    {
        m_id = id;
        cout << m_id << endl;
    }

};


int main()
{
    Callable a;
    a(1);
    a(2);

    return 0;
}

functional

#include <iostream>
#include <functional>
#include <sys/types.h>

using namespace std;

class Add
{
private:
    u_int32_t m_base;
public:
    Add(u_int32_t b):m_base(b){}
    u_int32_t operator()(u_int32_t a)//over ride ()
    {
        return m_base + a;
    }

    u_int32_t func(u_int32_t a)
    {
        return m_base + a;
    }
};

/**
*@detail function 参数作为回调
*/
void print_with_ops(u_int32_t target, function<u_int32_t(u_int32_t)> func)
{
    auto tmp = func(target);
    cout << tmp << endl;
}



int main()
{
    Add add(4);
    function<u_int32_t(u_int32_t)> f_add = add;
    u_int32_t ret = f_add(8);
    cout << ret << endl;

    print_with_ops(ret, add);//注意此次传入的是add 不是add() ,当然也可以传入Add(4)

    /**
    *lambda形式的回调
    */
    print_with_ops(ret, [](u_int32_t i){
                    cout << " i " << i << endl;
                   return 4+i; 
                });

/**
*bind 类成员函数实现回调
*/
    auto func1 = bind(&Add::func, add, placeholders::_1);
    print_with_ops(ret, func1);

    return 0;
}

lambda

#include <algorithm>//for_each find_if
#include <deque>
#include <iostream>

using namespace std;



int main()
{
    deque<int> coll = {1, 3, 19, 20, 45, 22, 23, 90,67};
    int x = 80;
    int y = 92;
    auto pos = find_if(coll.cbegin(), coll.cend(),
                        [=](int i){
                            return i > x && i < y;
                        });

    cout << "first elem > "<< x << " < " << y <<": is " << *pos << endl;

}

template add

#include <iostream>
#include <algorithm>
#include <vector>


using namespace std;

//注意这种template的用法
template <int theValue>
void add(int & elem)
{
    elem += theValue;
}

//function object
class AddValue
{
private:
    int theValue;
public:
    AddValue(int v) : theValue(v){}
    void operator()(int &elem) const {
        elem += theValue;
    }

};



int main()
{
    vector<int> coll = {1, 3, 4, 5, 7};
    for_each(coll.begin(), coll.end(),
            add<10>);

    for_each(coll.begin(), coll.end(),
            [](int &elem){
                cout << elem << endl;
            });

    for_each(coll.begin(), coll.end(),
            AddValue(10));//新建了一个临时对像

    for_each(coll.begin(), coll.end(),
            [](int &elem){
                cout << elem << endl;
            });

    return 0;
}