CH10 泛型算法

概述

大多数算法都定义在algorithm头文件中。

Note：算法永远不会执行容器操作

泛型算法本身不会执行容器的操作，而是通过迭代器来访问、修改等操作

10.1

题目要求读取数据存入vector,并实现用户可以查找的值出现在vector中的次数，所以可以考虑用户查找文件中某个数出现的次数，所以可以考虑文件操作

 int main(int argc, char* argv[])

 {

     ifstream infile(argv[]);

     if (!infile)

         cerr << "can not open the file!" << endl;

     vector <int> iv;

     int num;

     while (infile >> num)

         iv.push_back(num);

     cout << "please enter the number you want to find" << endl;

     int val;

     cin >> val;

     cout << "the count number " << val << " is :" << count(iv.begin(), iv.end(), val) << endl;

     system("pause");

     return ;

 }

10.2

同上，只是，程序区别大小写

 #include <iostream>

 #include <algorithm>

 #include <list>

 #include <string>

 #include <fstream>

 using namespace std;

 int main(int argc, char*argv[])

 {

     ifstream infile(argv[]);

     if (!infile)

     {

         cerr << "can not open the file,please check" << endl;

         return -;

     }

     list<string>sl;

     string words;

     while (infile >> words)

         sl.push_back(words);

     string word;

     cout << "please enter the word you want to count" << endl;

     cin >> word;

     cout <<"the number of  "<<word<<" is :"<< count(sl.begin(), sl.end(), word) << endl;

 }

只读算法

对于只读算法，通常最好使用cbegin()和cend(),但是如果用算法返回的迭代器来改变元素的值，就需要使用begin()和end()的结果作为参数

那些只接受一个单一迭代器来表示第二个序列的算法，都家丁第二个序列至少与第一个序列一样长。

10.3

accumulate(iv.begin(),iv.end(),0)

10.4

accumulate()将第三个参数作为求和的起点，序列中的元素的类型与第三个参数类型匹配，这里第三个是int型，所以前两个会被转换为int型。

写容器算法

一些算法从两个序列中读取元素。构成这两个序列的元素可以来自于不同类型的容器。例如，第一个序列可能保存于一个vector，而第二个可能保存于一个list、deque，内置数组或其他容器中。而且，两个序列中元素的类型也不要求严格匹配。

算法不检查写操作

 fill_n(vec.begin(), vec.size(), );//将所有元素重置为0

back_insert：接受一个容器的引用，返回一个与该容器绑定的插入迭代器，当通过此迭代器赋值时，赋值运算符会调用push_back将一个具有给定值的元素添加到容器中

 vector<int> vec;

     auto it = back_insert(vec);//通过它赋值会将元素添加到vector中

     *it = ;//vec 中现在有一个元素42

copy算法：向目的位置的迭代器指向的输出序列中元素写入数据，接受三个迭代器，一对输入范围，第三个目的序列其实位置。

 //使用copy实现内置数组的拷贝

     int a1[] = { ,,,,,,,,, };

     int a2[sizeof(a1) / sizeof(*a1)];//a2与a1大小相同

     auto ret = copy(a1, begin(), a1.end(), a2);//使用copy将a1内容拷贝给a2，ret指向拷贝到

     //a2的尾元素之后的位置

重排容器元素的算法

sort:接受一对迭代器，表示排序的范围，按字典顺序排序

unique 重排输入范围，使得每个单词只出现一次

插入迭代器

插入迭代器（insert iterator）迭代器适配器，接受一个容器，生成一个迭代器，该迭代器使用容器操作箱给定容器添加元素。有3个创建插入迭代器的模板：

back_inserter:在类型为T的容器末尾添加元素，创建一个使用push_back的迭代器

front_inserter :容器头部插入元素，创建一个使用push_front的迭代器

inserter:创建一个insert的迭代器，该函数接受两个参数，第二个参数是一个指向容器的迭代器，元素被插入到给定迭代器表示的元素之前

当调用inserter（c,iter）时，c是绑定的容器，得到一个迭代器，使用它时，会将元素插入到iter原来所指向的元素之前的位置。如果it是由inserter生成的迭代器，则下面的语句

    *it = val;

效果与下面代码一样

it = c.insert(it, val);

    ++it;

front_inserter生成的迭代器的行为与inserter生成迭代器不同，front_inserter总是插入到容器的第一个元素之前。

 #include <iostream>

 #include <vector>

 #include <list>

 #include <algorithm>

 #include <iterator>

 using namespace std;

 int main()

 {

     vector<int> iv1 = { ,,,, };

     vector<int>iv2;

     vector<int>iv3;

     vector<int> iv4 = { , };

     copy(iv1.cbegin(), iv1.cend(), back_inserter(iv2));

     for (auto it : iv2)

         cout << it << " ";

     cout << endl;

     copy(iv1.cbegin(), iv1.cend(), inserter(iv4, iv4.begin()));

     for (auto it : iv4)

         cout << it << " ";

     cout << endl;

     copy(iv1.cbegin(), iv1.cend(), inserter(iv3, iv3.begin()));

     for (auto it : iv3)

         cout << it << " ";

     cout << endl;

     list<int> il1 = { ,,,, };

     list<int>il2;

     list<int>il3;

     copy(il1.cbegin(), il1.cend(), front_inserter(il2));

     for (auto it : il2)

         cout << it << " ";

     cout << endl;

     copy(il1.cbegin(), il1.cend(), inserter(il3, il3.begin()));

     for (auto it : il3)

         cout << it << " ";

     cout << endl;

     system("pause");

     return ;

 }

iostream 迭代器

iostream类型不是容器，标准库定义了可用于这些IO类型对象的迭代器

istream_iterator :读取输入流，

ostream_iterator: 想一个输出流写数据

创建一个流迭代器时，必须指定迭代器将要读写的数据的类型。一个istream_iterator使用>>读取流，所以istream_iterator要读取的数据类型必须定义了输入运算符>>.

istream_iterator<int> int_it(cin);//从cin读取int

istream_iterator<int> int_eof;//默认初始化迭代器，初始化为尾后迭代器

ifstream infile("a_file");

    istream_iterator<string> str_it(infile);//使用istream_iterator从a_file读取数据

下面是一个使用istream_iterator从cin读取数据存入vector 的例子

 istream_iterator<int> in_iter(cin);

     istream_iterator<int>eof;

     vector<int>vec;

     while (in_iter != eof)

         vec.push_back(*in_iter++);

测试结果

使用迭代器范围更为简洁

vector<int>vec(in_iter, eof);

测试结果

使用算法操作流迭代器

使用一对istream_iterator 调用accumulate：

istream_iterator<int> in_iter(cin);

    istream_iterator<int>eof;

    cout << accumulate(in_iter, eof, ) << endl;

此调用会计算从标准输入读取的值的和。

ostream_iterator操作

可以对任何具有输出运算符<<的类型定义ostream_iterator。当创建一个ostream_iterator时，可以提供第二个参数。

ostream_iterator<T>out(os);//out将类型为T的值写到输出流os中

    ostream_iterator<T>out(os, d);//out将类型为T的值写到输出流os中，每个值后面都输出一个d，d指向一个

    //空字符串结尾的字符数组

使用ostream_iterator输出序列

ostream_iterator<int> out_iter(cout, " ");

    for (auto e : vec)

        *out_iter++ = e;//赋值语句将元素写入到cout

    cout << endl;

当向out_iter赋值时，可以忽略解引用和递增运算，即，循环可以写成下面这样

for (auto e : vec)

        out_iter = e;//赋值语句将元素写入到cout

    cout << endl;

但是推荐第一种形式，流迭代器的使用和其它迭代器的使用保持一致

//调用copy打印，比循环更简洁

    copy(vec.begin(), vec.end(), out_iter);

    cout << endl;

10.29

 #include <iostream>

 #include <vector>

 #include <string>

 #include <iterator>

 #include <fstream>

 using namespace std;

 int main(int argc, char*argv[])

 {

     ifstream infile(argv[]);

     if (!infile)

     {

         cerr << "can not open the file" << endl;

         return -;

     }

     istream_iterator<string>str_in_iter(infile);//从输入文件流infile读取数据

     istream_iterator<string>eof;

     vector<string>svec(str_in_iter, eof);

     ostream_iterator<string>str_out_iter(cout, " ");

     for (auto e : svec)

         *str_out_iter++ = e;

     cout << endl;

     system("pause");

     return ;

 }

测试结果

10.30 10.31

 #include <iostream>

 #include <vector>

 #include <fstream>

 #include <algorithm>

 #include <iterator>

 using namespace std;

 int main()

 {

     istream_iterator<int> in_it(cin);

     istream_iterator<int> eof;

     vector<int>iv;

     while (in_it != eof)

         iv.push_back(*in_it++);

     sort(iv.begin(), iv.end());

     ostream_iterator<int>out_it(cout, " ");

     copy(iv.begin(), iv.end(), out_it);

     cout << endl;

     //10.31

     unique_copy(iv.begin(), iv.end(), out_it);

     system("pause");

     return ;

 }

10.33

 #include <iostream>

 #include <iterator>

 #include <fstream>

 using namespace std;

 int main(int argc, char*argv[])

 {

     if (argc != )

         cerr << " the number of files is not correct" << endl;

     ifstream infile(argv[]);

     if (!infile)

     {

         cerr << "can not open the file " << endl;

         return -;

     }

     ofstream odd_out(argv[]);

     if (!odd_out)

         cerr << "can not open the file or the file does not exist" << endl;

     ofstream even_out(argv[]);

     if(!even_out)

        cerr << "can not open the file or the file does not exist" << endl;

     istream_iterator<int> in_iter(infile);

     istream_iterator<int> eof;

     /*ostream_iterator<int>out_iter_odd(cout, " ");

     ostream_iterator<int>out_iter_even(cout, " ");*/

     ostream_iterator<int>out_iter_odd(odd_out, " ");

     ostream_iterator<int>out_iter_even(even_out, " ");

     while (in_iter != eof)

     {

         if (*in_iter % )

             *out_iter_odd++ = *in_iter;

         else

             out_iter_even++ = *in_iter;

         in_iter++;

     }

     system("pause");

     return ;

 }

巴特西

CH10 泛型算法

最新文章

热门文章