devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++ Primer (第五版) 课后习题 Unit9_变的容器变量, elem是一个对象,则c1+=ele和c2+=elem的作用分别是什么?

作者：Cpp五条 | 2024-03-02 01:46:00

赞

踩

变的容器变量, elem是一个对象,则c1+=ele和c2+=elem的作用分别是什么?

9.1节练习

练习9.1

问题：对于下面的程序任务，vector、deque和list哪种容器最为适合？解释你的选择的理由。如果没有哪一种容器优于其他容器，也请解释理由。

  • (a) 读取固定数量的单词，将它们按字典序插入到容器中。我们将在下一章中看到，关联容器更适合这个问题。
  • (b) 读取未知数量的单词，总是将单词插入到末尾。删除操作在头部进行。
  • (c) 从一个文件读取未知数量的整数。将这些数排序，然后将它们打印到标准输出

答：

a）这个访问起来并不会有下标的帮助。所以还是需要顺序访问。那么此时在任何位置插入似乎就是它的亮点。我选择list

b）我选择deque。因为插入只在尾部。所以不选deque。又因为有对头部的删除，不选vector

c）我选择vector，可以很容易的追加数据。且不需要删除操作。

9.2节练习

练习9.2

问题：定义一个list对象，其元素类型是int的deque

list<deque<int>> la;

9.2.1节练习

练习9.3

问题：构成迭代器范围的迭代器有哪些限制？

迭代器指向同一个容器中的元素，或者是容器最后一个元素的后面位置

可以通过反复递增begin来达到end，end不在begin之前

练习9.4

问题：编写函数，接受一对指向vector<int>的迭代器和一个int值。在两个迭代器指定的范围中查找给定的值，返回一个布尔值来指出是否找到。

  1. #include <iostream>
  2. #include<vector>
  3.  
  4. using std::vector;
  5. using std::cout;
  6.  
  7. bool if_find(vector<int>::iterator begin,vector<int>::iterator end,int b){
  8.     for(auto v=begin;v!=end;v++){
  9.         if(*v==b)
  10.             return true;
  11.     }
  12.     return false;
  13. }
  14. int main() {
  15.     vector<int> fi={3,4,5,6,8};
  16.     int i=5;
  17.     cout<<if_find(fi.begin(),fi.end(),i);
  18.     return 0;
  19. }

 

练习9.5

问题：重写上一题的函数，返回一个迭代器指向找到的元素。注意，程序必须处理未找到给定值的情况。

  1. #include <iostream>
  2. #include<vector>
  3.  
  4. using std::vector;
  5. using std::cout;
  6.  
  7. vector<int>::iterator if_find(vector<int>::iterator begin,vector<int>::iterator end,int b){
  8.     auto v=begin;
  9.     for( v=begin;v!=end;v++){
  10.         if(*v==b)
  11.             return v;
  12.     }
  13.     return v;
  14. }
  15. int main() {
  16.     vector<int> fi={3,4,5,6,8};
  17.     int i=5;
  18.     auto v=if_find(fi.begin(),fi.end(),i);
  19.     if(v!=fi.end())
  20.         cout<<*if_find(fi.begin(),fi.end(),i);
  21.     return 0;
  22. }

练习9.6

问题：下面程序有何错误，应该如何修改？

  1. list<int> lst1;
  2. list<int>::iterator iter1 =lst1.begin(),iter2=lst1.end();
  3. while(iter1<iter2)...

答：循环应该使用iter1!=iter2

 

9.2.2节练习

练习9.7

问题：为了索引int的vector中的元素，应该使用什么类型？

答：vector<int>::size_type;

练习9.8

问题：为了读取string的list中的元素，应该使用什么类型？如果写入list，又应该使用什么类型？

写入：list<string> :: value_type  ❌   list<string>::iterator

读取：list<string>::const_reference

 

9.2.3节练习

练习9.9

问题：begin和cbegin两个函数有什么不同？

返回值不同，begin既可以返回const也可返回非const而这取决于引用它的对象是否是const的。

而cbegin只返回const的迭代器

练习9.10

问题：下面四个对象分别是什么类型？

  1. vector<int> v1;
  2. const vector<int> v2;
  3. auto it1 = v1.begin(), it2 = v2.begin();
  4. auto it3 = v1.cbegin(), it4 = v2.cbegin();

it1 vector<int> iterator;

it2 const vector<int> iterator;

it3 const vector<int> iterator;

it4 const vector<int> iterator;

9.2.4节练习

练习9.11

问题：对6种创建和初始化vector对象的方法，每一种都给出一个实例。解释每个vector包含什么值。

vector<int>  ivec1={10,10,10};//列表初始化，ivec是由三个int值组成的

vector<int> ivec2(3);//值初始化，ivec由3个int值为0的数组成

vector<int> ivec3(ivec1);//拷贝初始化 

vector<int> ivec4(10,-1);//构造函数初始化

vector<int> ivec5(ivec4.begin(),ivec4.end);//构造函数，输入一对指向同一个对象的两个迭代器，也可以是不同类型

vector<int> ivec6;//构造一个空的容器

练习9.12

问题：对于接受一个容器创建其拷贝的构造函数，和接受两个迭代器创建拷贝的构造函数，解释它们的不同

答：

对于接受一个容器创建其拷贝的构造函数而言，该容器必须和拷贝对象的容器类型相同，而且元素类型也必须一致。

对于接受两个迭代器创建拷贝的构造函数，不要求容器类型相同，而且新容器和原容器元素类型也可能不同，只要能将拷贝元素转换为要初始化的容器元素即可。这一种array不允许。❎

练习9.13

问题：如何从一个list<int>初始化一个vector<double>？从一个vector<int>又该如何创建？编写代码验证你的答案

list<int> a(4,5);

vector<double> vec(a.begin(),a.end());

vector<int> b(4,5);

vector<double> vec(b.begin(),b.end());

9.2.5节练习

练习9.14

问题：编写程序，将一个list中的char *指针元素赋值给一个vector中的string

  1.  
  2. #include <iostream>
  3. #include<list>
  4. #include<string>
  5. #include<vector>
  6. using namespace std;
  7.  
  8. int main() {
  9.  
  10.     list<char*> slist={"aa","bb","cc","dd","ee"};
  11.     vector<string> svec(slist.begin(),slist.end());
  12.     for(const auto &i:svec){
  13.         cout<<i;
  14.     }
  15.     vector<string> svec2;
  16.     //assign也可实现这个要求
  17.     svec2.assign(slist.cbegin(),slist.cend());
  18.     for(const auto &i:svec2){
  19.         cout<<i<<endl;
  20.     }
  21.     return 0;
  22. }

9.2.7节练习

练习9.15

问题：编写程序，判定两个vector<int>是否相等。

  1. /*
  2.  * 编写程序，判定两个vector<int>是否相等。
  3.  */
  4. #include <iostream>
  5. #include <vector>
  6. using namespace std;
  7.  
  8. bool equals(const vector<int>  &a,const vector<int>  &b){
  9.     return a==b;
  10. }
  11. int main() {
  12.     vector<int> v1={1,3,5,7};
  13.     vector<int> v2={1,3,5,7};
  14.     vector<int> v3={1,3,5,7,9,11};
  15.  
  16.     cout<<"v1==v2?:"<<equals(v1,v2)<<endl;
  17.     cout<<"v1==v3?:"<<equals(v1,v3)<<endl;
  18.     return 0;
  19. }

练习9.16

问题：重写上一题的程序，比较一个list中的元素和一个vector中的元素

  1. /*
  2.  * 重写上一题的程序，比较一个list<int>中的元素和一个vector<int>中的元素
  3.  */
  4. #include <iostream>
  5. #include <vector>
  6. #include <list>
  7. using namespace std;
  8.  
  9. bool equals(const vector<int>  &a,const vector<int>  &b){
  10.     return a==b;
  11. }
  12. bool equals(const int &a, const int &b){
  13.     return a==b;
  14. }
  15. int main() {
  16.     vector<int> v1={1,3,5,7};
  17.     vector<int> v2={1,3,5,7};
  18.     vector<int> v3={1,3,5,7,9,11};
  19.  
  20.     cout<<"v1==v2?:"<<equals(v1,v2)<<endl;
  21.     cout<<"v1==v3?:"<<equals(v1,v3)<<endl;
  22.  
  23.     vector<int> list1={1,2,3,4};
  24.     cout<<"v1[0]==list1[0]:"<<equals(v1[0],list1[0])<<endl;
  25.     cout<<"v1[1]==list1[1]:"<<equals(v1[1],list1[1])<<endl;
  26.  
  27.     std::list<int>      li{ 1, 2, 3, 4, 5 };
  28.     std::vector<int>    vec2{ 1, 2, 3, 4, 5 };
  29.     std::vector<int>    vec3{ 1, 2, 3, 4 };
  30.  
  31.     std::cout << (std::vector<int>(li.begin(), li.end()) == vec2 ? "true" : "false") << std::endl;//通过逐个元素进行比较
  32.     std::cout << (std::vector<int>(li.begin(), li.end()) == vec3 ? "true" : "false") << std::endl;
  33.     //说明这两个容器中的元素相等
  34.     
  35.     return 0;
  36. }

练习9.17

问题：假定c1和c2是两个容器，下面的比较操作有何限制？

c1<c2

答：关系运算符左右两边的运算对象必须是相同类型的容器，且必须保存相同类型的元素。

元素类型要支持相关操作。

 

9.3.1节练习

练习9.18

问题：编写程序，从标准输入读取string序列，存入一个deque中。编写一个循环，用迭代器打印deque中的元素

  1. #include <iostream>
  2. #include <string>
  3. #include <deque>
  4. using namespace std;
  5. int main() {
  6.     string temp;
  7.     deque<string> sde;
  8.  
  9.     while(cin>>temp){
  10.         sde.push_back(temp);
  11.     }
  12.     for(const auto vec:sde){
  13.         cout<<vec<<endl;
  14.     }
  15.     return 0;
  16. }

 

练习9.19

问题：重写上一题的程序，用list替代deque。列出程序要做出哪些改变

答：只需要将deque替换成list即可。程序不需要做任何改变

 

练习9.20 

问题：编写程序，从一个list<int>拷贝元素到两个deque中。值为偶数的所有元素都拷贝到一个deque中，而奇数值元素都拷贝到另一个deque中

  1. #include <iostream>
  2. #include <list>
  3. #include <deque>
  4. using namespace std;
  5. int main() {
  6.     list<int> il={1,2,3,4,5};
  7.     deque<int> ou,ji;
  8.     for(auto vec=il.begin();vec!=il.end();vec++){
  9.         if((*vec)%2==0)
  10.             ou.push_back(*vec);
  11.         else
  12.             ji.push_back(*vec);
  13.     }
  14.     for(auto vec=ou.begin();vec!=ou.end();vec++)
  15.         cout<<*vec<<" ";
  16.     cout<<endl;
  17.     for(auto vec=ji.begin();vec!=ji.end();vec++)
  18.         cout<<*vec<<" ";
  19.     return 0;
  20. }

 

练习9.21

问题：如果我们将第308页中使用insert返回值将元素添加到list中的循环程序改写为将元素插入到vector中，分析循环将如何工作

循环没有什么变化。

 

练习9.22

问题：假定iv是一个int的vector，下面的程序存在什么错误？你将如何修改？

  1. vector<int>::iterator iter = iv.begin(),
  2. 					  mid = iv.begin() + iv.size() / 2;
  3. while (iter != mid)
  4. 	if (*iter == some_val)
  5. 		iv.insert(iter, 2 * some_val);

答：循环没有增量，会变成永久的循环

我会改成：while(++iter!=mid)

还有对于vector插入，需要将插入后面的值都往后移动。也就是说，每当它插入以后，当前的迭代器所指的元素就是插入位置的元素。如此使用++以后，又回满足条件。于是会形成无限插入。此时我们可以在每次成功插入后对迭代器加一

最终程序为：

  1. while (++iter != mid)
  2. 	if (*iter == some_val){
  3. 		iv.insert(iter, 2 * some_val);
  4.         iter++;
  5. }

9.3.2节练习

练习9.23

问题：在本节第一个程序中，若c.size() 为1，则val、val2、val3和val4的值会是什么？

说明容器中只有一个值。那么val=val2=val3=val4 = 这个值

 

练习9.24

问题：编写程序，分别使用at、下标运算符、front 和 begin 提取一个vector中的第一个元素。在一个空vector上测试你的程序

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  4.  
  5. int main() {
  6.     vector<int> ivec{1,2,3,4 };
  7.     vector<int> ivec2;
  8.     int val1=ivec.front();//1
  9.     int val2=ivec.back();//4
  10.     int val3=ivec.at(1);//2
  11.     int val4=ivec[2];//3
  12.  
  13.     int nval1=ivec2.front();//exc_bad_access 访问错误
  14.     int nval2=ivec2.back();//exc_bad_access  访问错误
  15.     int nval3=ivec2[0];//exc_bad_access  访问错误
  16.     int nval4=ivec2.at(0);//out_of_range
  17.  
  18.     cout<<val1<<val2<<val3<<val4<<endl;
  19.     cout<<nval1<<nval2<<nval3<<nval4;
  20.     return 0;
  21. }

nval1:

直接弹出错误，无法执行。

 

9.3.3节练习

练习9.25

问题：对于第312页中删除一个范围内的元素的程序，如果 elem1 与 elem2 相等会发生什么？如果 elem2 是尾后迭代器，或者 elem1 和 elem2 皆为尾后迭代器，又会发生什么？

答：根据测试，如果elem1==elem2，则不会删除。如果elem2是尾后迭代器，则返回尾后迭代器。如果elem1和elem2都为尾后迭代器，则不会删除，且返回尾后迭代器。

 

练习9.26

问题：使用下面代码定义的ia，将ia拷贝到一个vector和一个list中。使用单迭代器版本的erase从list中删除奇数元素，从vector中删除偶数元素

int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };
  1. #include <iostream>
  2. #include <vector>
  3. #include <list>
  4. using namespace std;
  5.  
  6.  
  7. int main() {
  8.     int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };
  9.     vector<int> ivec;
  10.     list<int> il;
  11.  
  12.     ivec.assign(&ia[0],&ia[sizeof(ia)/sizeof(int)]);
  13.     il.assign(&ia[0],&ia[sizeof(ia)/sizeof(int )]);
  14.  
  15.     for(auto iter=ivec.begin();iter!=ivec.end();){
  16.         if(*iter%2==0){
  17.             iter=ivec.erase(iter);
  18.             continue;
  19.         }else
  20.             iter++;
  21.     }
  22.     for(auto iter=il.begin();iter!=il.end();){
  23.         if(*iter%2==1){
  24.             iter=il.erase(iter);
  25.             continue;
  26.         }else
  27.             iter++;
  28.     }
  29.     for(auto iter:ivec){
  30.         cout<<iter<<" ";
  31.     }
  32.     cout<<endl;
  33.     for(auto iter:il){
  34.         cout<<iter<<" ";
  35.     }
  36.  
  37.     return 0;
  38. }

9.3.4节练习：

练习9.27:

问题：编写程序，查找并删除forward_list<int>中的奇数元素

  1. #include <iostream>
  2. #include <forward_list>
  3. using namespace std;
  4. int main() {
  5.     forward_list<int> fli={1,2,3,4,5,6,7,8,9};
  6.  
  7.     auto beforeB=fli.before_begin();
  8.     for(auto iter=fli.begin();iter!=fli.end();){
  9.         if(*iter%2==1){
  10.             iter=fli.erase_after(beforeB);
  11.         }else{
  12.             beforeB=iter;
  13.             iter++;
  14.         }
  15.     }
  16.     for(auto iter:fli){
  17.         cout<<iter<<" ";
  18.     }
  19.     return 0;
  20. }

练习9.28

问题：编写函数，接受一个forward_list<string>和两个string共三个参数。函数应在链表中查找第一个string，并将第二个string插入到紧接着第一个string之后的位置。若第一个string未在链表中，则将第二个string插入到链表末尾。

  1. #include <iostream>
  2. #include <forward_list>
  3. #include <string>
  4. using namespace std;
  5.  
  6. void compare_insert(forward_list<string> &forw,string a,string b){
  7.     auto beforeB=forw.before_begin();
  8.     for(auto iter=forw.begin();iter!=forw.end();){
  9.         if(a==*iter){
  10.             forw.insert_after(iter,b);
  11.             break;
  12.         }else{
  13.             beforeB=iter;
  14.             if(++iter==forw.end()){
  15.                 forw.insert_after(beforeB,b);
  16.             }
  17.         }
  18.     }
  19. }
  20. int main() {
  21.     forward_list<string> fls={"aa","bb","cc"};
  22.     string a="bb";
  23.     string b="mm";
  24.     string d="hh";
  25.     compare_insert(fls,a,b);
  26.     for(auto iter:fls){
  27.         cout<<iter<<" ";
  28.     }
  29.     return 0;
  30. }

9.3.5节练习

练习9.29

问题：假定vec包含25个元素，那么vec.resize(100)会做什么？如果接下来调用vec.resize(10)会做什么？

答：调用之后，会将vec大小调整为100个元素，并且对于其中每个值进行值初始化

vec会将大小调整为10，后面的90个元素会被丢弃

练习9.30

问题：接受单个参数的resize版本对元素类型有什么限制（如果有的话）？

答：元素类型可以自行进行默认初始化，如果是类类型，则必须要有默认构造函数

9.3.6节练习

练习9.31

问题：第316页中删除偶数值元素并复制奇数值元素的程序不能用于list或forward_list。为什么？修改程序，使之也能用于这些类型

答：可以，因为list和forward_list有增添值和删除值的操作

  1. #include <iostream>
  2. #include <forward_list>
  3. #include <string>
  4. using namespace std;
  5.  
  6. void compare_insert(forward_list<string> &forw,string a,string b){
  7.     auto beforeB=forw.before_begin();
  8.     for(auto iter=forw.begin();iter!=forw.end();){
  9.         if(a==*iter){
  10.             forw.insert_after(iter,b);
  11.             break;
  12.         }else{
  13.             beforeB=iter;
  14.             if(++iter==forw.end()){
  15.                 forw.insert_after(beforeB,b);
  16.             }
  17.         }
  18.     }
  19. }
  20. int main() {
  21.     forward_list<string> fls={"aa","bb","cc"};
  22.     string a="bb";
  23.     string b="mm";
  24.     string d="hh";
  25.     compare_insert(fls,a,b);
  26.     for(auto iter:fls){
  27.         cout<<iter<<" ";
  28.     }
  29.     cout<<endl;
  30.     compare_insert(fls,d,b);
  31.     for(auto iter:fls){
  32.         cout<<iter<<" ";
  33.     }
  34.     return 0;
  35. }

练习9.32

问题：在第316页的程序中，像下面语句这样调用insert是否合法？如果不合法，为什么？

iter=vi.insert(iter,*iter++)

不合法，究竟将iter插入到哪里是未知的。

 

练习9.33

问题：在本节最后一个例子中，如果不将insert的结果赋予begin，将会发生什么？编写程序，去掉此赋值语句，验证你的答案。

答：如果不将insert结果赋值给beigin，那么begin将会变成无效迭代器。

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  4.  
  5. int main() {
  6.     vector<int> vec1={1,3,4};
  7.     auto begin = vec1.begin();
  8.     while(begin!=vec1.end()){
  9.         if(*begin==3){
  10.             ++begin;
  11. //            vec1.insert(begin,10);
  12.             begin=vec1.insert(begin,10);
  13.             ++begin;
  14.         }else
  15.             ++begin;
  16.     }
  17.     for(auto iter:vec1){
  18.         cout<<iter<<" ";
  19.     }
  20.     return 0;
  21. }

去掉此赋值语句，发现多插入了一个10

练习9.34

问题：假定vi是一个保存int的容器，其中有偶数值也有奇数值，分析下面循环的行为，然后编写程序验证你的分析是否正确。

  1. iter = vi.begin();
  2. while (iter != vi.end())
  3. 	if (*iter % 2)
  4. 		iter = vi.insert(iter, *iter);
  5. 	++iter;

这个循环在第一次遇到一个奇数的时候，就会一直复制该奇数值。且是一个无限循环。

9.4节练习

练习9.35

问题：解释一个vector的capacity和size有何区别

答：capacity指的是容器在不扩张内存下，可以容纳多少元素

size则是说明了当前容器中有多少个元素。

练习9.36

问题：一个容器的capacity可能小于它的size吗？

答：不可能，因为capacity代表着这个容器可容纳的元素，这个容器实际元素不能小于它所能容纳的元素大小。

练习9.37

为什么list或array没有capacity成员函数？

因为array是固定大小的。而list是通过单次插入来实现的，它属于链表。所以不需要分配一段连续空间。

练习9.38

问题：编写程序，探究在标准库实现中，vector是如何增长的

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  4.  
  5. int main() {
  6.      vector<int> svec1;
  7.     for(vector<int>::size_type ix=0;ix!=100;++ix){
  8.         svec1.push_back(ix);
  9.         cout<<"capacity:  "<<svec1.capacity()<<"   size:"<<svec1.size()<<endl;
  10.     }
  11. }

输出：

capacity:  1   size:1
capacity:  2   size:2
capacity:  4   size:3
capacity:  4   size:4
capacity:  8   size:5
capacity:  8   size:6
capacity:  8   size:7
capacity:  8   size:8
capacity:  16   size:9
capacity:  16   size:10
capacity:  16   size:11
capacity:  16   size:12
capacity:  16   size:13
capacity:  16   size:14
capacity:  16   size:15
capacity:  16   size:16
capacity:  32   size:17
capacity:  32   size:18
capacity:  32   size:19
capacity:  32   size:20
capacity:  32   size:21
capacity:  32   size:22
capacity:  32   size:23
capacity:  32   size:24
capacity:  32   size:25
capacity:  32   size:26
capacity:  32   size:27
capacity:  32   size:28
capacity:  32   size:29
capacity:  32   size:30
capacity:  32   size:31
capacity:  32   size:32
capacity:  64   size:33
capacity:  64   size:34
capacity:  64   size:35
capacity:  64   size:36
capacity:  64   size:37
capacity:  64   size:38
capacity:  64   size:39
capacity:  64   size:40
capacity:  64   size:41
capacity:  64   size:42
capacity:  64   size:43
capacity:  64   size:44
capacity:  64   size:45
capacity:  64   size:46
capacity:  64   size:47
capacity:  64   size:48
capacity:  64   size:49
capacity:  64   size:50
capacity:  64   size:51
capacity:  64   size:52
capacity:  64   size:53
capacity:  64   size:54
capacity:  64   size:55
capacity:  64   size:56
capacity:  64   size:57
capacity:  64   size:58
capacity:  64   size:59
capacity:  64   size:60
capacity:  64   size:61
capacity:  64   size:62
capacity:  64   size:63
capacity:  64   size:64
capacity:  128   size:65
capacity:  128   size:66
capacity:  128   size:67
capacity:  128   size:68
capacity:  128   size:69
capacity:  128   size:70
capacity:  128   size:71
capacity:  128   size:72
capacity:  128   size:73
capacity:  128   size:74
capacity:  128   size:75
capacity:  128   size:76
capacity:  128   size:77
capacity:  128   size:78
capacity:  128   size:79
capacity:  128   size:80
capacity:  128   size:81
capacity:  128   size:82
capacity:  128   size:83
capacity:  128   size:84
capacity:  128   size:85
capacity:  128   size:86
capacity:  128   size:87
capacity:  128   size:88
capacity:  128   size:89
capacity:  128   size:90
capacity:  128   size:91
capacity:  128   size:92
capacity:  128   size:93
capacity:  128   size:94
capacity:  128   size:95
capacity:  128   size:96
capacity:  128   size:97
capacity:  128   size:98
capacity:  128   size:99
capacity:  128   size:100

练习9.39

问题：解释下面程序片段做了什么：

  1. vector<string> svec;
  2. svec.reserve(1024);
  3. string word;
  4. while (cin >> word)
  5. 	svec.push_back(word);
  6. svec.resize(svec.size() + svec.size() / 2);

答：首先将svec容量调整称为1024，然后向其中添加string成员。之后给容器又重新加上了svec.size()/2 个空字符串。如果超过了容量，程序会自动分配空间，这个取决于程序自身的实现。

练习9.40

问题：如果上一题的程序读入了256个词，在resize之后容器的capacity可能是多少？如果读入了512个、1000个、或1048个呢？

答：读入了256个词之后，resize后capacity应该还为1024

读入了512个词，resize后capacity还是1024

读入了1000个词后，resize后capacity应该为2048//其实也取决于具体实现

读入了1048个，resize后capacity应该为4096//取决于具体实现

9.5.1节练习

练习9.41

问题：编写程序，从一个vector<char>初始化一个string

  1. #include <iostream>
  2. #include <vector>
  3. #include <string>
  4. using namespace std;
  5.  
  6. int main() {
  7.     vector<char> vc{'a','b','c','d','e'};
  8.     string s1(vc.begin(),vc.end());
  9.     cout<<s1;
  10.     return 0;
  11. }

练习9.42

问题：假定你希望每次读取一个字符存入一个string中，而且知道最少需要读取100个字符，应该如何提高程序的性能？

那么我会在一开始就对这个string获取100的容量。

s.reserve(100);

9.5.2节练习

练习9.43

问题：编写一个函数，接受三个string参数是s、oldVal 和newVal。使用迭代器及insert和erase函数将s中所有oldVal替换为newVal。测试你的程序，用它替换通用的简写形式，如，将"tho"替换为"though",将"thru"替换为"through"

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4.  
  5. void replace_(string &s,string oldVal,string newVal){
  6.     for(auto iter=s.begin();iter!=s.end()-oldVal.size();iter++){
  7.         if(oldVal==string(iter,iter+oldVal.size())){
  8.             iter=s.erase(iter,iter+oldVal.size());
  9.             iter=s.insert(iter,newVal.begin(),newVal.end());
  10.             iter+=newVal.size();
  11.         }
  12.     }
  13. }
  14. int main() {
  15.     string s="Tom walk thro the block,tho he was not happy!";
  16.     replace_(s,"thro","through");
  17.     replace_(s,"tho","though");
  18.     cout<<s;
  19.     return 0;
  20. }

练习9.44

问题：重写上一题的函数，这次使用一个下标和replace

  1.  
  2. #include <iostream>
  3. #include <string>
  4. using namespace std;
  5.  
  6. int main() {
  7.     string s="Tom walk thro the block,tho he was not happy!";
  8.     string oldVal="thro";
  9.     string newVal="through";
  10. //    for(auto iter=s.begin();iter!=s.end()-oldVal.size();iter++){
  11. //        if(oldVal==string(iter,iter+oldVal.size())){
  12. //            s.replace(iter,oldVal.size(),newVal);
  13. //        }
  14. //因为要使用replace，所以这里需要通过下标
  15.     for(string::size_type pos=0;pos!=s.size()-oldVal.size();pos++){
  16.         if(oldVal==s.substr(pos,oldVal.size())){
  17.             s.replace(pos,oldVal.size(),newVal);
  18.         }
  19.     }
  20.     cout<<s;
  21.     return 0;
  22. }

练习9.45

问题：编写一个函数，接受一个表示名字的string参数和两个分别表示前缀（如"Mr."或"Mrs."）和后缀（如"Jr."或"III"）的字符串。使用迭代器及insert和append函数将前缀和后缀添加到给定的名字中，将生成的新string返回

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4.  
  5. string insert_pre_suffix(string &a,string forward,string back){
  6.     a.insert(a.begin(),forward.begin(),forward.end());
  7.     return a.append(back);
  8. }
  9. int main() {
  10.     string name,forward,back;
  11.     name="Jaosn";
  12.     forward="Mr.";
  13.     back="Jr.";
  14.  
  15.     cout<<insert_pre_suffix(name,forward,back);
  16.     return 0;
  17. }

练习9.46

问题：重写上一题的函数，这次使用位置和长度来管理string，并只使用insert

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4.  
  5. string insert_pre_suffix(string &name,string forward,string back){
  6.     name.insert(0,forward);
  7.     name.insert(name.size(),back);
  8.     return name;
  9. }
  10. int main() {
  11.     string name="jason";
  12.     cout<<insert_pre_suffix(name,"Mr.","Jr.");
  13.     return 0;
  14. }

9.5.3节练习

练习9.47

问题：编写程序，首先查找string"ab2c3d7R4E6"中每个数字字符，然后查找其中每个字母字符。编写两个版本的程序，第一个要使用find_first_of，第二个要使用find_first_not_of

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4.  
  5. int main() {
  6.     string item="ab2c3d7R4E6";
  7.     string number="0123456789";
  8.     for(string::size_type pos=0;pos!=string::npos&&pos<item.size();){
  9.         pos=item.find_first_of(number,pos);
  10.         cout<<item[pos];
  11.         if(pos!=string::npos)
  12.             pos++;
  13.     }
  14.     cout<<endl;
  15.     for(string::size_type pos=0;pos!=string::npos&&pos<item.size();){
  16.         pos=item.find_first_not_of(number,pos);
  17.         cout<<item[pos];
  18.         if(pos!=string::npos)
  19.             pos++;
  20.     }
  21.     return 0;
  22. }

练习9.48

问题：假定name和numbers的定义如325页所示，numbers.find(name)返回什么？

返回string::npos

练习9.49

问题：如果一个字母延伸到中线之上，如d或f，则称其有上出头部分（ascender）。如果一个字母延伸到中线之下，如p或g，则称其有下出头部分（descender）。编写程序，读入一个单词文件，输出最长的既不包含上出头部分，也不包含下出头部分的单词

如果既不包含上出头也不包含下出头且最长的单词有多个，取第一个。

  1. #include <iostream>
  2. #include <fstream>
  3. #include <sstream>
  4. #include <string>
  5. using namespace std;
  6.  
  7. int main() {
  8.     ifstream input("/Users/jason/CLionProjects/C++p_u9_9.49/input");
  9.     //判断是否为不含上出头且不含下出头的单次
  10.     string selectWord="aceimnorsuvwxz";
  11.     //保存被选中的单词
  12.     string selectded;
  13.     string line;
  14.     string word;
  15.  
  16.     if(input.is_open()){
  17.         while(getline(input,line)){
  18.             istringstream readLine(line);
  19.             while(readLine>>word){
  20.                 if(word.find_first_not_of(selectWord,0)==string::npos&&word.size()>selectded.size())
  21.                     selectded=word;
  22.             }
  23.         }
  24.     }
  25.     cout<<selectded;
  26.     input.close();
  27.     return 0;
  28. }

9.5.5节练习

练习9.50

问题：编写程序处理一个vector<string>，其元素都表示整型值。计算vector中所有元素之和。修改程序，使之计算表示浮点值的string之和

  1. #include <iostream>
  2. #include <vector>
  3. #include <string>
  4. using namespace std;
  5.  
  6. int main() {
  7.     vector<string> iv={"123","234","345"};
  8.     int sum=0;
  9.     for(auto iter=iv.begin();iter!=iv.end();iter++){
  10.         sum+=stoi(*iter);
  11.     }
  12.     cout<<sum;
  13.     double sum2=0;
  14.     vector<string> dv={"11.22","22.33",".55","1.21"};
  15.     for(auto iter=dv.begin();iter!=dv.end();iter++){
  16.         sum2+=stod(*iter);
  17.     }
  18.     cout<<endl<<sum2;
  19.     return 0;
  20. }

练习9.51

问题：设计一个类，它有三个unsigned成员，分别表示年、月和日。为其编写构造函数，接受一个表示日期的string参数。你的构造函数应该能处理不同的数据格式，如January 1,1900、1/1/1990、Jan 1 1900 等

  1. #include <iostream>
  2. #include <string>
  3. #include <vector>
  4. using namespace std;
  5.  
  6. struct Date{
  7.     Date(string s);
  8.     void print(){cout<<"Year:"<<this->year<<endl
  9.                     <<"Month:"<<this->month<<endl
  10.                     <<"Day:"<<this->day<<endl;}
  11.  
  12.     unsigned year;
  13.     unsigned month;
  14.     unsigned day;
  15. };
  16.  
  17. vector<string> Month{"January","Feburary","March","April","May","June","July","August","September","October","November","December"};
  18. string number="0123456789";
  19. string letter="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM";
  20.  
  21. int digital(int a){
  22.     int dig=0;
  23.     while(a!=0){
  24.         a=a/10;
  25.         dig++;
  26.     }
  27.     return dig;
  28. }
  29. /*
  30.  * 分析：
  31.  * 1.凡是带字母的，一定是月份
  32.  * 2.数字为四位数的，一定是年份
  33.  * 3.月份总是出现在日子之前，如果三个值全为数字，那么出去那个四位数的，剩下的两个数，一个为月份，一个为日子
  34.  *
  35.  * 算法：
  36.  * 1.一上来先找字母，如果找到了，说明这就是月份
  37.  * 2.接下来找数字，同时分析数字的特性，确定是年或者日
  38.  * 3.如果一开始没有找到字母，说明月份也用数字表示
  39.  * 4.此时一定会找到三个数字，而且通常情况下应该不会将年放在月和日的中间，当月和日同时以数字出现时，我们默认月在前，日在后
  40.  * 5.对于第四条，可以稍微加强一下判断，如果月和日都<=12,则以默认情况，如果有一条不小于12，那么该数必定为日
  41.  *
  42.  */
  43. Date::Date(string s) {
  44.     //对s先判断是否含有字母，如果有字母我们就默认它是月份
  45.     string::size_type pos_letter_b,pos_letter_e;
  46.     if(pos_letter_b=s.find_first_of(letter)!=string::npos){//npos表示没搜到
  47.         pos_letter_e=s.find_last_of(letter);
  48.         //提取月份,找到了就直接拿出，其实都可以将赋值语句放到循环条件判断里的
  49.         string temp_month(s,pos_letter_b-1,pos_letter_e-pos_letter_b+2);
  50.         for(vector<string>::size_type pos=0;pos!=Month.size();pos++){
  51.             if(Month[pos].find(temp_month)!=string::npos){
  52.                 month=pos+1;
  53.                 break;
  54.             }
  55.         }
  56.         for(string::size_type pos=0;pos<s.size()&&s.find_first_of(number)!=string::npos;){
  57.             //找到第一个是数字的字符
  58.             pos=s.find_first_of(number);
  59.             //删除掉数字之前所有的值，使得字符串的第一个就是数字
  60.             s.erase(0,pos);
  61.             pos=s.find_first_not_of(number);
  62.             //将字符串转换为数字,找到第一个是数字到第一个不是数字的字符串
  63.             int temp=stoi(s.substr(0,pos));
  64.             //判断是年是天
  65.             if(digital(temp)==4){ year =temp;s.erase(0,pos); pos=0;}
  66.             else {day=temp;s.erase(0,pos);pos=0;}
  67.         }
  68.  
  69.     }else{//没有字母，说明全部用数字表示了
  70.         int flag=0;//用来标记是第一个数字还是第二个数字，这里默认第一个表示月，第二个表示日，如果都不是4位的情况下
  71.         for(string::size_type pos=0,posn=0;pos<s.size()&&s.find_first_of(number)!=string::npos;){
  72.             pos=s.find_first_of(number);
  73.             s.erase(0,pos);
  74.             posn=s.find_first_not_of(number);
  75.             //字符串转换为数字
  76.             int temp=stoi(s.substr(0,posn));
  77.  
  78.             if(digital(temp)==4){year=temp;s.erase(0,posn);pos=0;}
  79.             else if(flag==0){ month=temp;s.erase(0,posn);pos=0;flag++;}
  80.             else{day=temp;s.erase(0,posn);pos=0;}
  81.         }
  82.     }
  83. }
  84.  
  85. int main() {
  86.     Date day1("January 1,1900");
  87.     day1.print();
  88.     Date day2("Mar 3,2004");
  89.     day2.print();
  90.     Date day3("11/21/1990");
  91.     day3.print();
  92.  
  93.     return 0;
  94. }

 

9.6节练习

练习9.52

问题：使用stack处理括号化的表达式。当你看到一个左括号，将其记录下来。当你在一个左括号之后看到一个右括号，从stack中pop对象，直至遇到左括号，将左括号也一起弹出栈。然后将一个值（括号内的运算结果）push到栈中，表示一个括号化的（子）表达式已经处理完毕，被其运算结果所替代

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/178297
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号