如何设计一个泛型算法

#include <iostream>
#include <list>
#include <vector>

#include <functional>
#include <algorithm>

using namespace std;
//下面我们的新任务。
//用户给一个整数 vector 我们必须返回一个新的 vector ，其中内含原 vector 之中小于 10 的所有数值
//一个快速但缺乏通用性的解法是：
//
/*
vector<int>less_than(const vector<int>&vec)
{
    vector<int> nvec;
    for(int i=0;i<vec.size();i++)
    {
        if(vec[i]<10)
        {
            nvec.push_back(vec[i]);
        }
    }
    return nvec;
}
//上面的程序虽然正确，但如果用户想要 小于 11 或 12 的数，那么我们就得建立另一个函数。
//因此 可以让用户来指定一个上限值  如下：

vector<int>less_than(const vector<int>&vec,int less_val)//多加一个参数让用户来指定所要选的数值
{
    vector<int> nvec;
    for(int i=0;i<vec.size();i++)
    {
        if(vec[i]<less_val)
        {
            nvec.push_back(vec[i]);
        }
    }
    return nvec;
}
*/

//下面任务难度颇高，我们必须允许用户自己来指定比较操作，如 大于，小于等等，
//如何才能将 比较操作 参数化呢？
//有一个办法：用函数调用来取代 less_than 运算符，加入第三个参数 pred,用它来指定一个函数
//指针，它的参数表有两个整数返回值为 bool
// 不过它的名称已 不在适当了，就换 filter()  吧:

//例：
/*
vector<int>filter(const vector<int>&vec,int filter_value,bool (*pred)(int ,int))//让用户指定比较方式
{
    vector<int> nvec;
    for(int i=0;i<vec.size();i++)
    {
        if(pred(vec[i],filter_value))
        {
            nvec.push_back(vec[i]);
        }
    }
    return nvec;
}
//比较函数
bool less_than(int v1,int v2)
{
    return v1<v2 ? true:false;
}
bool greater_than(int v1,int v2)
{
    return v1>v2? true:false;
}
bool qwer(int v1,int v2)
{
        return v1==v2? true:false;
}
*/

//我们探索并没有停止，标准库提供了两个函数：bind1st 会将指定值绑定至第一操作数，
//bind2nd 则将指定值绑定至第二操作数，详细可以看 msdn
//以下是修改后的 filter()

/*vector<int>filter(const vector<int>&vec,int val,less<int>&lt)
{
    vector<int>nvec;
    vector<int>::const_iterator iter=vec.begin();
    //bind2nd(less<int>,val)会把 val 绑定到 less<int>  的第二参数身上
    //于是 less<int> 会将每个元素拿来和 val 比较
    while((iter=find_if(iter,vec.end(),bind2nd(lt,val)))!=vec.end())
    {
        //每当 iter!=vec.end();
        //iter 便是指向某个小于 val 的元素
        nvec.push_back(*iter);
        iter++;
    }
    return nvec;
}
*/
//但这个还不是我们想要的,要更通用的如 例3：
//注意 这两个头文件    #include <functional>
//    #include <algorithm>

/*
template<class Input,class Output,class ElemType,class Comp>
Output filter(Input first,Input last,Output at,const ElemType &val,Comp pred)
{
    while((first=find_if(first,last,bind2nd(pred,val)))!=last)
    {
        cout<<"找到的值："<<*first<<endl;
        *at++=*first++;//执行 自加操作，然后让两个 指针 前进
    }
    return at;
}
//好了现在我们的函数和元素类型无关，和比较操作无关，和容器类型无关，简单地说我们已经将最初的函数
//转化为一个泛型算法了。

*/

//另一种截然不同的做法是，先对vector排序，再以 find_if 找出第一个大于指定值的元素位置，
//然后再删除该位置之后互 vector 末尾的所有元素，通常我们会在 vector 的副本上进行排序
// 因为我们可能不愿意改变 vector

//例：4
/*vector<int>sub_vec(const vector<int> &vec,int val)
{
    vector<int> local_vec(vec);
    sort(local_vec.begin(),local_vec.end());

    vector<int>::iterator iter=find_if(local_vec.begin(),local_vec.end(),
        bind2nd(greater<int>(),val));

    local_vec.erase(iter,local_vec.end());//删除后面所有的元素

    return local_vec;
}*/
// 例4：上面的没有什么可玩性，还是把它做成通用的模板吧 如：
/*
template<const class vect,class vaule> vect sub_vec (vect &vec,vaule val)
{
    vector<vaule>  loacl_vec(vec);
    sort(loacl_vec.begin(),loacl_vec.end());
    vector<vaule>::iterator iter=find_if(loacl_vec.begin(),loacl_vec.end(),
        bind2nd(greater<vaule>(),val));
    loacl_vec.erase(iter,loacl_vec.end());
    
    return loacl_vec;

}
*/


//驱动程序
int main()
{
    /*例 1 2
    int aa[]={12,13,7,11,2};
    vector<int> vec(aa,aa+5);
    vector<int> temp;//存储过滤结果
    //temp=less_than(vec,12);//less_than(vec) 这个函数返回的是一个 vector 所以用一个vector 对象来接收它
    //temp=filter(vec,12,greater_than);//大于
//    temp=filter(vec,12,less_than);//小于
    temp=filter(vec,11,qwer);//等于

    for(vector<int>::iterator p=temp.begin();p!=temp.end();p++)
    {
        cout<<*p<<" : ";
    }
    cout<<endl;
    */

    //例 3：
/*    const int elem_size=5;
    int aa[elem_size]={12,45,56,1,2};
    vector<int> ivec(aa,aa+elem_size);//将数组元素给它

    int aa2[elem_size];//存储过滤结果
    vector<int> ivec2(elem_size);
    
    cout<<"小于 15 的：/n"<<endl;
    filter(aa,aa+elem_size,aa2,15,less<int>());

    cout<<"大于 15 的：/n"<<endl;
    filter(ivec.begin(),ivec.end(),ivec2.begin(),15,greater<int>());
*/
/*
    //例 4：
    const int size=6;
    int aa[size]={23,56,24,1,2,3};
    vector<int> vec(aa,aa+6);

    vector<int> vec2;
    vec2=sub_vec(vec,25);
    
    cout<<"小于 25 的有："<<endl;

    for(vector<int>::iterator p=vec2.begin();p!=vec2.end();p++)
    {
        cout<<*p<<" ";
    }
    cout<<'/n';
*/

    return 0;
}