如何设计一个泛型算法

#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><)
{
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;
}