泛型编程
1.指针的算术运算
为了操作容器中的数据而不用管它的数据类型是什么，使用泛型(generic)算法，不直接在容器身上进行操作，而是借用一对iterator，标识我们要进行迭代的范围。
1.对于array来说，传入array而不管array里面是什么
//写出template泛型 find()函数
template <typename T>
T* find( T *first, T *last, const T &value) {
if (!first || !last)
return 0;
for (; first != last; ++first) {
if (*first == value)
return first;//输出所查找元素的地址
}
return 0;
}
int main(){
int ia[8] = { 1,2,3,4,5,6,7,8 };
int *pi = find(ia,ia+8,ia[3]); //find()返回所查找元素的地址
}
2.传入vector而不管vector里面是什么
#include <vector>
#include <iostream>
//编写泛型find函数
template <typename T>
T* find( T *first, T *last, const T &value) {
if (!first || !last)
return 0;
for (; first != last; ++first) {
if (*first == value)
return first;
}
return 0;
}
template <typename T>
inline T * begin(const std::vector<T> &vec) {
return vec.std::empty() ? 0 : &vec[0];
}
template <typename T>
inline T * end(const std::vector<T>&vec) {
return vec.std::empty() ? 0 : &vec[vec.std::size()];
}
int main() {
int ia[8] = { 1,2,3,4,5,6,7,8 };
std::vector<int> ib;
ib.insert(ib.begin(), ia, ia + 9);
std::cout << "ib is " << &ib << "\nib[7]is" << &ib[7]
<<"\nia is "<<ia<<"\nia[7] is "<<&ia[7];//验证了vector和array确实都是连续内存
int *pi = find(begin(ib),end(ib),ib[3]);//why:find报错
//std::cout << find(begin(ib), end(ib), ib[3]) << " ";
getchar();
}
但是对于list等非连续空间内的指针，指针的算术运算就不适用了，因此需要在底层指针的行为之上提供一层抽象，取代程序原本的“指针直接操作”方式，我们把底层指针的处理放在这个抽象层当中，让用户无须直接面对指针操作。这样就可以只提供一个find()函数就可以操作std所提供的所有的容器类。
#include <vector>
#include <iostream>
#include <string>
#include <list>
std::vector<std::string> svec;
std::vector<std::string>::iterator iter = svec.begin();
namespace mine {
template <typename T, typename IT>
IT find(IT first, IT last, const T &value)
{
for (; first != last; ++first) {
if (value == *first)//值运算，故first解包
return first;
}
return last;
}
}
/*发现如果用find(),会和标准库的find()重名，导致报错“有多个重载函数find实例与
参数列表匹配，函数调用不明确”
问题原因：自定义的find定义位置是全局变量，因此污染了namespace
解决方法：1.函数改名 ，并以后不要定义与标准库重名的函数
2.给自定义变量加命名空间 如 namespace main{}*/
int main() {
const int asize = 8;
int ia[asize] = { 1,1,2,3,5,8,13,21 };//ia is an array
std::vector<int> ivec(ia,ia+asize);//将ia[]赋值给vector
std::list<int> ilist(ia, ia + asize);
//find() return一个地址，故应该和pia存放的地址对比计算
int*pia = mine::find(ia, ia + asize, 1024);
if (pia != ia + asize)//pia is an int*
std::cout << pia << std::endl;
else
std::cout << "none"<<std::endl;
std::vector<int>::iterator it; //声明泛型迭代器it
it = mine::find(ivec.begin(), ivec.end(), 21);
if(it!=ivec.end())
std::cout << *it << std::endl;
else
std::cout << "none";
getchar();
}
因此，定义函数时最好不要定义和标准库同名的函数名。
3.顺序性容器
顺序性容器有，
vector,物理连续内存储存，利于随机访问但不利于插入删除（因为每次涉及插入删除都需要复制一份依次向右移动）。
list，逻辑内存储存，包含三个字段：value,back point,front point。利于插入删除但不利于随机访问。
deque：与vector类似都是连续内存，对于最前端元素的插入和删除效率更高，末端元素亦同。
//e.g.
std::deque <int> a_line;
int ival;
while (std::cin>>ival)
{ //add an elem to the end of a_line
a_line.push_back(ival);
//read the first elem of a_line
int curr_value = a_line.front;
//delete the first elem
a_line.pop_front;
// if you want to delete the last elem, you can write pop_back()
}
几种指定位置的删除/增加：
interator insert(iterator position ,elemType value)——可将value插入position之前
std::list<int> ilist;
std::list<int>::iterator it = ilist.begin();
while (it != ilist.end())
{
if (*it >= ival) {
ilist.insert(it, ival);//insert it befor value ival
break;
}
++it;
}
if (it == ilist.end())
ilist.push_back(ival);
viod insert(iterator position, int count, elemType calue)——可在position之前插入count个元素，这些元素的值和value相同
std::string sval("part two");
std::list<std::string> slist;
//fill slist...
//find sval between slist.begin&slist.end() and return a iterator
std::list<std::string>::iterator it = std::find(slist.begin(), slist.end(),sval);
slist.insert(it, 8, std::string("dummy"));
viod insert(iterator1 position, iterator2 first,iterator2 last)——可在Position插入[first,last)中的元素（注意左闭区间右开）
int ia1[7] = { 1,1,2,3,5,55,89 };
int ia2[4] = { 8,13,21,34 };
std::list<int> elems(ia1, ia1 + 7);
std::list<int>::iterator it = find(elems.begin(), elems.end(), 55);
elems.insert(it, ia2, ia2 + 4);//由于it已经是55的具体地址值，因此不需要指定插入在ia1之中
删除(erase)元素
iterator erase(iterator posit) ——可以删除position指定的元素
//e.g.
//要删除“str”这个元素
std::list <string>::iterator it = find(slist.begin(),slist.end().str);
slist.erase(it);
iterator erase(iterator first,iterator last)可以删除[first,last)范围内的元素。
//e.g.
//删除元素值为str何元素值为sval之间的所有元素。
std::list<string>::iterator it1 = find(slist.begin() , slist.end(),str);
std::list<string>::iterator it2 = find(slist.begin() , slist.end(),sval);
slist.erase(it1,it2);
需要注意的是，上述两个erase函数范围的Iterator都指向被删除之后的最后一个元素的下一个位置。
另外，不能使用
slist.erase(it,it+num_tries);
因为List并不支持iterator的偏移计算。因此必须将It1，it2传入。
4.已有的泛型算法应用
std::binary_search 比find()函数更有效率，但查找时需保证vector中的元素是单调递增的，因为它的底层判断是依赖这个特性写的。不同于find(),binary_search()是返回一个Bool值。
//e.g.
bool is_elem(std::vector<int>&vec, int elem) {
//前提条件：我们现在处理的是一个严格单调递增的vector
int max_value = *std::max_element(vec.begin(), vec.end());//找出容器中最大的元素
if (max_value < elem)
return grow_vec(vec, elem);
if (max_value == elem)
return true;
return binary_search(vec.begin(), vec.end(), elem);
}
max_element返回一个iterator，需要用*进行解包。
grow_vec()会持续地将数列元素意义加入vector中，直到加入的数值大于或者等于elem。
binary_search()要求作用对象必须经过排序，如果没有，可以先将容器复制一份，然后调用sort排序，最后调用binary_search查找。
//e.g.
int ia[4] = { 1,2,4,3 };
std::vector<int> ivec(ia, ia + 4);
std::vector<int> temp(ivec.size());
std::copy(ivec.begin(), ivec.end(), temp.begin());
std::sort(temp.begin(), temp.end());
return std::binary_search(temp.begin(), temp.end(), elem);
5.设计一个泛型算法
当我们要做一个泛型任务，例如需要用户基于一个整数vector，我们返回一个新的vector，其中内含原vector中所有小于/或大于x(由用户指定)的数，
我们首先想到用for循环和函数指针来完成任务。
#include <algorithm>
#include <vector>
#include <iostream>
//定义一个按条件筛选的“过滤器”
std::vector<int> filter_ver1(const std::vector<int>&vec,
int filter_value,
bool(*pred)(int, int)) //利用函数指针形成函数弹性
{ std::vector<int>nvec;
for (int ix = 0; ix < vec.size(); ++ix) {
if (pred(vec[ix], filter_value))
nvec.push_back(vec[ix]);
}
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;
}
int main() {
std::vector<int> big_vec;
int value;
//调用 函数指针指向less_than函数
std::vector<int> lt_10 = filter_ver1(big_vec, value, less_than);
bind函数，
std::bind1st std::bind2nd 就是将一个二元函数的一个参数设置为定值，这样二元函数就转换为了一元函数。因为有些算法的参数要求必须是一元函数，但是我们又想用二元函数，那么就可以使用这两个函数。其中在VS2015及以后的版本必须导入functional
#include <functional>
//定义一个按条件筛选的“过滤器”
std::vector<int> filter(const std::vector <int>&vec,
int val, std::less<int><) {
std::vector <int>nvec;
std::vector <int>::const_iterator iter = vec.begin();
//用Bind函数把比较算法的第2位参数给固定了，相当于是找出了所有less than val的值
while ( (iter = find_if(iter,vec.end(),std::bind2nd(lt,val)))!=vec.end() )
{ //只要iter!=vec.end(),就往nvec里面推入iter
nvec.push_back(*iter);
//移动iter
iter++;
}
return nvec;
}
更加泛型的写法，使得过滤器filter脱离了与vector容器类型的依赖关系。
对find_if的理解：
用一个while循环，但是整个容器里面的每个元素只遍历一遍。因为每次判断一个元素是否是大于/小于val后，first都加一，使得遍历的指针一直在移动。
template <typename InputIterator,typename OutputIterator,typename ElemType, typename Comp>
OutputIterator filter(InputIterator first,InputIterator last, OutputIterator at,const ElemType &val,Comp pred)
{
while ((first = find_if(first, last, std::bind2nd(pred, val))) != last)
//find和find_if的区别:后者是带条件的查找
{ //观察程序进行情况
std::cout << "found value:" << *first << std::endl;
//执行assign操作，先进行赋值，然后令两个iterator前进
*at++ = *first++;
}
return at;
}
//调用filter
int main() {
const int elem_size = 8;
int ia[elem_size] = { 12,8,43,0,6,21,3,7 };
std::vector <int>ivec(ia, ia + elem_size);
int ia2[elem_size];
std::vector<int> ivec2(elem_size);
//对array进行比小
std::cout << "filtering integer array for value leess than 8\n";
filter(ia, ia + elem_size, ia2, elem_size, std::less<int>());
//对vector进行比大
std::cout << "filtering integer vector for values greater than 8\n";
filter(ivec.begin(), ivec.end(), ivec2.begin(), elem_size, std::greater<int>());
}
方法二：先做一个vector副本，然后将副本排序，找到第一个大于val的值的位置，最后删除这个位置之后的所有的值，剩下的就全是小于val的值了。
std::vector<int> sub_vec(const std::vector<int> &vec, int val) {
std::vector<int> local_vec(vec); //制造了一份vec的副本
//等价于std::copy(vec.begin(),vec.end(),local_vec.begin());
std::sort(local_vec.begin(), local_vec.end());
//因为要找出所有小于的，所以只用找到第一个大于val的位置即可
std::vector<int>::iterator iter = find_if(local_vec.begin(),
local_vec.end(),
std::bind2nd(std::greater<int>(), val));
local_vec.erase(iter, local_vec.end());
}
改写成泛型格式
template<typename InputIterator,
typename ElemType,
typename Comp>
std::vector<ElemType> sub_T(InputIterator first,
InputIterator last,
const ElemType &val,
Comp pred)
{
std::vector<ElemType> temp_vec;
std::copy(first, last, temp_vec.begin());
sort(temp_vec.begin(),temp_vec.end() );
InputIterator iter = std::find_if(temp_vec.begin(), temp_vec.end(), std::bind2nd(pred, val));
std::vector<ElemType> temp_vec2(temp_vec.begin(), iter);
return temp_vec2;
}
6.map 字典
//输入map
#include <map>
#include <string>
#include <iostream>
int main() {
std::map<std::string, int>words;
words["vermeer"] = 1;
std::string tword;
std::string tword;
while (std::cin >> tword) {
words[tword]++;
}
}
索引
int count = 0;
if(!(count = words["vermeer"]))
这个写法的缺陷是如果关键字不在字典内，就会加入这个map中，然后value被设置为所属类型的默认值。
故使用如下find写法：
words.find("关键字");
//如果key在其中，find会返回一个iterator,指向key/value形成的一个pair.如果不在则返回end()
int count = 0;
map<string,int>::iterator it;
it = words.find("关键字");
if(it!=words.end())
count = it->second;
第三种查询方法使用count()函数，会返回查询的关键字在map中的个数：
int count = 0 ;
std::string serch_word("vermeer");
if(word.count(search_word))
count = words[search_word];
7.iterator inserter对容器的STD泛型操作
#include <string>
#include <vector>
#include <iterator>
#include <algorithm>
#include <list>
int main() {
std::vector<int> ivec;
std::vector<int>result_vec;
std::unique_copy(ivec.begin(), ivec.end(), back_inserter(result_vec));
//back_inserter会以push_back()函数取代assignment操作符
std::vector<int> svec;
std::vector<std::string>svec_res;
unique_copy(svec.begin(), svec.end(), inserter(svec_res, svec_res.end()));
//inserter(容器，插入操作起点)，容器制定位置插入
std::list<int>ilist;
std::list<int>ilist_clone;
copy(ilist.begin(), ilist.end(), front_inserter(ilist_clone));
//front_inserter以容器前项插入，push_front，适用于list和deque
}
要使用上述三种insertion adpter，必须包含头文件iterator和algorithm。
然而这些adapter不能用在array上，array不支持元素插入操作。
8.Iostream Iterator
用io迭代器读写数据：
#include <iostream>
#include <iterator>
#include <algorithm>
#include <vector>
#include <string>
int main() {
std::istream_iterator<std::string> is(std::cin);
std::istream_iterator<std::string> eof;
std::vector<std::string>text;
copy(is, eof, std::back_inserter(text));
std::sort(text.begin(), text.end());
std::ostream_iterator<std::string> os(std::cout, " ");
copy(text.begin(), text.end(), os);
}
如果不需要输出，而是从文件中读写，则用istream绑定 in_file,ostream绑定outfile
//e.g.
ifstream in_file("input_file.txt");
ofstream out_file("output_file.txt");
istream_iterator<string>is (in_file);
istream_iterator<string>eof;
vector<string>text;
copy(is,eof,back_inerter(text));
sort(text.begin(),text.end());
ostream_iterator<string> os(out_file,"");
copy(text.begin(),text.end(),os);
扫一扫
254
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
