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值。在两个迭代器指定的范围中查找给定的值，返回一个布尔值来指出是否找到。
#include <iostream>
#include<vector>
using std::vector;
using std::cout;
bool if_find(vector<int>::iterator begin,vector<int>::iterator end,int b){
for(auto v=begin;v!=end;v++){
if(*v==b)
return true;
}
return false;
}
int main() {
vector<int> fi={3,4,5,6,8};
int i=5;
cout<<if_find(fi.begin(),fi.end(),i);
return 0;
}
练习9.5
问题：重写上一题的函数，返回一个迭代器指向找到的元素。注意，程序必须处理未找到给定值的情况。
#include <iostream>
#include<vector>
using std::vector;
using std::cout;
vector<int>::iterator if_find(vector<int>::iterator begin,vector<int>::iterator end,int b){
auto v=begin;
for( v=begin;v!=end;v++){
if(*v==b)
return v;
}
return v;
}
int main() {
vector<int> fi={3,4,5,6,8};
int i=5;
auto v=if_find(fi.begin(),fi.end(),i);
if(v!=fi.end())
cout<<*if_find(fi.begin(),fi.end(),i);
return 0;
}
练习9.6
问题：下面程序有何错误，应该如何修改？
list<int> lst1;
list<int>::iterator iter1 =lst1.begin(),iter2=lst1.end();
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
问题：下面四个对象分别是什么类型？
vector<int> v1;
const vector<int> v2;
auto it1 = v1.begin(), it2 = v2.begin();
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
#include <iostream>
#include<list>
#include<string>
#include<vector>
using namespace std;
int main() {
list<char*> slist={"aa","bb","cc","dd","ee"};
vector<string> svec(slist.begin(),slist.end());
for(const auto &i:svec){
cout<<i;
}
vector<string> svec2;
//assign也可实现这个要求
svec2.assign(slist.cbegin(),slist.cend());
for(const auto &i:svec2){
cout<<i<<endl;
}
return 0;
}9.2.7节练习
练习9.15
问题：编写程序，判定两个vector<int>是否相等。
/*
* 编写程序，判定两个vector<int>是否相等。
*/
#include <iostream>
#include <vector>
using namespace std;
bool equals(const vector<int> &a,const vector<int> &b){
return a==b;
}
int main() {
vector<int> v1={1,3,5,7};
vector<int> v2={1,3,5,7};
vector<int> v3={1,3,5,7,9,11};
cout<<"v1==v2?:"<<equals(v1,v2)<<endl;
cout<<"v1==v3?:"<<equals(v1,v3)<<endl;
return 0;
}
练习9.16
问题：重写上一题的程序，比较一个list中的元素和一个vector中的元素
/*
* 重写上一题的程序，比较一个list<int>中的元素和一个vector<int>中的元素
*/
#include <iostream>
#include <vector>
#include <list>
using namespace std;
bool equals(const vector<int> &a,const vector<int> &b){
return a==b;
}
bool equals(const int &a, const int &b){
return a==b;
}
int main() {
vector<int> v1={1,3,5,7};
vector<int> v2={1,3,5,7};
vector<int> v3={1,3,5,7,9,11};
cout<<"v1==v2?:"<<equals(v1,v2)<<endl;
cout<<"v1==v3?:"<<equals(v1,v3)<<endl;
vector<int> list1={1,2,3,4};
cout<<"v1[0]==list1[0]:"<<equals(v1[0],list1[0])<<endl;
cout<<"v1[1]==list1[1]:"<<equals(v1[1],list1[1])<<endl;
std::list<int> li{ 1, 2, 3, 4, 5 };
std::vector<int> vec2{ 1, 2, 3, 4, 5 };
std::vector<int> vec3{ 1, 2, 3, 4 };
std::cout << (std::vector<int>(li.begin(), li.end()) == vec2 ? "true" : "false") << std::endl;//通过逐个元素进行比较
std::cout << (std::vector<int>(li.begin(), li.end()) == vec3 ? "true" : "false") << std::endl;
//说明这两个容器中的元素相等
return 0;
}练习9.17
问题：假定c1和c2是两个容器，下面的比较操作有何限制？
c1<c2
答：关系运算符左右两边的运算对象必须是相同类型的容器，且必须保存相同类型的元素。
元素类型要支持相关操作。
9.3.1节练习
练习9.18
问题：编写程序，从标准输入读取string序列，存入一个deque中。编写一个循环，用迭代器打印deque中的元素
#include <iostream>
#include <string>
#include <deque>
using namespace std;
int main() {
string temp;
deque<string> sde;
while(cin>>temp){
sde.push_back(temp);
}
for(const auto vec:sde){
cout<<vec<<endl;
}
return 0;
}练习9.19
问题：重写上一题的程序，用list替代deque。列出程序要做出哪些改变
答：只需要将deque替换成list即可。程序不需要做任何改变
练习9.20
问题：编写程序，从一个list<int>拷贝元素到两个deque中。值为偶数的所有元素都拷贝到一个deque中，而奇数值元素都拷贝到另一个deque中
#include <iostream>
#include <list>
#include <deque>
using namespace std;
int main() {
list<int> il={1,2,3,4,5};
deque<int> ou,ji;
for(auto vec=il.begin();vec!=il.end();vec++){
if((*vec)%2==0)
ou.push_back(*vec);
else
ji.push_back(*vec);
}
for(auto vec=ou.begin();vec!=ou.end();vec++)
cout<<*vec<<" ";
cout<<endl;
for(auto vec=ji.begin();vec!=ji.end();vec++)
cout<<*vec<<" ";
return 0;
}
练习9.21
问题：如果我们将第308页中使用insert返回值将元素添加到list中的循环程序改写为将元素插入到vector中，分析循环将如何工作
循环没有什么变化。
练习9.22
问题：假定iv是一个int的vector，下面的程序存在什么错误？你将如何修改？
vector<int>::iterator iter = iv.begin(),
mid = iv.begin() + iv.size() / 2;
while (iter != mid)
if (*iter == some_val)
iv.insert(iter, 2 * some_val);答：循环没有增量，会变成永久的循环
我会改成：while(++iter!=mid)
还有对于vector插入，需要将插入后面的值都往后移动。也就是说，每当它插入以后，当前的迭代器所指的元素就是插入位置的元素。如此使用++以后，又回满足条件。于是会形成无限插入。此时我们可以在每次成功插入后对迭代器加一
最终程序为：
while (++iter != mid)
if (*iter == some_val){
iv.insert(iter, 2 * some_val);
iter++;
}9.3.2节练习
练习9.23
问题：在本节第一个程序中，若c.size() 为1，则val、val2、val3和val4的值会是什么？
说明容器中只有一个值。那么val=val2=val3=val4 = 这个值
练习9.24
问题：编写程序，分别使用at、下标运算符、front 和 begin 提取一个vector中的第一个元素。在一个空vector上测试你的程序
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> ivec{1,2,3,4 };
vector<int> ivec2;
int val1=ivec.front();//1
int val2=ivec.back();//4
int val3=ivec.at(1);//2
int val4=ivec[2];//3
int nval1=ivec2.front();//exc_bad_access 访问错误
int nval2=ivec2.back();//exc_bad_access 访问错误
int nval3=ivec2[0];//exc_bad_access 访问错误
int nval4=ivec2.at(0);//out_of_range
cout<<val1<<val2<<val3<<val4<<endl;
cout<<nval1<<nval2<<nval3<<nval4;
return 0;
}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 };#include <iostream>
#include <vector>
#include <list>
using namespace std;
int main() {
int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };
vector<int> ivec;
list<int> il;
ivec.assign(&ia[0],&ia[sizeof(ia)/sizeof(int)]);
il.assign(&ia[0],&ia[sizeof(ia)/sizeof(int )]);
for(auto iter=ivec.begin();iter!=ivec.end();){
if(*iter%2==0){
iter=ivec.erase(iter);
continue;
}else
iter++;
}
for(auto iter=il.begin();iter!=il.end();){
if(*iter%2==1){
iter=il.erase(iter);
continue;
}else
iter++;
}
for(auto iter:ivec){
cout<<iter<<" ";
}
cout<<endl;
for(auto iter:il){
cout<<iter<<" ";
}
return 0;
}9.3.4节练习：
练习9.27:
问题：编写程序，查找并删除forward_list<int>中的奇数元素
#include <iostream>
#include <forward_list>
using namespace std;
int main() {
forward_list<int> fli={1,2,3,4,5,6,7,8,9};
auto beforeB=fli.before_begin();
for(auto iter=fli.begin();iter!=fli.end();){
if(*iter%2==1){
iter=fli.erase_after(beforeB);
}else{
beforeB=iter;
iter++;
}
}
for(auto iter:fli){
cout<<iter<<" ";
}
return 0;
}练习9.28
问题：编写函数，接受一个forward_list<string>和两个string共三个参数。函数应在链表中查找第一个string，并将第二个string插入到紧接着第一个string之后的位置。若第一个string未在链表中，则将第二个string插入到链表末尾。
#include <iostream>
#include <forward_list>
#include <string>
using namespace std;
void compare_insert(forward_list<string> &forw,string a,string b){
auto beforeB=forw.before_begin();
for(auto iter=forw.begin();iter!=forw.end();){
if(a==*iter){
forw.insert_after(iter,b);
break;
}else{
beforeB=iter;
if(++iter==forw.end()){
forw.insert_after(beforeB,b);
}
}
}
}
int main() {
forward_list<string> fls={"aa","bb","cc"};
string a="bb";
string b="mm";
string d="hh";
compare_insert(fls,a,b);
for(auto iter:fls){
cout<<iter<<" ";
}
return 0;
}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有增添值和删除值的操作
#include <iostream>
#include <forward_list>
#include <string>
using namespace std;
void compare_insert(forward_list<string> &forw,string a,string b){
auto beforeB=forw.before_begin();
for(auto iter=forw.begin();iter!=forw.end();){
if(a==*iter){
forw.insert_after(iter,b);
break;
}else{
beforeB=iter;
if(++iter==forw.end()){
forw.insert_after(beforeB,b);
}
}
}
}
int main() {
forward_list<string> fls={"aa","bb","cc"};
string a="bb";
string b="mm";
string d="hh";
compare_insert(fls,a,b);
for(auto iter:fls){
cout<<iter<<" ";
}
cout<<endl;
compare_insert(fls,d,b);
for(auto iter:fls){
cout<<iter<<" ";
}
return 0;
}练习9.32
问题：在第316页的程序中，像下面语句这样调用insert是否合法？如果不合法，为什么？
iter=vi.insert(iter,*iter++)
不合法，究竟将iter插入到哪里是未知的。
练习9.33
问题：在本节最后一个例子中，如果不将insert的结果赋予begin，将会发生什么？编写程序，去掉此赋值语句，验证你的答案。
答：如果不将insert结果赋值给beigin，那么begin将会变成无效迭代器。
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> vec1={1,3,4};
auto begin = vec1.begin();
while(begin!=vec1.end()){
if(*begin==3){
++begin;
// vec1.insert(begin,10);
begin=vec1.insert(begin,10);
++begin;
}else
++begin;
}
for(auto iter:vec1){
cout<<iter<<" ";
}
return 0;
}去掉此赋值语句，发现多插入了一个10
练习9.34
问题：假定vi是一个保存int的容器，其中有偶数值也有奇数值，分析下面循环的行为，然后编写程序验证你的分析是否正确。
iter = vi.begin();
while (iter != vi.end())
if (*iter % 2)
iter = vi.insert(iter, *iter);
++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是如何增长的
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> svec1;
for(vector<int>::size_type ix=0;ix!=100;++ix){
svec1.push_back(ix);
cout<<"capacity: "<<svec1.capacity()<<" size:"<<svec1.size()<<endl;
}
}输出：
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
问题：解释下面程序片段做了什么：
vector<string> svec;
svec.reserve(1024);
string word;
while (cin >> word)
svec.push_back(word);
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
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main() {
vector<char> vc{'a','b','c','d','e'};
string s1(vc.begin(),vc.end());
cout<<s1;
return 0;
}练习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"
#include <iostream>
#include <string>
using namespace std;
void replace_(string &s,string oldVal,string newVal){
for(auto iter=s.begin();iter!=s.end()-oldVal.size();iter++){
if(oldVal==string(iter,iter+oldVal.size())){
iter=s.erase(iter,iter+oldVal.size());
iter=s.insert(iter,newVal.begin(),newVal.end());
iter+=newVal.size();
}
}
}
int main() {
string s="Tom walk thro the block,tho he was not happy!";
replace_(s,"thro","through");
replace_(s,"tho","though");
cout<<s;
return 0;
}练习9.44
问题：重写上一题的函数，这次使用一个下标和replace
#include <iostream>
#include <string>
using namespace std;
int main() {
string s="Tom walk thro the block,tho he was not happy!";
string oldVal="thro";
string newVal="through";
// for(auto iter=s.begin();iter!=s.end()-oldVal.size();iter++){
// if(oldVal==string(iter,iter+oldVal.size())){
// s.replace(iter,oldVal.size(),newVal);
// }
//因为要使用replace，所以这里需要通过下标
for(string::size_type pos=0;pos!=s.size()-oldVal.size();pos++){
if(oldVal==s.substr(pos,oldVal.size())){
s.replace(pos,oldVal.size(),newVal);
}
}
cout<<s;
return 0;
}练习9.45
问题：编写一个函数，接受一个表示名字的string参数和两个分别表示前缀（如"Mr."或"Mrs."）和后缀（如"Jr."或"III"）的字符串。使用迭代器及insert和append函数将前缀和后缀添加到给定的名字中，将生成的新string返回
#include <iostream>
#include <string>
using namespace std;
string insert_pre_suffix(string &a,string forward,string back){
a.insert(a.begin(),forward.begin(),forward.end());
return a.append(back);
}
int main() {
string name,forward,back;
name="Jaosn";
forward="Mr.";
back="Jr.";
cout<<insert_pre_suffix(name,forward,back);
return 0;
}练习9.46
问题：重写上一题的函数，这次使用位置和长度来管理string，并只使用insert
#include <iostream>
#include <string>
using namespace std;
string insert_pre_suffix(string &name,string forward,string back){
name.insert(0,forward);
name.insert(name.size(),back);
return name;
}
int main() {
string name="jason";
cout<<insert_pre_suffix(name,"Mr.","Jr.");
return 0;
}9.5.3节练习
练习9.47
问题：编写程序，首先查找string"ab2c3d7R4E6"中每个数字字符，然后查找其中每个字母字符。编写两个版本的程序，第一个要使用find_first_of，第二个要使用find_first_not_of
#include <iostream>
#include <string>
using namespace std;
int main() {
string item="ab2c3d7R4E6";
string number="0123456789";
for(string::size_type pos=0;pos!=string::npos&&pos<item.size();){
pos=item.find_first_of(number,pos);
cout<<item[pos];
if(pos!=string::npos)
pos++;
}
cout<<endl;
for(string::size_type pos=0;pos!=string::npos&&pos<item.size();){
pos=item.find_first_not_of(number,pos);
cout<<item[pos];
if(pos!=string::npos)
pos++;
}
return 0;
}练习9.48
问题：假定name和numbers的定义如325页所示，numbers.find(name)返回什么？
返回string::npos
练习9.49
问题：如果一个字母延伸到中线之上，如d或f，则称其有上出头部分（ascender）。如果一个字母延伸到中线之下，如p或g，则称其有下出头部分（descender）。编写程序，读入一个单词文件，输出最长的既不包含上出头部分，也不包含下出头部分的单词
如果既不包含上出头也不包含下出头且最长的单词有多个，取第一个。
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
using namespace std;
int main() {
ifstream input("/Users/jason/CLionProjects/C++p_u9_9.49/input");
//判断是否为不含上出头且不含下出头的单次
string selectWord="aceimnorsuvwxz";
//保存被选中的单词
string selectded;
string line;
string word;
if(input.is_open()){
while(getline(input,line)){
istringstream readLine(line);
while(readLine>>word){
if(word.find_first_not_of(selectWord,0)==string::npos&&word.size()>selectded.size())
selectded=word;
}
}
}
cout<<selectded;
input.close();
return 0;
}9.5.5节练习
练习9.50
问题：编写程序处理一个vector<string>，其元素都表示整型值。计算vector中所有元素之和。修改程序，使之计算表示浮点值的string之和
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main() {
vector<string> iv={"123","234","345"};
int sum=0;
for(auto iter=iv.begin();iter!=iv.end();iter++){
sum+=stoi(*iter);
}
cout<<sum;
double sum2=0;
vector<string> dv={"11.22","22.33",".55","1.21"};
for(auto iter=dv.begin();iter!=dv.end();iter++){
sum2+=stod(*iter);
}
cout<<endl<<sum2;
return 0;
}练习9.51
问题：设计一个类，它有三个unsigned成员，分别表示年、月和日。为其编写构造函数，接受一个表示日期的string参数。你的构造函数应该能处理不同的数据格式，如January 1,1900、1/1/1990、Jan 1 1900 等
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct Date{
Date(string s);
void print(){cout<<"Year:"<<this->year<<endl
<<"Month:"<<this->month<<endl
<<"Day:"<<this->day<<endl;}
unsigned year;
unsigned month;
unsigned day;
};
vector<string> Month{"January","Feburary","March","April","May","June","July","August","September","October","November","December"};
string number="0123456789";
string letter="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM";
int digital(int a){
int dig=0;
while(a!=0){
a=a/10;
dig++;
}
return dig;
}
/*
* 分析：
* 1.凡是带字母的，一定是月份
* 2.数字为四位数的，一定是年份
* 3.月份总是出现在日子之前，如果三个值全为数字，那么出去那个四位数的，剩下的两个数，一个为月份，一个为日子
*
* 算法：
* 1.一上来先找字母，如果找到了，说明这就是月份
* 2.接下来找数字，同时分析数字的特性，确定是年或者日
* 3.如果一开始没有找到字母，说明月份也用数字表示
* 4.此时一定会找到三个数字，而且通常情况下应该不会将年放在月和日的中间，当月和日同时以数字出现时，我们默认月在前，日在后
* 5.对于第四条，可以稍微加强一下判断，如果月和日都<=12,则以默认情况，如果有一条不小于12，那么该数必定为日
*
*/
Date::Date(string s) {
//对s先判断是否含有字母，如果有字母我们就默认它是月份
string::size_type pos_letter_b,pos_letter_e;
if(pos_letter_b=s.find_first_of(letter)!=string::npos){//npos表示没搜到
pos_letter_e=s.find_last_of(letter);
//提取月份,找到了就直接拿出，其实都可以将赋值语句放到循环条件判断里的
string temp_month(s,pos_letter_b-1,pos_letter_e-pos_letter_b+2);
for(vector<string>::size_type pos=0;pos!=Month.size();pos++){
if(Month[pos].find(temp_month)!=string::npos){
month=pos+1;
break;
}
}
for(string::size_type pos=0;pos<s.size()&&s.find_first_of(number)!=string::npos;){
//找到第一个是数字的字符
pos=s.find_first_of(number);
//删除掉数字之前所有的值，使得字符串的第一个就是数字
s.erase(0,pos);
pos=s.find_first_not_of(number);
//将字符串转换为数字,找到第一个是数字到第一个不是数字的字符串
int temp=stoi(s.substr(0,pos));
//判断是年是天
if(digital(temp)==4){ year =temp;s.erase(0,pos); pos=0;}
else {day=temp;s.erase(0,pos);pos=0;}
}
}else{//没有字母，说明全部用数字表示了
int flag=0;//用来标记是第一个数字还是第二个数字，这里默认第一个表示月，第二个表示日，如果都不是4位的情况下
for(string::size_type pos=0,posn=0;pos<s.size()&&s.find_first_of(number)!=string::npos;){
pos=s.find_first_of(number);
s.erase(0,pos);
posn=s.find_first_not_of(number);
//字符串转换为数字
int temp=stoi(s.substr(0,posn));
if(digital(temp)==4){year=temp;s.erase(0,posn);pos=0;}
else if(flag==0){ month=temp;s.erase(0,posn);pos=0;flag++;}
else{day=temp;s.erase(0,posn);pos=0;}
}
}
}
int main() {
Date day1("January 1,1900");
day1.print();
Date day2("Mar 3,2004");
day2.print();
Date day3("11/21/1990");
day3.print();
return 0;
}
9.6节练习
练习9.52
问题：使用stack处理括号化的表达式。当你看到一个左括号，将其记录下来。当你在一个左括号之后看到一个右括号，从stack中pop对象，直至遇到左括号，将左括号也一起弹出栈。然后将一个值（括号内的运算结果）push到栈中，表示一个括号化的（子）表达式已经处理完毕，被其运算结果所替代
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
