类模板、绑定器与参数推演

当我们执行一段代码时，如果有一个循环调用一个函数，那就有不断的函数栈贞的开辟与回退，就造成效率底下，在c++中我们可以用模板解决这个问题，模板在编译阶段就被确定。

template<typename T>//二元比较器
class Less
{
public:
    typedef T value_type;
    bool call(T a1,T a2)
    {
        return a1<a2;
    }

private:

};

template<typename T>//一元比较器
class Greater
{
public:
    typedef T value_type;
    Greater(T value) :_value(value){}
    bool call(T a1)
    {
        return a1 > _value;
    }
private:
    T _value;
};

而我们当用一个函数调用时：

template<typename T,typename compare>
int find(T*array, int len, compare comp)
{

    for (int i = 0; i < len; i++)
    {
        if (comp.call(array[i]))
        {
            return i;
        }
    }
    return -1;
}

如何在不改变find函数模板的情况下，让find既能调用一元比较器又能调用二元比较器呢？
我们定义一个绑定器，将二元比较器的一个值绑定，就变成了一元比较器，find就成了通用的模板了，比较器定义如下：

template<typename compare>
class _bind
{
public:
     typedef typename compare::value_type T;//获取数组中的元素的类型
    _bind(compare comp,T a)
    {
        _value = a;
        _comp = comp;
    }
    bool call(T a)
    {
        return _comp.call(a, _value);
    }
private:
    T _value;
    compare _comp;
};

绑定器就相当于重新定义了一个模板，将一个参数变为自己的成员属性，然后再自己模板内部吧这个参数传递给二元比较器，也相当于给二元比较器重新加了一个外包装。但是此模板在调用时必须把参数写全，类模板无法自己推演参数参数类型调用时如下：

//int index = find(arr, 5, _bind<int, Less<int>>(Less<int>(),3 ));//_bind类模板不存在参数的推演，所以必须写明参数

于是我们就加给此绑定器加了一个外包装，让他变成一个函数模板，函数模板就可以自己根据传递的参数自己推演参数列表，函数如下：

template<typename compare>//用一个函数将类包装
_bind<compare> _mybind(compare comp, typename compare::value_type a)//typename 指明后面是类型名
{
    return _bind<compare>(comp, a);
}

此时调用：

int index = find(arr, 5, _mybind(Less<int>(), 3));//将类模板转换成相应的函数模板，因为函数模板存在参数推演，就简化