仿函数

一.仿函数，即行为类似函数的对象。又称为function object，实际上就是重载了（）运算符

例如

class X

{

 public:

return-value operator()(args) const

   {

   }

}

假如我们要实现一个函数int function（args1，args2）;

我们需要这么做

X fo;

fo(args1,args2);

相比于一般函数，仿函数不仅拥有行为还拥有状态，这使得它可以在执行器进行行为的变化。

例如如下函数：

   假如我们要做一个加法函数   

void add10(int &elem)
{
    elem+=10;
}

每次将输入加10，如果我们想将加的改成20就需要再写一个函数add20，如果我们想运行时添加被加的数值，我们就需要传递一个新的参数

通过新建一个类型X，通过其中重载的（）我们可以满足这些要求

class X
{
    int add;
public:
    X(int t){add = t;}
    void operator()(int &elem)
    {
        elem+=add;
    }
    
};

int main()
{
    list<int> col;
    for(int i = 1;i<=9;i++)
    {
        col.push_back(i);
    }
    for(auto i = col.begin();i!=col.end();++i)
    {
        add10(*i);
    }
    PRINT_ELEM(col,"print");
    for(auto i = col.begin();i!=col.end();++i)                        
    {
        X t(*i);
        t(*i);
    }
    PRINT_ELEM(col,"print");
    for(auto i = col.begin();i!=col.end();++i)
    {
            X z(13);
            z(*i);
    }
    PRINT_ELEM(col,"print");
    return 0;
}

PRINT_ELEM是一个模板函数用于输出容器内的值

template<class T>
inline void PRINT_ELEM(const T&col,const char *op = "")
{
    T::const_iterator pos;            //使用const迭代器，表示不能修改元素
    std::cout<<op;
    for(pos = col.begin();pos!=col.end();++pos)
    {
        std::cout<<*pos<<' ';
    }
    std::cout<<endl;
}

此外可以用作算法中的判断规则

#include <iostream>
#include <algorithm>
#include <iterator>
#include <list>
using namespace std;

class IntSequence
{
private:
    int value;
public:
    IntSequence(int initialValue):value(initialValue)
    {

    }
    int operator()()
    {
        return value++;
    }
};
template<class T>
inline void PRINT_ELEM(const T&col,const char *op = "")
{
    T::const_iterator pos;            //使用const迭代器，表示不能修改元素
    std::cout<<op;
    for(pos = col.begin();pos!=col.end();++pos)
    {
        std::cout<<*pos<<' ';
    }
    std::cout<<endl;
}

int main()
{
    list<int> coll;
    generate_n(back_inserter(coll),9,IntSequence(1));

    PRINT_ELEM(coll,"print");

    generate(++coll.begin(),--coll.end(),IntSequence(42));

    PRINT_ELEM(coll);

}

这段代码使用IntSequence仿函数完成对coll的初始化，其中generate_n这个算法在algorithm的实现是

template<class _OutIt,
    class _Diff,
    class _Fn0> inline
    _OutIt _Generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func)
    {    // replace [_Dest, _Dest + _Count) with _Func()
    for (; 0 < _Count; --_Count, ++_Dest)
        *_Dest = _Func();
    return (_Dest);
    }

即一个模板函数，参数分别是起始位置，初始化数目，初始化函数，注意，仿函数是值传递（这里）

然后对每一个值都使用_Func()的返回值来初始化它，这里就等于IntSequence(1)()的返回值。

这里的back_inserter是配接器，是C++标准程序库事先定义好的特殊迭代器，又称为迭代器配接器。

在这里，对每一个*_Dest赋值的时候，请注意，这里的*运算符，是在back_insert类型中重载之后的运算符

template<class _Container>
    class back_insert_iterator
        : public _Outit

在back_inserter中调用是返回一个指向自己对象的this指针

    _Myt& operator*()
        {    // pretend to return designated value
        return (*this);
        }

它假装返回我们事先设定的类型的对象的值

也就是返回的其实是back_inserter而并不是其里面的类型对象，然后这个赋值运算符，就调用的是

_Myt& operator=(_Valty&& _Val)
        {    // push value into container
        container->push_back(_STD forward<_Valty>(_Val));
        return (*this);
        }

也就是说，它内部调用了一下push_back函数，即在*_Dest = Func()这段代码中，首先通过*获得这个back_insert_iterator对象

然后通过其类重载的赋值运算符，完成将值插入容器的过程。

这个container是在back_insert_iterator初始化的时候，在初始化列表中初始化的。

由此，在generate_n中的Func()调用，就变成仿函数的对象调用()

仿函数是pass by value即传值，而不是pass by reference。

如果IntSequence seq(1);

底下 generate_n(back_inserter(coll),9,seq);

         generate_n(back_inserter(coll),9,seq);

两次调用都是从1开始赋值

这样，在算法中，我们即使修改seq，也是修改的其在算法中的copy副本。

那么如果想获得这个副本或者在算法中修改这个仿函数的实际状态要怎么办？

二.从运用仿函数的算法中获取结果

有两种方法，1，将仿函数按照引用的方式传递进去（这一部分有问题）

2.运用for_each()算法的返回值

其中第二种方法仅作用于for_each

首先是仿函数按照引用的方式传递进去。实际上实现非常简单。

就是在调用算法的时候，显式将模板类型写出来，将传递的类型参数写出来，同时传递的仿函数类型显式的写成引用。

按值传递：

generate_n(back_inserter(coll),4,IntSequence(42));

按引用传递：

generate_n<back_inserter_iterator<list<int> >,int,IntSequence>(back_inserter(coll),4,IntSequence(42))

这样，在这个算法结束后，原本的仿函数的状态得到了改变。

如果是for_each()算法，那么可以通过其返回值获得修改后的仿函数（原仿函数copy版），这是唯一一个返回仿函数的算法。

例如：

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

class IntSequence
{
private:
    int value;
public:
    IntSequence(int initialValue):value(initialValue)
    {

    }
    int operator()()
    {
        return value++;
    }
    int getValue();
    int operator()(int &t)
    {
        return value++;
    }
};
int IntSequence::getValue()
{
    return value;
}
template<class T>
inline void PRINT_ELEM(const T&col,const char *op = "")
{
    T::const_iterator pos;            //使用const迭代器，表示不能修改元素
    std::cout<<op;
    for(pos = col.begin();pos!=col.end();++pos)
    {
        std::cout<<*pos<<' ';
    }
    std::cout<<endl;
}

int main()
{
    vector<int> coll;
    generate_n(back_inserter(coll),9,IntSequence(1));

    PRINT_ELEM(coll,"print");

    generate(++coll.begin(),--coll.end(),IntSequence(42));

    PRINT_ELEM(coll);

    IntSequence mv = for_each(coll.begin(),coll.end(),IntSequence(2));
    cout<<mv.getValue()<<endl;
}

这里面我添加了一个operator()的新的重载形式用于处理for_each中带参数的情况。

然后输出返回的仿函数的内部成员变量，很明显这里返回的值就不是起始的2了，而是11。

template<class _InIt,
    class _Fn1> inline
    void _For_each(_InIt _First, _InIt _Last, _Fn1& _Func)
    {    // perform function for each element
    for (; _First != _Last; ++_First)
        _Func(*_First);
    }

这是for_each的执行函数，很简单

3.预定义仿函数

在C++标准程序库中，提供了多种预先定义的仿函数，

negate<type>()	-param
plus<type>()	param1+param2
minus<type>()	param1-param2
multiplies<type>()	param1*param2
divides<type>()	param1/param2
modulus<type>()	param1%param2
equal_to<type>()	param1==param2
not_equal_to<type>()	param1!=param2
less<type>()	param1<param2
greater<type>()	param1>param2
less_equal<type>()	param1<=param2
greater_equal<type>()	param1>=param2
logical_not<type>()	!param
logical_and<type>()	param1&&param2
logical_or<type>()	param1||param2

要使用这些仿函数，必须添加头文件functional

template<class _Ty>
    struct negate
        : public unary_function<_Ty, _Ty>
    {    // functor for unary operator-
    _Ty operator()(const _Ty& _Left) const
        {    // apply operator- to operand
        return (-_Left);
        }
    };

我们举几个例子来看，这个negate<type>()仿函数，其实际为negate类型中重载()运算符，接收一个_Ty类型引用。

然后返回其-值，该_Ty类型必须有-运算符，如果你传递的类型没有这个运算符，就会出错~

template<class _Ty>
    struct equal_to
        : public binary_function<_Ty, _Ty, bool>
    {    // functor for operator==
    bool operator()(const _Ty& _Left, const _Ty& _Right) const
        {    // apply operator== to operands
        return (_Left == _Right);
        }
    };

这是另一个例子equal_to，类型为struct结构，重载()运算符，然后接收两个参数，判断是否相等，要求_Ty类型必须有==运算符。

所有的二元参数仿函数都继承自binary_function

template<class _Arg1,
    class _Arg2,
    class _Result>
    struct binary_function
    {    // base class for binary functions
    typedef _Arg1 first_argument_type;
    typedef _Arg2 second_argument_type;
    typedef _Result result_type;
    };

这个类型规定了二元参数仿函数的两个参数类型，返回值类型。在继承这个类型的时候，会给出这3个类型。

所有的一元参数仿函数都继承自unary_function

template<class _Arg,
    class _Result>
    struct unary_function
    {    // base class for unary functions
    typedef _Arg argument_type;
    typedef _Result result_type;
    };

这个类型规定了一元参数仿函数的一个参数类型，返回值类型，在继承这个类型的时候，会给出这两个类型

这些内部定义仿函数，都是可以用于算法内部，但是必须配合相应类型和算法。