当前位置： 代码迷 >> 综合 >> C++ Primer (第五版) 课后习题 Unit10
  详细解决方案

C++ Primer (第五版) 课后习题 Unit10

热度：82   发布时间：2024-03-08 23:56:22.0

10.1节练习

练习10.1

问题：头文件algorithm中定义了一个名为count的函数，它类似find， 接受一对迭代器和一个值作为参数。count返回给定值在序列中出现的次数。编写程序，读取int序列存入vector中，打印有多少个元素的值等于给定值

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <list>
using namespace std;int main() {vector<int> a={1,2,3,1,1,33,23,55,15,7,9};cout<<count(a.begin(),a.end(),1);cout<<endl;list<string> b={"av","ab","mqt","tv","mv","av"};cout<<count(b.begin(),b.end(),"av");return 0;
}

练习10.2

问题：重做上一题，但读取 string 序列存入 list 中

见上一题

10.2.1节练习

练习10.3

问题：用 accumulate求一个 vector<int> 中元素之和

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;int main() {vector<int> a={1,2,3,4};int sum=accumulate(a.begin(),a.end(),0);cout<<sum<<endl;return 0;
}

 

练习10.4

问题：假定 v 是一个vector<double>，那么调用 accumulate(v.cbegin(),v.cend(),0) 有何错误（如果存在的话）

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;int main() {vector<double> v={1.1,2.2,3,4.4};cout<<accumulate(v.begin(),v.end(),0);return 0;
}

会将double类型强制转换成int类型。会忽略小数点的值

练习10.5

问题：在本节对名册（roster）调用equal的例子中，如果两个名册中保存的都是C风格字符串而不是string，会发生什么？

将会比较提供的指针。C风格字符串并没有提供给其运算符比较， 而是定义了函数strcmp。

10.2.2节练习

练习10.6

问题：编写程序，使用 fill_n 将一个序列中的 int 值都设置为0

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;int main() {list<int> ilist={1,2,3,4,5};fill_n(ilist.begin(),ilist.size(),0);for(auto iter:ilist){cout<<iter<<" ";}return 0;
}

练习10.7

下面程序是否有错误？如果有，请改正。

(a) vector<int> vec; list<int> lst; int i;while (cin >> i)lst.push_back(i);copy(lst.cbegin(), lst.cend(), vec.begin());
(b) vector<int> vec;vec.reserve(10);fill_n(vec.begin(), 10, 0);

答：a）vec是一个空容器，不能向其中拷贝值。此时如果要拷贝，则要用back_inserter  插入迭代器才可以

b）虽然给vec分配了10的空间，但是里面还是没有元素，所以需要插入迭代器才可以

练习10.8

问题：本节提到过，标准库算法不会改变它们所操作的容器的大小。为什么使用 back_inserter不会使这一断言失效？

因为back_inserter不在标准库算法中，它是一个迭代器。定义在iterator中。

10.2.3节练习

练习10.9

问题：实现你自己的elimDups。分别在读取输入后、调用unique后以及调用erase后打印vector的内容

void elimDups(vector<string> &words){//先对它排序sort(words.begin(),words.end());//unique重排，使得范围内每一项只出现一次auto end_unique=unique(words.begin(),words.end());//删除重复项words.erase(end_unique,words.end());
}
int main() {vector<string> sv;
//从文件中读取ifstream input("/Users/jason/CLionProjects/C++p_u10_10.9/input");if(input.is_open()){string temp;while(input>>temp){sv.push_back(temp);}
//消除重复项操作elimDups(sv);}input.close();
//打印for(auto iter:sv){cout<<iter<<" ";}return 0;
}

练习10.10

问题：你认为算法不改变容器大小的原因是什么？

我认为是为了方便实现吧。如果算法要改变容器大小，必然需要对容器进行操作。那么可能会同时要实现算法，还要实现容器的增删改。也会增大程序的耦合度。使得代码独立性变差。

 

10.3.1节练习

练习10.11

问题：编写程序，使用 stable_sort 和 isShorter 将传递给你的 elimDups 版本的 vector 排序。打印 vector的内容，验证你的程序的正确性

int main() {vector<string> sv;ifstream input("/Users/jason/CLionProjects/C++p_u10_10.11/input");if(input.is_open()){string temp;while(input>>temp){sv.push_back(temp);}elimDups(sv);}input.close();stable_sort(sv.begin(),sv.end(),isShorter);for(auto iter:sv){cout<<iter<<" ";}return 0;
}

在10.9的基础上进行修改。

练习10.12

问题：编写名为 compareIsbn 的函数，比较两个 Sales_data 对象的isbn() 成员。使用这个函数排序一个保存 Sales_data 对象的 vector


bool compareIsbn(const Sales_item &a,const Sales_item &b){return a.Isbn()<b.Isbn();
}int main() {vector<Sales_item> sv{
   {"cd-mmd"},{"ak-ddl"},{"oj-ssm"},{"tl-shv"}};sort(sv.begin(),sv.end(),compareIsbn);for(const auto iter:sv){cout<<iter.Isbn()<<endl;}return 0;
}

练习10.13

问题：标准库定义了名为 partition 的算法，它接受一个谓词，对容器内容进行划分，使得谓词为true 的值会排在容器的前半部分，而使得谓词为 false 的值会排在后半部分。算法返回一个迭代器，指向最后一个使谓词为 true 的元素之后的位置。编写函数，接受一个 string，返回一个 bool 值，指出 string 是否有5个或更多字符。使用此函数划分 words。打印出长度大于等于5的元素

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;bool sizeMoreT5(const string &a){return a.size()<5;
}
int main() {vector<string> sv{"aa","fox","red","jumps","over","turtle","increase","abandon","thefox"};auto iter=partition(sv.begin(),sv.end(),sizeMoreT5);for(;iter!=sv.end();iter++){cout<<*iter<<" ";}return 0;
}

 

10.3.2节练习

练习10.14

问题：编写一个lambda，接受两个int，返回它们的和。

auto f=[](int a,int b){return a+b;};

练习10.15

问题：编写一个lambda，捕获它所在函数的int，并接受一个int参数。lambda返回捕获的int和int参数的和。

int a=10;
auto f=[a](int b){return a+b;};

练习10.16

问题：使用 lambda 编写你自己版本的 biggies

了解biggies的功能：

  1. 对一个字符向量排序
  2. 删除重复项
  3. 求大于给定长度的单词有多少
  4. 打印大于给定长度的单词
//这里自然可以定义一个isShorter函数，但是不能将sz实时的传入到函数中
//也就是我们输入的谓词，只能对vector中的string进行操作，但是无法和我们输入sz进行比较
void biggies(vector<string> &words,vector<string>::size_type sz){elimDups(words);//排序并删除重复项auto iter=partition(words.begin(),words.end(),[sz](string &a){return a.size()<sz;});//获取size>=sz的迭代器for(;iter!=words.end();iter++){cout<<*iter<<endl;}//将size>=sz的打印出来
}

练习10.17

问题：重写10.3.1节练习10.12的程序，在对sort的调用中使用 lambda 来代替函数 compareIsbn

#include <iostream>
#include <vector>
#include <algorithm>
#include "/Users/jason/CLionProjects/C++primer_unit1_class_Sales_item/Sales_item.h"
using namespace std;int main() {vector<Sales_item> sv{
   {"cd-mmd"},{"ak-ddl"},{"oj-ssm"},{"tl-shv"}};sort(sv.begin(),sv.end(),[](const Sales_item &a,const Sales_item &b){return a.Isbn()<b.Isbn();});for(auto iter:sv){cout<<iter<<endl;}return 0;
}

练习10.18

问题：重写 biggies，用 partition 代替 find_if。我们在10.3.1节练习10.13中介绍了 partition 算法

见10.16

 

练习10.19

问题：用 stable_partition 重写前一题的程序，与 stable_sort 类似，在划分后的序列中维持原有元素的顺序

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
void biggies(vector<string> &vs,string::size_type sz){//对序列进行排序sort(vs.begin(),vs.end());//删除重复项auto end_iter= unique(vs.begin(),vs.end());vs.erase(end_iter,vs.end());auto show_iter = stable_partition(vs.begin(),vs.end(),[sz](const string &s){return s.size()<sz;});for(auto iter=show_iter;iter!=vs.end();iter++){cout<<*iter<<endl;}
}int main() {vector<string> sv{"aa","fox","red","jumps","over","turtle","increase","abandon","thefox"};biggies(sv,6);return 0;
}

10.3.3节练习

练习10.20

问题：标准库定义了一个名为 count_if 的算法。类似 find_if，此函数接受一对迭代器，表示一个输入范围，还接受一个谓词，会对输入范围中每个元素执行。count_if返回一个计数值，表示谓词有多少次为真。使用count_if重写我们程序中统计有多少单词长度超过6的部分

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;int length_of_words_over6(vector<string> &vs){return count_if(vs.begin(),vs.end(),[](const string &a){return a.size()>=6;});
}
int main() {vector<string> sv{"aa","fox","red","jumps","over","turtle","increase","abandon","thefox"};cout<<length_of_words_over6(sv)<<endl;return 0;
}

练习10.21

问题：编写一个 lambda，捕获一个局部 int 变量，并递减变量值，直至它变为0。一旦变量变为0，再调用lambda应该不再递减变量。lambda应该返回一个bool值，指出捕获的变量是否为0

    int a=10;//说明是一次捕获，之后都可以使用它。f()里面拷贝的a一直在变，但是a本身没变auto f=[a]()mutable ->bool {return (a==0? true:!(--a));};while(f()==false)cout<<a<<endl;

上述程序的结果将10输出10遍，因为a本身没有变化。只是拷贝到lambda中的a从10减到了0

    auto f2=[&b]{return (b==0? true:!(--b));};while(!f2())cout<<b<<endl;

这个程序则是按照题目要求，每次对int值进行修改

 

10.3.4节练习

练习10.22

问题：重写统计长度小于等于6的单词数量的程序，使用函数代替lambda

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;bool length_6(const string &a){//如果长度小于等于6，就对其计数return a.size()<=6;
}//还可以通过将序列排序，然后找到第一个单词不小于6的位置，然后计算大小//使用函数替代
void length_of_word(const string &a,int &num){if(a.size()<=6)num++;
}int main() {vector<string> sv{"aa","fox","red","jumps","over","turtle","increase","abandon","thefox"};int sz=6;//使用可调用对象直接进行计算auto num=count_if(sv.begin(),sv.end(),length_6);auto f=[sz](const string &a){return a.size()>sz;};//size小于6auto g=[](const string &a,const string &b){return a.size()<b.size();};//使用lambdasort(sv.begin(),sv.end(),g);auto iter=find_if(sv.begin(),sv.end(),f);int size=iter-sv.begin();//这里为什么不用减去1，因为它总是向后统计一个，比如如果计算字符大于6的个数，就是用sv.end()-iter;sv.end是指向最后一个指针的下一个。//同样计算小于等于6，比如这里是第八个元素才不小于6的，然后用第八个元素的地址，减去第一个元素的地址，最后就是不大于6的元素个数。相当于8-1//使用函数int size2=0;for_each(sv.begin(),sv.end(),bind(length_of_word,placeholders::_1,ref(size2)));cout<<"size:"<<size<<endl;cout<<"size2:"<<size2<<endl;cout<<num<<endl;return 0;
}

练习10.23:

问题：bind接受几个参数？

如果函数接受n个参数，bind就接受n+1个参数

练习10.24:

问题：给定一个string，使用 bind 和 check_size 在一个 int 的vector 中查找第一个大于string长度的值

#include <iostream>
#include <string>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;
using namespace placeholders;bool check_size(const string &a,int &b){return b>a.size();
}int main() {vector<int> vi={1,2,3,4,5,6,7,8,9,10};string s="ace";auto iter=find_if(vi.begin(),vi.end(),bind(check_size,ref(s),_1));//这里的_1就是在绑定参数里的位置，而在bind中是按照函数顺序来排列的。cout<<*iter;return 0;
}

练习10.25

问题：在10.3.2节的练习中，编写了一个使用partition 的biggies版本。使用 check_size 和 bind 重写此函数

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
using namespace placeholders;bool bigger(const string &a,string::size_type size){return a.size()<size;
}
int main() {vector<string> sv{"aa","fox","red","jumps","over","turtle","increase","abandon","thefox"};auto iter=partition(sv.begin(),sv.end(),bind(bigger,_1,6));for(;iter!=sv.end();iter++){cout<<*iter<<endl;}return 0;
}

 

10.4.1节练习

练习10.26

问题：解释三种插入迭代器的不同之处。

三种迭代器分贝调用了容器的不同成员函数。

front_inserter:调用了push_front

back_inserter:调用了push_back

inserter:调用了insert方法

练习10.27

问题：除了 unique 之外，标准库还定义了名为 unique_copy 的函数，它接受第三个迭代器，表示拷贝不重复元素的目的位置。编写一个程序，使用 unique_copy将一个vector中不重复的元素拷贝到一个初始化为空的list中

#include <iostream>
#include <vector>
#include <algorithm>
#include <list>
using namespace std;int main() {vector<string> v_words{"marke","abc","bcd","def","msn","abc","hgk","marke","cc"};list<string> l_words;sort(v_words.begin(),v_words.end());unique_copy(v_words.begin(),v_words.end(),back_inserter(l_words));for(auto iter=l_words.begin();iter!=l_words.end();iter++){cout<<*iter<<endl;}return 0;
}

练习10.28

问题：一个vector 中保存 1 到 9，将其拷贝到三个其他容器中。分别使用inserter、back_inserter 和 front_inserter 将元素添加到三个容器中。对每种 inserter，估计输出序列是怎样的，运行程序验证你的估计是否正确

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <list>
using namespace std;int main() {vector<int> iv={1,2,3,4,5,6,7,8,9};vector<int> vc1,vc2;list<int> vl;copy(iv.begin(),iv.end(),inserter(vc1,vc1.begin()));copy(iv.begin(),iv.end(),back_inserter(vc2));copy(iv.begin(),iv.end(),front_inserter(vl));for(auto i:vc1){cout<<i<<" ";}cout<<endl;for(auto i:vc2){cout<<i<<" ";}cout<<endl;for(auto i:vl){cout<<i<<" ";}return 0;
}

注意这里使用头插法，要注意对象容器。像vector就不能使用头插。

 

10.4.2节练习

练习10.29:

问题：编写程序，使用流迭代器读取一个文本文件，存入一个vector中的string里

#include <iostream>
#include <vector>
#include <string>
#include <iterator>
#include <fstream>
using namespace std;int main() {vector<string> vs;ifstream ifs("/Users/jason/CLionProjects/C++p_u10_10.29/input");istream_iterator<string> input(ifs),eof;while(input!=eof){vs.push_back(*input++);}for(auto iter:vs){cout<<iter<<" ";}cout<<endl<<vs.size();ifs.close();return 0;
}

 

练习10.30

问题：使用流迭代器、sort 和 copy 从标准输入读取一个整数序列，将其排序，并将结果写到标准输出

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
using namespace std;int main() {istream_iterator<int> input(cin),eof;ostream_iterator<int> output(cout," ");vector<int> iv(input,eof);sort(iv.begin(),iv.end());copy(iv.begin(),iv.end(),output);return 0;
}

 

练习10.31

问题：修改前一题的程序，使其只打印不重复的元素。你的程序应该使用 unique_copy

//上一个题基础上假如这段代码即可
unique_copy(iv.begin(),iv.end(),output);

 

练习10.32

问题：重写1.6节中的书店程序，使用一个vector保存交易记录，使用不同算法完成处理。使用 sort 和10.3.1节中的 compareIsbn 函数来排序交易记录，然后使用 find 和 accumulate 求和

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iterator>
#include "/Users/jason/CLionProjects/C++primer_unit1_class_Sales_item/Sales_item.h"
using namespace std;bool compareIsbn(const Sales_item &a,const Sales_item &b){return a.Isbn()<b.Isbn();
}int main() {ifstream ifs("/Users/jason/CLionProjects/C++p_u10_10.32/input");istream_iterator<Sales_item> input(ifs),eof;ostream_iterator<Sales_item> output(cout);vector<Sales_item> vsi(input,eof);//将数据存入vector中sort(vsi.begin(),vsi.end(),compareIsbn); //对数据进行排序//将销售数据序列按照isbn码排列好了之后，此时需要对其求和打印auto beg=vsi.cbegin();auto end=beg;while(beg!=vsi.end()){end = find_if(beg,vsi.cend(),[beg](const Sales_item &item){return item.Isbn()!=beg->Isbn();});cout<<accumulate(beg,end,Sales_item(beg->Isbn()))<<endl;//用到了通过string来初始化的点beg=end;}return 0;
}

练习10.33

问题：编写程序，接受三个参数：一个输入文件和两个输出文件的文件名。输入文件保存的应该是整数。使用 istream_iterator 读取输入文件。使用 ostream_iterator 将奇数写入第一个输入文件，每个值后面都跟一个空格。将偶数写入第二个输出文件，每个值都独占一行

#include <iostream>
#include <fstream>
#include <iterator>
#include <vector>
using namespace std;int main() {char *file1="/Users/jason/CLionProjects/C++p_u10_10.33/input";char *file2="/Users/jason/CLionProjects/C++p_u10_10.33/output_1";char *file3="/Users/jason/CLionProjects/C++p_u10_10.33/output_2";ifstream input(file1);ofstream output_1(file2);ofstream output_2(file3);istream_iterator<int> in(input),eof;ostream_iterator<int> out1(output_1," "),out2(output_2,"\n");vector<int> iv(in,eof);auto iter=iv.cbegin(),end=iv.cend();while(iter!=end){if((*iter)%2)//奇数*out1++=*iter;else*out2++=*iter;iter++;}input.close();output_1.close();output_2.close();return 0;
}

 

10.4.3节练习

练习10.34

问题：使用 reverse_iterator 逆序打印一个vector

#include <iostream>
#include <iterator>
#include <vector>
using namespace std;int main() {vector<int> vec{1,2,4,5,6,7};for(auto iter=vec.crbegin();iter!=vec.crend();iter++){cout<<*iter<<" ";}return 0;
}

练习10.35

问题：使用普通迭代器逆序打印一个vector

#include <iostream>
#include <vector>int main() {std::vector<int> vec{1,2,34,5,6};auto iter=vec.cend();do{std::cout<<*(--iter)<<" ";}while(iter!=vec.cbegin());return 0;
}

练习10.36

问题：使用 find 在一个 int 的list 中查找最后一个值为0的元素

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;int main() {list<int> il{1,2,3,4,5,0,8,7};auto iter=find(il.crbegin(),il.crend(),0);cout<<*iter;return 0;
}

练习10.37

问题：给定一个包含10 个元素的vector，将位置3到7之间的元素按逆序拷贝到一个list中

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;int main() {vector<int> a{1,2,3,4,5,6,7,8,9,0};vector<int> c(a.begin()+2,a.begin()+7);list<int> b(c.crbegin(),c.crend());for(auto iter:b){cout<<iter<<endl;}return 0;
}

10.5.1节练习

练习10.38

问题：列出5个迭代器类别，以及每类迭代器所支持的操作

输入迭代器（istream_iterator）：==、!=、++、*、->

输出迭代器（ostream_iterator):++、*

前向迭代器（forward_list上的迭代器):==、!=、++、*、->

双向迭代器：==、!=、++、*、->、--

随机访问迭代器：==、!=、++、*、->、--、>、>=、<、<=、+=、-=、+、-、[](iter[n]等价于*iter[n]

练习10.39

问题：list 上的迭代器属于哪类？vector呢？

list:双向迭代器

vector：随机访问迭代器

练习10.40

问题：你认为 copy 要求哪类迭代器？reverse 和 unique 呢？

copy：输入迭代器和输出迭代器

reverse：双向迭代器

unique: 随机访问迭代器

10.5.3节练习

练习10.41:

问题：仅根据算法和参数的名字，描述下面每个标准库算法执行什么操作

replace(beg, end, old_val, new_val);
replace_if(beg, end, pred, new_val);
replace_copy(beg, end, dest, old_val, new_val);
replace_copy_if(beg, end, dest, pred, new_val);

1.将范围中值为old_val的替换为new_val

2.将范围中满足条件的值 替换为 new_val

3.将范围中值为old_value的替换为new_val并拷贝到dest中

4.将范围中满足条件的值替换为 new_val并拷贝到dest

 

10.6节练习

练习10.42

问题：使用 list 代替 vector 重新实现10.2.3节中的去除重复单词的程序

#include <iostream>
#include <list>
using namespace std;int main() {list<string> word{"marke","abc","bcd","def","msn","abc","hgk","marke","cc"};word.sort();word.unique();for(auto iter:word){cout<<iter<<endl;}return 0;
}

之前提到，list是直接对容器进行修改的，所以在unique中会直接对数据进行删除，而不像通用unique,会将重复项放到最后，然后返回不重复序列之后位置的迭代器。

  相关解决方案

代码迷 - 您身边的软件异常，代码异常，编程异常助手（发现，解决，分享）
Copyright © 2009-2013 DAIMAMI.COM. All rights reserved.