从前慢现在也慢

这个屌丝很懒，什么也没留下！

热门标签

c++ primer 第五版----第9章习题解答_假定iv是一个int的vector,下面的程序存在什么错误?你将如何修改?

作者：从前慢现在也慢 | 2024-03-02 01:52:27

踩

假定iv是一个int的vector,下面的程序存在什么错误?你将如何修改?

9.1：对于下面的程序任务，vector、deque和list哪种容器最为适合？解释你的选择的理由。如果没有哪一种容器优于其他容器，也请解释理由。
(a) 读取固定数量的单词，将它们按字典序插入到容器中。我们将在下一章中看到，关联容器更适合这个问题。
(b) 读取未知数量的单词，总是将单词插入到末尾。删除操作在头部进行。
(c) 从一个文件读取未知数量的整数。将这些数排序，然后将它们打印到标准输出。
答：(a)应该使用list，要求插入是字典顺序，list可以任意插入。
(b)这里由于数量不确定，但不要求字典序，要求头部删除，毫无疑问应该用deque

(c)不需要删除则使用vector

9.2 定义一个list对象，其元素类型是int的deque。
list<deque<int>> lst;

9.3 构成迭代器范围的迭代器有何限制？

答：指向同一个迭代器；begin可以反复递增到达end。

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

答;


#include<iostream>
#include<vector>
using namespace std;
bool fun(vector<int>::iterator a, vector<int>::iterator b,int c)
{
	while (a != b)
	{
		if (*a == c)
		{
			return true;
		}
		else
		{
			a++;
		}
	}
	return false;
}
int main()
{
 
 
	vector<int> iter = { 1, 2, 3, 4, 5, 6 };
	int t = 5;
 
 
	cout << fun(iter.begin(),iter.end(), t) << endl;
 
 
	return 0;
}

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


#include<iostream>
#include<vector>
using namespace std;
vector<int>::iterator fun(vector<int>::iterator a, vector<int>::iterator b, int c)
{
	while (a!=b)
	{
		if (*a== c)
		{
			
			return a;
		}
		else
		{
			a++;
		}
	
 
	}
	cout << "no" << endl;
	return b;
	
}
int main()
{
 
	vector<int> iter={ 1, 2, 3, 4, 5, 6 };
	int t = 7;
	fun(iter.begin(),iter.end(), t);
	//cout << fun(iter, t) << endl;
 
	return 0;
}

9.6 下面程序有何错误？你应该如何修改它？

list<int> lst1;
list<int>::iterator iter1 = lst1.begin(),iter2 = lst1.end();
while (iter1 < iter2) /* ... */

答: list容器的迭代器不支持该算术运算符“<”。

9.7 为了索引int的vector中的元素，应该使用什么类型？
vector<int>::size_type

9.8 为了读取string的list中的元素，应该使用什么类型？如果写入list，又应该使用什么类型？
list<string>::const_iterator
list<string>::iterator

9.9 begin和cbegin两个函数有什么不同？
begin返回的迭代器视对象是否是const而定，而cbegin返回的一定是const迭代器。

9.10 下面4个对象分别是什么类型？
vector<int> v1;
const vector<int> v2;
auto it1 = v1.begin(), it2 = v2.begin();
auto it3 = v1.cbegin(), it4 = v2.cbegin();
答： auto只能推断同一类型，因此auto it1 = v1.begin(), it2 = v2.begin();是错误的
it3是vector<int>::cosnt_iterator
it4是vector<int>::const_iterator

9.11 对6种创建和初始化vector对象的方法，每一种都给出一个实例。解释每个vector包含什么值。
答：vector<int> v1; //默认初始化，空vector
vector<int> v2 = {1, 2, 3}; //列表初始化，含有3个元素，值分别为1,2,3
vector<int> v3(v2); //拷贝初始化，拷贝v2，含有3个元素，值分别为1,2,3
vector<int> v4(10); //特定构造函数定义的初始化，含有10个元素，元素值初始化
vector<int> v5(10, 5); //特定构造函数定义的初始化，含有10个元素，元素值初始化为5
vector<int> v6(vector<int>::iterator b, vector<int>::iterator e); //特定构造函数定义的初始化，含有e-b个元素，元素值对应迭代器范围的元素值

9.12 对于接受一个容器创建其拷贝的构造函数，和接受两个迭代器创建拷贝的构造函数，解释它们的不同。
答：接受一个容器创建拷贝的构造函数要求容器类型和元素类型必须一致。
接受两个迭代器创建拷贝的构造函数只要求元素类型一致或者能隐式转换得到。

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


  list<int> l = {1, 2, 3};
   vector<double> vd(l.begin(), l.end());
   vector<int> vi(l.begin(), l.end());

9.14 编写程序，将一个list中的char *指针（指向C风格字符串）元素赋值给一个vector中的string。


list<const char *> t1;
vector<string> t2;
t2.assign(t1.cbegin(), t1.cend());

9.15 编写程序，判定两个vector<int>是否相等。
if (v1 == v2) //v1、v2是2个vector<int>

9.16 重写上一题的程序，比较一个list中的元素和一个vector中的元素。
答：会报错。如果实在要比较不同容器类型中元素的大小，可以选择把lis<int>中的元素拷贝到一个临时vector<int>变量中，然后再比较。

9.17 假定c1和c2是两个容器，下面的比较操作有何限制（如果有的话）？
if (c1 < c2)

答：并不是所有容器都定义了该运算符，比如list容器。所以使用该运算符是有限制的。

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


#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<deque>
using namespace std;
int main()
{
	string word;
	deque<string> con;
	while (cin >> word)
		con.push_back(word);
 
	auto begin = con.begin();
	auto end = con.end();
	while (begin!=end)
	{
		cout << *begin ++<< endl;
		
 
	}
 
	return 0;
}

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


#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<deque>
using namespace std;
int main()
{
	string word;
	list<string> con;
	while (cin >> word)
		con.push_back(word);
 
	auto begin = con.begin();
	auto end = con.end();
	while (begin!=end)
	{
		cout << *begin ++<< endl;
		
 
	}
 
	return 0;
}

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


#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<deque>
using namespace std;
int main()
{
	list<int> vec{ 0, 1, 3, 4, 5, 6, 7, 8 };
	deque<int> t1;
	deque<int> t2;
	auto begin = vec.begin();
	auto end = vec.end();
	while (begin != end)
	{
		if (*begin % 2)
		{
			t2.push_back(*begin++);
		}
		else
		{
			t1.push_back(*begin++);
		}
	}
 
	for (auto c : t1)
	{
		cout << c << "  ";
 
	}
	cout << endl;
 
	for (auto c : t2)
	{
		cout << c << "  ";
 
	}
	cout << endl;
 
	return 0;
}

9.21 如果我们将第308页中使用insert返回值将元素添加到list中的循环程序改写为将元素插入到vector中，分析循环将如何工作。
答：与使用list容器没有任何区别，仅仅可能会有效率上的差异。

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);


#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<deque>
using namespace std;
int main()
{
	vector<int> iv{2,2,2,3,4};
	vector<int>::iterator iter = iv.begin(), mid = iv.begin() + iv.size() / 2;
	int some_val = 2;
	while (iter != mid)
	{
		
		if (*iter == some_val)
		{
			iter=iv.insert(iter, 2 * some_val);
			mid = iv.begin() + iv.size() / 2+1;
			iter +=2;
		}
		else
		
			++iter;
 
		
	}
 
	for (auto c : iv)
	{
		cout << c << "  ";
	}
	cout << endl;
 
	return 0;
}

注意：mid迭代器可能失效。

9.23 在本节第一个程序（第309页）中，若c.size()为1，则val、val2、val3和val4的值会是什么？
答：它们的值都将是第一个元素值。

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


#include<string>
#include<vector>
#include<list>
#include<deque>
using namespace std;
int main()
{
	vector<int> c{1,2,3};
	cout << c.at(0) << endl;
	cout << c[0] << endl;
	cout << c.front() << endl;
	cout << *c.begin() << endl;
 
	return 0;
}

当是一个空的时候，会报错。

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

答：如果elem1和elem2相等，则范围为0不进行任何删除。如果elem2是尾后迭代器，那么从elem1删到结尾。如果两者皆为尾后迭代器，则范围为0不进行任何删除。

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<string>
#include<vector>
#include<list>
#include<deque>
using namespace std;
int main()
{
	vector<int> c1;
	list<int> c2;
	int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };
	for (int i = 0; i < 11;i++)
	{
		c1.push_back(ia[i]);
		c2.push_back(ia[i]);
	}
 
	auto it1 = c1.begin();
	auto it2 = c2.begin();
 
	while (it1 != c1.end())//删除偶数
	{
		if (!(*it1 % 2))
		{
			it1 = c1.erase(it1);
		}
		else
			++it1;
 
	}
 
	while (it2 != c2.end())//删除奇数
	{
		if (*it2 % 2)
		{
			it2 = c2.erase(it2);
		}
		else
			++it2;
 
	}
 
	for (auto c : c1)
	{
		cout << c << "  ";
 
	}
	cout << endl;
 
	for (auto c : c2)
	{
		cout << c << "  ";
 
	}
	cout << endl;
 
 
	return 0;
}

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


#include<iostream>
#include<string>
#include<vector>
#include<forward_list>
#include<deque>
using namespace std;
int main()
{
 
	forward_list<int> c1{ 0, 1, 2, 3, 54, 6, 7, 8 };
	auto prev = c1.before_begin();
	auto curr = c1.begin();
 
	while (curr!=c1.end())
	{
		if (*curr % 2)
		{
			curr = c1.erase_after(prev);
		}
		else
		{
			prev = curr;
 
			++curr;
		}
 
	}
 
	
 
	for (auto c : c1)
	{
		cout << c << "  ";
 
	}
	cout << endl;
 
	
 
 
	return 0;
}

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


#include<iostream>
#include<string>
#include<vector>
#include<forward_list>
#include<deque>
using namespace std;
void f1(forward_list<string> c, string s1, string s2)
{
	auto prev = c.before_begin();
	auto curr = c.begin();
	int flag = 1;
	while (curr != c.end())
	{
		if (*curr == s1)
		{
			curr = c.insert_after(curr,s2);
			flag = 0;
		}
		prev = curr;//记录尾后迭代器前一个元素的位置
		curr++;
	}
 
	if (flag)
	{
		c.insert_after(prev,s2);
	}
 
	for (auto c1 : c)
	{
		cout << c1 << "  ";
 
	}
	cout << endl;
 
}
int main()
{
 
	forward_list<string> c1{ "s1","s2","s3" };
	string s1 = "s4";
	string s2 = "s22";
 
	f1(c1, s1, s2);
 
 
	
 
 
	return 0;
}

9.29 假定vec包含25个元素，那么vec.resize(100)会做什么？如果接下来调用vec.resize(10)会做什么？
答：追加75个值初始化的元素到vec中。
删除vec靠后90个元素。

9.30 接受单个参数的resize版本对元素类型有什么限制（如果有的话）？
答：元素类型必须具有默认构造函数。

9.31 第316页中删除偶数值元素并复制奇数值元素的程序不能用于list或forward_list。为什么？修改程序，使之也能用于这些类型。
因为list和forward_list的迭代器不支持复合赋值运算。
对于list，iter += 2;应该修改为++iter;++iter;

9.32 在第316页的程序中，像下面语句这样调用insert是否合法？如果不合法，为什么？
iter = vi.insert(iter, *iter++);
不合法。因为参数的求值顺序是未指定，无法保证括号内的计算顺序。

9.33 在本节最后一个例子中，如果不将insert的结果赋予begin，将会发生什么？编写程序，去掉此赋值语句，验证你的答案。
不将insert的结果赋予begin，begin将会失效，程序无法正常工作或崩溃。

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

iter = vi.begin();
while (iter != vi.end())
if (*iter % 2)
iter = vi.insert(iter, *iter);
++iter;
死循环。

9.35 解释一个vector的capacity和size有何区别。
答：capacity表示在不重新分配内存空间的情况下，容器可以容纳多少元素，size值是容器已经保存的元素的个数。

9.36 一个容器的capacity可能小于它的size吗？
答：不可能。

9.37 为什么list或array没有capacity成员函数？
答：因为list是链表，不需要事先分配连续内存，而array不允许改变容器大小。

9.38 编写程序，探究在你的标准实现中，vector是如何增长的。


#include <iostream>
#include <vector>
 
using namespace std;
 
int main(int argc, char const *argv[])
{
    vector<int> v = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    v.reserve(50);
    cout << "v: size: " << v.size()
         << " capacity: "  << v.capacity() << endl;
 
    while (v.size() != v.capacity())
        v.push_back(0);
    cout << "v: size: " << v.size()
         << " capacity: "  << v.capacity() << endl;
 
    v.push_back(42);
    cout << "v: size: " << v.size()
         << " capacity: "  << v.capacity() << endl;
    return 0;
}

9.39 解释下面程序片段做了什么：
vector<string> svec;
svec.reserve(1024); //为该vevtor申请1024个元素空间
string word;
while (cin >> word)
svec.push_back(word);
svec.resize(svec.size() + svec.size() / 2); //将可以容纳1024个string的vector扩大0.5倍

9.40 如果上一题的程序读入了256个词，在resize之后容器的capacity可能是多少？如果读入了512个、1000个、或1048个呢？
答：如果读入了256个或512个词，capacity 仍然是 1024
如果读入了1000或1048个词，capacity 取决于具体实现。

9.41 编写程序，从一个vector<char>初始化一个string。
vector<char> v{ 'h', 'e', 'l', 'l', 'o' };
string s(v.cbegin(), v.cend());

9.42 假定你希望每次读取一个字符存入一个string中，而且知道最少需要读取100个字符，应该如何提高程序的性能？
答：使用 reserve(200) 函数预先分配200个元素的空间。

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


#include <iostream>
#include <string>
using namespace std;
 
 
void replaceString(std::string &s, const std::string &oldVal, const std::string &newVal){
 
 
	if (oldVal.empty() || s.empty()){
		return;
	}
 
 
	if (s.size() < oldVal.size()){
		return;
	}
 
 
	auto sIter = s.begin();
	auto oldIter = oldVal.begin();
 
 
	while (sIter != s.end()){
 
 
		if ((*sIter) == (*oldIter)){
			++oldIter;
		}
		else {
			oldIter = oldVal.begin();
		}
 
 
		++sIter;
 
 
		if (oldIter == oldVal.end()){
			oldIter = oldVal.begin();
			sIter = s.erase(sIter - oldVal.size(), sIter);
			for (std::string::size_type index = 0; index < newVal.size(); ++index){//一个字符一个字符的放进去。一次性放进去不行，以防被改变的字符串是最后一个字符串。
				sIter = s.insert(sIter, newVal[index]);
				++sIter;
			}
		}
	}
 
 
}
 
 
 
 
int main()
{
 
 
	string s("a an tho the thru");
	//f(s, "tho", "though");
//	f(s, "thru", "through");
	replaceString(s, "tho", "though");
	replaceString(s, "thru", "through");
	cout << s << endl;
	return 0;
}

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


#include <iostream>
#include <string>
using namespace std;
 
void replaceString(std::string &s, const std::string &oldVal, const std::string &newVal){
 
	if (oldVal.empty() || s.empty()){
		return;
	}
 
	if (s.size() < oldVal.size()){
		return;
	}
 
	std::string::size_type sIndex = 0;
	std::string::size_type oldIndex = 0;
 
	while (sIndex < s.size()){
 
		if (oldVal[oldIndex] == s[sIndex]){
			++oldIndex;
		}
		else {
			oldIndex = 0;
		}
 
		++sIndex;
 
		if (oldIndex >= oldVal.size()){
			oldIndex = 0;
			s.replace(sIndex - oldVal.size(), oldVal.size(), newVal);
			sIndex += newVal.size() - oldVal.size();
		}
 
	}
}
 
 
 
int main()
{
 
	string s("a an tho the thru");
	//f(s, "tho", "though");
//	f(s, "thru", "through");
	replaceString(s, "tho", "though");
	replaceString(s, "thru", "through");
	cout << s << endl;
	return 0;
}

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


#include<iostream>
#include<string>
using namespace std;
void f(string &s, const string &fr,const string &ba)
{
	s.insert(s.begin(),fr.begin(),fr.end());
	s.append(ba);
 
}
int main()
{
	string s("Jhon");
	f(s, "Mr ", " Jr");
 
	cout << s << endl;
	return 0;
}

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


#include<iostream>
#include<string>
using namespace std;
void f(string &s, const string &fr,const string &ba)
{
	s.insert(s.begin(),fr.begin(),fr.end());
	s.insert(s.end(), ba.begin(), ba.end());
 
}
int main()
{
	string s("Jhon");
	f(s, "Mr ", " Jr");
 
	cout << s << endl;
	return 0;
}

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


#include<iostream>
#include<string>
using namespace std;
int main()
{
	string num = "0123456789";
	
	string s("ab2c3d7R4E6");
 
 
 
 
	string::size_type pos = 0;
	while ((pos = s.find_first_of(num,pos)) != string ::npos)//输出每一个数字所在位置。
	{
		cout << pos << " ";
		pos++;
 
 
	}
	cout <<endl;
	pos = 0;
	while ((pos = s.find_first_not_of(num, pos)) != string::npos)//输出每一个数字所在位置。
	{
		cout << pos << " ";
		pos++;
 
 
	}
 
 
	//cout << pos << endl;
	
	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<string>
using namespace std;
 
int main(int argc, char const *argv[])
{
	//string serial = "abccefg";
	string not_in("bdfhkltgjpqy");
	ifstream is;
	string word, picked;
	string::size_type len = word.size();
	is.open("hello.txt");
	if (is)
	{
		cout << "open word.txt\n";
		while (is >> word)
		{
			string::size_type pos = 0;
			if ((pos = word.find_first_of(not_in, pos)) == string::npos)
			{
				if (word.size() > len)
				{
					len = word.size();
					picked = word;
				}
			}
		}
		cout << picked << endl;
	}
	return 0;
}

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

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

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/178339