c++ primer中文版第五版作业第十章

最新推荐文章于 2024-03-08 21:26:00 发布
最新推荐文章于 2024-03-08 21:26:00 发布
阅读量920 收藏 9
点赞数 11
分类专栏： c/c++及数据结构 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuluoyide312/article/details/136570225
版权

仓库地址

文章目录

10.1

#include <iostream>
#include <climits>
#include <algorithm>
#include <vector>
using namespace std;
int main(void)
{
	vector<int> ivec;
	int itmp;
	int targ=0;
	cout<<"Enter some integer(q to quit): ";
	while(cin>>itmp)
		ivec.push_back(itmp);
	cout<<"Which target do you count: ";
	cin.clear();
	cin.ignore(INT_MAX,'\n');
	cin>>targ;
	itmp=0;
	itmp=count(ivec.begin(),ivec.end(),targ);
	cout<<itmp<<" targets are find."<<endl;
	return 0;
}

10.2

#include <iostream>
#include <algorithm>
#include <list>
#include <string>
using namespace std;
int main(void)
{
	list<string> slst;
	string stmp;
	cout<<"Enter some strings: ";
	while(cin>>stmp&&stmp!="quit")
		slst.push_back(stmp);
	cout<<"Which string do you want to count: ";
	cin>>stmp;
	cout<<stmp<<" occurs "<<count(slst.begin(),slst.end(),stmp)<<" times."<<endl;
	return 0;
}

10.3

#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main(void)
{
	int tmp,sum=0;
	vector<int> ivec;
	cout<<"Enter some integers(q to quit): ";
	while(cin>>tmp)
		ivec.push_back(tmp);
	sum=accumulate(ivec.cbegin(),ivec.cend(),0);
	cout<<"Sum is "<<sum<<endl;
	return 0;
}

10.4

 accumulate的第三个参数是和的初值，它还决定了函数的返回类型以及函数中使用哪个加法运算符，所以本题中和的初始是整型，则会发生双精度浮点数向整型的转换，损失小数点后的部分。
###10.5
 equal使用==运算符比较两个序列中的元素。string类重载了==运算符，可以比较两个string或者一个string和一个c风格字符串是否相等。而两个都是c风格字符串的话，它们本质上是比较两个char *类型的指针，即所指地址。所以，只有当两个序列中的指针都指向相同的地址时，equal 才会返回 true。否则，即使字符串内容完全相同，也会返回 false。

10.6

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;
int main()
{
	vector<int> ivec(10,10);
	fill_n(ivec.begin(),ivec.size(),0);
	for(const auto &pi:ivec)
		cout<<pi<<" ";
	cout<<endl;
	return 0;
}

10.7

vector<int> vec;list<int> lst;int i;
while(cin>>i)
	lst.push_back(i);
copy(lst.cbegin(),lst.cend(),back_inserter(vec));

reserve并不改变容器中元素的数量，它仅影响vector预先分配的内存空间，所以这时候的vec仍然是空的
vector<int> vec;
vec.reserve(10);
fill_n(back_inserter(vec),10,0);

10.8

 标准库算法从来不 直接 操作容器，它们只操作迭代器，从而 间接 访问容器。能不能插入和删除元素，不在于算法，而在于传递给它们的迭代器是否具有这样的能力。

10.9

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void elimDups(vector<string> &);
void pt(vector<string> &);
int main(void)
{
	string tmp;
	vector<string> svec;
	while(cin>>tmp)
		svec.push_back(tmp);
	elimDups(svec);
	return 0;
}
void elimDups(vector<string> &svec)
{
	pt(svec);
	sort(svec.begin(),svec.end());
	pt(svec);
	vector<string>::iterator end_unique=unique(svec.begin(),svec.end());
	pt(svec);
	svec.erase(end_unique,svec.end());
	pt(svec);
}
void pt(vector<string> &svec)
{
	for(const auto &s:svec)
		cout<<s<<" ";
	cout<<endl;
}

10.10

 算法只操作迭代器，由迭代器真正实现对容器的访问，因此算法根本就不知道容器的存在，所以是否改变容器的大小完全是迭代器的选择与责任。

10.11

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void elimDups(vector<string> &);
void pt(vector<string> &);
bool isShorter(const string &s1,const string &s2)
{
	return s1.size()<s2.size();
}
int main(void)
{
	string tmp;
	vector<string> svec;
	while(cin>>tmp)
		svec.push_back(tmp);
	elimDups(svec);
	stable_sort(svec.begin(),svec.end(),isShorter);
	pt(svec);
	return 0;
}
void elimDups(vector<string> &svec)
{
	pt(svec);
	sort(svec.begin(),svec.end());
	pt(svec);
	vector<string>::iterator end_unique=unique(svec.begin(),svec.end());
	pt(svec);
	svec.erase(end_unique,svec.end());
	pt(svec);
}
void pt(vector<string> &svec)
{
	for(const auto &s:svec)
		cout<<s<<" ";
	cout<<endl;
}

10.12

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
using namespace std;
class Sales_data;
istream &read(istream &is,Sales_data &item);
class Sales_data
{
friend Sales_data add(const Sales_data &lhs,const Sales_data &rhs);
friend ostream &print(ostream &os,Sales_data &item);
friend istream &read(istream &is,Sales_data &item);
private:
	string bookNo;
	unsigned units_sold=0;
	double revenue=0.0;
	double avg_price() const;
public:
	std::string isbn() const  {return bookNo;}
	Sales_data &combine(const Sales_data &);
	Sales_data():Sales_data("",0,0){}
	Sales_data(istream &is):Sales_data(){read(is,*this);}
	Sales_data(const string &s):Sales_data(s,0,0){}
	Sales_data(const string &s,unsigned n,double p):bookNo(s),units_sold{n},revenue{n*p}{}
};
inline double Sales_data::avg_price() const
{
	if(units_sold)
		return revenue/units_sold;
	else
		return 0;
}
Sales_data & Sales_data::combine(const Sales_data &rhs)
{
	units_sold+=rhs.units_sold;
	revenue+=rhs.revenue;
	return *this;
}
istream &read(istream &is,Sales_data &item)
{
	double price=0;
	is>>item.bookNo>>item.units_sold>>price;
	item.revenue=item.units_sold*price;
	return is;
}
ostream &print(ostream &os,Sales_data &item)
{
	os<<item.isbn()<<" "<<item.units_sold<<" "<<item.revenue<<" "<<item.avg_price();
	return os;
}
Sales_data add(const Sales_data &lhs,const Sales_data &rhs)
{
	Sales_data sum=lhs;
	sum.combine(rhs);
	return sum;
}
bool compareIsbn(Sales_data &s1,Sales_data &s2)
{
	return s1.isbn()<s2.isbn();
}
int main(void)
{
	Sales_data tmp;
	vector<Sales_data> Sales_data_vec;
	while(read(cin,tmp))
		Sales_data_vec.push_back(tmp);
	sort(Sales_data_vec.begin(),Sales_data_vec.end(),compareIsbn);
	for(auto &t:Sales_data_vec)
	{
		print(cout,t);
		cout<<endl;
	}
	return 0;
}

10.13

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
bool divide(const string &s)
{
	return s.size()>=5;
}
int main(void)
{
	string tmp;
	vector<string> svec;
	while(cin>>tmp)
		svec.push_back(tmp);
	const auto p=partition(svec.begin(),svec.end(),divide);
	for(auto beg=svec.cbegin();beg!=p;++beg)
		cout<<*beg<<" ";
	cout<<endl;
	return 0;
}

10.14

[](int a,int b)-> return int{return a+b;}

10.15

[a](int b)-> return int {return a+b;}

10.16

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
void elimDups(vector<string> &s)
{
	sort(s.begin(),s.end());
	auto end_unique=unique(s.begin(),s.end());
	s.erase(end_unique,s.end());
}
string make_plural(size_t count,const string &word,const string &end)
{
	return (count>1)?(word+end):word;
}
void biggies(vector<string> &words,vector<string>::size_type sz)
{
	elimDups(words);
	stable_sort(words.begin(),words.end(),[](const string &s1,const string &s2)-> bool {return s1.size()<s2.size();});
	auto wc=find_if(words.begin(),words.end(),[sz](const string &s)-> bool {return s.size()>=sz;});
	auto count=words.end()-wc;
	cout<<count<<" "<<make_plural(count,"word","s")<<" of length "<<sz<<" or longer "<<endl;
	for_each(wc,words.end(),[](const string &s){cout<<s<<" ";});
	cout<<endl;
}
int main(void)
{
	string tmp;
	vector<string> svec;
	cout<<"Enter some strings: ";
	while(cin>>tmp)
		svec.push_back(tmp);
	biggies(svec,3);
	return 0;
}

10.17

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
using namespace std;
class Sales_data;
istream &read(istream &is,Sales_data &item);
class Sales_data
{
friend Sales_data add(const Sales_data &lhs,const Sales_data &rhs);
friend ostream &print(ostream &os,Sales_data &item);
friend istream &read(istream &is,Sales_data &item);
private:
	string bookNo;
	unsigned units_sold=0;
	double revenue=0.0;
	double avg_price() const;
public:
	std::string isbn() const  {return bookNo;}
	Sales_data &combine(const Sales_data &);
	Sales_data():Sales_data("",0,0){}
	Sales_data(istream &is):Sales_data(){read(is,*this);}
	Sales_data(const string &s):Sales_data(s,0,0){}
	Sales_data(const string &s,unsigned n,double p):bookNo(s),units_sold{n},revenue{n*p}{}
};
inline double Sales_data::avg_price() const
{
	if(units_sold)
		return revenue/units_sold;
	else
		return 0;
}
Sales_data & Sales_data::combine(const Sales_data &rhs)
{
	units_sold+=rhs.units_sold;
	revenue+=rhs.revenue;
	return *this;
}
istream &read(istream &is,Sales_data &item)
{
	double price=0;
	is>>item.bookNo>>item.units_sold>>price;
	item.revenue=item.units_sold*price;
	return is;
}
ostream &print(ostream &os,Sales_data &item)
{
	os<<item.isbn()<<" "<<item.units_sold<<" "<<item.revenue<<" "<<item.avg_price();
	return os;
}
Sales_data add(const Sales_data &lhs,const Sales_data &rhs)
{
	Sales_data sum=lhs;
	sum.combine(rhs);
	return sum;
}
bool compareIsbn(Sales_data &s1,Sales_data &s2)
{
	return s1.isbn()<s2.isbn();
}
int main(void)
{
	Sales_data tmp;
	vector<Sales_data> Sales_data_vec;
	while(read(cin,tmp))
		Sales_data_vec.push_back(tmp);
	sort(Sales_data_vec.begin(),Sales_data_vec.end(),[](Sales_data &d1,Sales_data&d2)->bool{return d1.isbn()<d2.isbn();});
	for(auto &t:Sales_data_vec)
	{
		print(cout,t);
		cout<<endl;
	}
	return 0;
}

10.18

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
void elimDups(vector<string> &s)
{
	sort(s.begin(),s.end());
	auto end_unique=unique(s.begin(),s.end());
	s.erase(end_unique,s.end());
}
string make_plural(size_t count,const string &word,const string &end)
{
	return (count>1)?(word+end):word;
}
void biggies(vector<string> &words,vector<string>::size_type sz)
{
	elimDups(words);
	stable_sort(words.begin(),words.end(),[](const string &s1,const string &s2)-> bool {return s1.size()<s2.size();});
	auto wc=partition(words.begin(),words.end(),[sz](const string &s)-> bool {return s.size()<sz;});
	auto count=words.end()-wc;
	cout<<count<<" "<<make_plural(count,"word","s")<<" of length "<<sz<<" or longer "<<endl;
	for_each(wc,words.end(),[](const string &s){cout<<s<<" ";});
	cout<<endl;
}
int main(void)
{
	string tmp;
	vector<string> svec;
	cout<<"Enter some strings: ";
	while(cin>>tmp)
		svec.push_back(tmp);
	biggies(svec,3);
	return 0;
}

10.19

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
void elimDups(vector<string> &s)
{
	sort(s.begin(),s.end());
	auto end_unique=unique(s.begin(),s.end());
	s.erase(end_unique,s.end());
}
string make_plural(size_t count,const string &word,const string &end)
{
	return (count>1)?(word+end):word;
}
void biggies(vector<string> &words,vector<string>::size_type sz)
{
	elimDups(words);
	stable_sort(words.begin(),words.end(),[](const string &s1,const string &s2)-> bool {return s1.size()<s2.size();});
	auto wc=stable_partition(words.begin(),words.end(),[sz](const string &s)-> bool {return s.size()<sz;});
	auto count=words.end()-wc;
	cout<<count<<" "<<make_plural(count,"word","s")<<" of length "<<sz<<" or longer "<<endl;
	for_each(wc,words.end(),[](const string &s){cout<<s<<" ";});
	cout<<endl;
}
int main(void)
{
	string tmp;
	vector<string> svec;
	cout<<"Enter some strings: ";
	while(cin>>tmp)
		svec.push_back(tmp);
	biggies(svec,3);
	return 0;
}

10.20

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
void elimDups(vector<string> &s)
{
	sort(s.begin(),s.end());
	auto end_unique=unique(s.begin(),s.end());
	s.erase(end_unique,s.end());
}
string make_plural(size_t count,const string &word,const string &end)
{
	return (count>1)?(word+end):word;
}
void biggies(vector<string> &words,vector<string>::size_type sz)
{
	elimDups(words);
	stable_sort(words.begin(),words.end(),[](const string &s1,const string &s2)-> bool {return s1.size()<s2.size();});
	auto wc=find_if(words.begin(),words.end(),[sz](const string &s)-> bool {return s.size()>sz;});
	auto count=count_if(words.begin(),words.end(),[=](const string &s)->bool {return s.size()>sz;});
	cout<<count<<" "<<make_plural(count,"word","s")<<" longer than "<<sz<<endl;
	for_each(wc,words.end(),[](const string &s){cout<<s<<" ";});
	cout<<endl;
}
int main(void)
{
	string tmp;
	vector<string> svec;
	cout<<"Enter some strings: ";
	while(cin>>tmp)
		svec.push_back(tmp);
	biggies(svec,6);
	return 0;
}

10.21

[i]()mutable->bool{if(i>0) {--i;return false;}else return true;};

10.22

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <functional>
using namespace std;
using namespace std::placeholders;
void elimDups(vector<string> &s)
{
	sort(s.begin(),s.end());
	auto end_unique=unique(s.begin(),s.end());
	s.erase(end_unique,s.end());
}
string make_plural(size_t count,const string &word,const string &end)
{
	return (count>1)?(word+end):word;
}
bool check_sz(const string &s,string::size_type sz)
{
	return s.size()>sz;
}
void biggies(vector<string> &words,vector<string>::size_type sz)
{
	elimDups(words);
	stable_sort(words.begin(),words.end(),[](const string &s1,const string &s2)-> bool {return s1.size()<s2.size();});
	auto wc=find_if(words.begin(),words.end(),bind(check_sz,_1,sz));
	auto count=wc-words.begin();
	cout<<count<<" "<<make_plural(count,"word","s")<<" short than "<<sz<<endl;
	for_each(words.begin(),wc,[](const string &s){cout<<s<<" ";});
	cout<<endl;
}
int main(void)
{
	string tmp;
	vector<string> svec;
	cout<<"Enter some strings: ";
	while(cin>>tmp)
		svec.push_back(tmp);
	biggies(svec,6);
	return 0;
}

10.23

 bind是可变参数的。它接受的第一个参数是可调用对象，即实际工作函数A，返回供算法调用的新的可调用对象B。若A接受X个参数，则bind的参数个数就是X+1个，即除了A自身外，其他参数与A的形参一一对应。这些参数中，有些是占位符（_n），另外一些来自所处函数的局部变量。

10.24

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <functional>
using namespace std;
using namespace std::placeholders;
bool check_sz(const string &s,string::size_type sz)
{
	return s.size()>sz;
}
int main(void)
{
	string tmp;
	vector<string> svec;
	cout<<"Enter some string(q to quit):";
	while(cin>>tmp&&tmp!="q")
		svec.push_back(tmp);
	cout<<"Which string longer than:";
	cin>>tmp;
	auto p=find_if(svec.begin(),svec.end(),bind(check_sz,_1,tmp.size()));
	cout<<"The first longer than "<<tmp<<" is "<<*p<<endl;
	return 0;
}

10.25

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <functional>
using namespace std;
using namespace std::placeholders;
void elimDups(vector<string> &s)
{
	sort(s.begin(),s.end());
	auto end_unique=unique(s.begin(),s.end());
	s.erase(end_unique,s.end());
}
bool check_sz(const string &s,string::size_type sz)
{
	return s.size()<sz;
}
string make_plural(size_t count,const string &word,const string &end)
{
	return (count>1)?(word+end):word;
}
void biggies(vector<string> &words,vector<string>::size_type sz)
{
	elimDups(words);
	stable_sort(words.begin(),words.end(),[](const string &s1,const string &s2)-> bool {return s1.size()<s2.size();});
	auto wc=partition(words.begin(),words.end(),bind(check_sz,_1,sz));
	auto count=words.end()-wc;
	cout<<count<<" "<<make_plural(count,"word","s")<<" of length "<<sz<<" or longer "<<endl;
	for_each(wc,words.end(),[](const string &s){cout<<s<<" ";});
	cout<<endl;
}
int main(void)
{
	string tmp;
	vector<string> svec;
	cout<<"Enter some strings: ";
	while(cin>>tmp)
		svec.push_back(tmp);
	biggies(svec,3);
	return 0;
}

10.26

 back_inserter创建一个使用push_back的迭代器，front_inserter创建一个使用push_front的迭代器，inserter创建一个使用insert的迭代器。使用front_inserter向容器插入一些元素，元素最终在容器中的顺序与插入顺序相反，但 back_inserter 和 inserter 则不会有这个问题。

10.27

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;
int main(void)
{
	list<int> ilst;
	vector<int> ivec{9,1,9,2,2,3,3,3,4,4,4,4,5,5,5,5,5};
	sort(ivec.begin(),ivec.end(),[](const int a,const int b)->bool{return a<b;});
	unique_copy(ivec.begin(),ivec.end(),back_inserter(ilst));
	for_each(ilst.begin(),ilst.end(),[](const int i)->void{cout<<i<<" ";});
	return 0;
}

10.28

#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <forward_list>
#include <algorithm>
using namespace std;
int main(void)
{
	forward_list<int> iflst;
	list<int> ilst;
	deque<int> idq;
	vector<int> ivec{1,2,3,4,5,6,7,8,9};
	copy(ivec.begin(),ivec.end(),front_inserter(iflst));
	copy(ivec.begin(),ivec.end(),inserter(ilst,ilst.begin()));
	copy(ivec.begin(),ivec.end(),back_inserter(idq));

	for_each(iflst.begin(),iflst.end(),[](const int i)->void{cout<<i<<" ";});
	cout<<'\n';
	for_each(ilst.begin(),ilst.end(),[](const int i)->void{cout<<i<<" ";});
	cout<<'\n';
	for_each(idq.begin(),idq.end(),[](const int i)->void{cout<<i<<" ";});
	cout<<'\n';
	return 0;
}

10.29

#include <iostream>
#include <fstream>
#include <iterator>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
int main(int argc,char *argv[])
{
	ifstream infile(argv[1]);
	istream_iterator<string> it(infile),eof;
	vector<string> svec(it,eof);
	for_each(svec.begin(),svec.end(),[](const string &s)->void{cout<<s<<" ";});
	cout<<endl;
	return 0;
}

10.30

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

10.31

#include <iostream>
#include <iterator>
#include <algorithm>
#include <vector>
using namespace std;
int main(void)
{
	istream_iterator<int> it(cin),eof;
	ostream_iterator<int> ot(cout," ");
	vector<int> ivec(it,eof);
	sort(ivec.begin(),ivec.end());
	unique_copy(ivec.begin(),ivec.end(),ot);
	return 0;
}

10.32

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iterator>
#include "Sales_item.h"
using namespace std;
int main(int argc,char *argv[])
{
	ifstream infile(argv[1]);
	istream_iterator<Sales_item> it(infile),eof;
	vector<Sales_item> Sales_vec(it,eof);
	sort(Sales_vec.begin(),Sales_vec.end(),compareIsbn);
	vector<Sales_item>::iterator bg=Sales_vec.begin(),ed;
	while(bg!=Sales_vec.end())
	{
		ed=find_if_not(bg,Sales_vec.end(),[bg](Sales_item &s)->bool{return s.isbn()==bg->isbn();});
		cout<<accumulate(bg,ed,Sales_item(bg->isbn()))<<endl;
		bg=ed;
	}
	return 0;
}

10.33

#include <iostream>
#include <fstream>
#include <iterator>
using namespace std;
int main(int argc,char *argv[])//三个参数第一个是输入文件，第二个输出奇数，第三个输出偶数
{
	if(argc!=4)
	{
		cerr<<"usage: ./a.out arg1 arg2 arg3\n";
		return EXIT_FAILURE;
	}
	ifstream infile(argv[1]);
	ofstream ofile1(argv[2]),ofile2(argv[3]);
	istream_iterator<int> it(infile),eof;
	ostream_iterator<int> odd(ofile1," "),even(ofile2,"\n");
	while(it!=eof)
		if(*it%2)
			odd=*it++;
		else
			even=*it++;
	return 0;
}

10.34

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void)
{
	vector<int> ivec{0,1,2,3,4,5,6,7,8,9};
	for_each(ivec.crbegin(),ivec.crend(),[](int i)->void{cout<<i<<" ";});
	cout<<'\n';
	return 0;
}

10.35

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void)
{
	vector<int> ivec{0,1,2,3,4,5,6,7,8,9};
	for(auto p=ivec.end()-1;p!=ivec.begin()-1;--p)
		cout<<*p<<" ";
	cout<<'\n';
	return 0;
}

10.36

#include <iostream>
#include <algorithm>
#include <list>
using namespace std;
int main(void)
{
	list<int> ilst{3,0,2,1,5,4,0,8,0,9};
	auto p=find(ilst.crbegin(),ilst.crend(),0);
	++p;
	int count=0;
	for(auto bg=ilst.begin();bg!=p.base();++bg,++count);
	cout<<"最后一个值为零的元素在list中下标为"<<count<<"的位置上。"<<endl;
	return 0;
}

10.37

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;
int main(void)
{
	list<int> ilst;
	vector<int> ivec{0,1,2,3,4,5,6,7,8,9};
	vector<int>::reverse_iterator rbg(ivec.begin()+7),red(ivec.begin()+2);
	copy(rbg,red,back_inserter(ilst));
	for_each(ilst.begin(),ilst.end(),[](int i)->void{cout<<i<<" ";});
	cout<<endl;
	return 0;
}

10.38

  • 输入迭代器：只读，不写；单遍扫描，只能递增；还支持相等性判定运算（==、!=）、解引用运算符（*）（只出现在赋值运算符右侧）和箭头运算符（->）。
  • 输出迭代器：只写，不读；单遍扫描，只能递增；支持解引用运算符（*）（只出现在赋值运算符左侧）。
  • 前向迭代器：可读、写；多遍扫描；只能递增；支持所有输入、输出迭代器的操作。
  • 双向迭代器：可读、写；多遍扫描；可递增、递减；支持所有向前迭代器操作。
  • 随机访问迭代器：可读、写；多遍扫描；支持全部迭代器运算，除了上述迭代器类别支持的操作外，还有：
    1. 比较两个迭代器相对位置的关系运算符（<、<=、> 和 >=）
    2. 迭代器和一个整数值的加减运算（+、+=、- 和 -=）令迭代器在序列中前进或后退给定整数个元素
    3. 两个迭代器上的减法运算符（-）得到其距离
    4. 下标运算符

10.39

 list上的迭代器属于双向迭代器，vector上的迭代器属于随机访问迭代器。

10.40

 copy的前两个参数要求输入迭代器，第三个参数要求输出迭代器。reverse的两个参数要求双向迭代器。unique要求两个参数是前向迭代器。

10.41

  • replace(beg,end,old_val,new_val)将beg至end范围内的old_val替换为new_val
  • replace_if(beg,end,pred,new_val)将beg至end范围内谓词返回true的元素替换为new_val
  • replace_copy(beg,end,dest,old_val,new_val)将beg至end范围内的old_val替换为new_val，并将新的元素序列写入dest
  • replace_copy_if(beg,end,dest,pred,new_val)将beg至end范围内谓词返回true的元素替换为new_val,并将新的元素序列写入dest

10.42

#include <iostream>
#include <list>
using namespace std;
void elimDups(list<string> &);
void pt(list<string> &);
int main(void)
{
	string tmp;
	list<string> slst;
	while(cin>>tmp)
		slst.push_back(tmp);
	elimDups(slst);
	return 0;
}
void elimDups(list<string> &slst)
{
	pt(slst);
	slst.sort();
	pt(slst);
	slst.unique();
	pt(slst);
}
void pt(list<string> &slst)
{
	for(const auto &s:slst)
		cout<<s<<" ";
	cout<<endl;
}
fuluoyide312
关注
  • 11
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++Primer第五版——习题答案+详解(完整版)
MISAYAONE的博客
12-21 33万+
C++Primer第五版——习题答案详解 看的也比较快，但是有很多东西确实用不上，所以很多都没有深入的探讨，但是知识点覆盖的很全面，每一道题涉及的知识点我都写上简单的解释了。 文中代码的中文注释也尽量都写上，自己皆编译通过。 水平有限，如有有误之处，希望大家不吝指教！ 下面的链接是 第一章：全部题目(第一章基础较多)http:/
C++ primer第五版 练习 第二章
Echo_Hsu的博客
04-05 1024
2.1 类型 int、long、long long 和 short 的区别是什么？无符号类型和带符号类型的区别是什么？float 和 double的区别是什么？ int 最小是16位， long 是32位，long long是64位。 无符号只能表示大于等于0的值，有符号类型可以表示正数、负数、0 float表示单精度浮点数，double为双精度浮点数。float和double分别有7和16位有效...
C++Primer第五版 习题答案 目录
热门推荐
shamozhizhoutx的博客
07-29 5万+
C++Primer第五版 习题答案 本文当作我学习C++的一个记录，这里的习题答案并不是标准答案，仅仅是我的理解，如有错误，请大家指出，谢谢！ 我参考的文章会在文末列出，谢谢大家。 第一章 ...
《C++ primer 》第五版 第六章 笔记
还在路上的蒲公英
06-10 479
（）：函数调用运算符   实参的类型必须和对应的形参类型相同，函数有几个形参我们就必须提供几个相同数量的实参 函数的返回类型不能是数组类型或函数类型，但是可以是指向数组或者函数的指针。 局部静态对象：在程序的执行路径第一次经过时初始化，直到程序终止才被销毁，在此期间及时对象所在的函数结束执行，也不会对他有影响。 函数的声明和定义：声明不需要有函数体，所以也就不需要形参的名字。 数组形参：不
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
C++ primer第五版，英文版
03-17
锻炼自己的全英文C++ primer第五版电子版，更加适合于有一定代码功底人士阅读，初学者（你要读也很棒棒）阅读难度较大。
C++Primer 中文版第五版 习题代码实现 第一章
05-09
《C++ Primer 中文版第五版 习题代码实现 第一章》是一个针对初学者和有一定基础的C++程序员的学习资源，旨在通过实践加深对C++语言的理解。本章节主要涵盖了C++的基础知识，包括变量、基本数据类型、运算符、输入/...
C++ Primer中文版 第5版
02-22
C++ Primer中文版 第5版_PDF电子书下载 高清 带索引书签目录_(美)stanley b. lippman(斯坦利 李普曼)(著) 王刚;杨巨峰(译)_电子工业出版社_P838_2013-09-01
数据结构与算法分析--c语言描述(原书第二版)练习自答（第六章）
fuluoyide312的博客
07-21 2130
文章目录6.16.26.36.4 6.1 待完善 6.2 static void PercolateDown(int index,ElementType Data[],int Length) { ElementType Temp; int i,Child; for(i=index;i*2<=Length;i=Child) { Child=i*2; if(Chi
数据结构与算法分析--c语言描述(原书第二版)练习自答（第七章）
fuluoyide312的博客
08-30 1823
文章目录7.17.27.37.47.57.67.77.87.97.107.117.127.137.147.15 7.1 #!/bin/bash #形如7-1.sh 3 1 4 1 5 9 2 6 5的输入即可排序 array=(`echo $@`) length=${#array[@]} for((i=0;i<$length;i++)) do Tmp=${array[i]} j=$i while [ $j -gt 0 ]&&[ ${arr
c++ primer中文版第五版作业第十一章
fuluoyide312的博客
03-08 1482
如果关键字0在m中，则将其对应的值修改为1.如果关键字0不在m中，则向m中添加一个关键字为0，对应值为0的元素，然后将此元素的值修改为1.书中程序处理了这种情况的，如果文件中的某一行包含一个关键字和一个空格，那么这一行的转换规则不会录入map。而vector中的元素是按它们在容器中的位置来顺序保存和访问的。如果v中含有元素，则将v[0]赋值1.如果v是空的，则会产生严重错误。会返回相同的迭代器，迭代器会指向第一个不影响排序的关键字插入位置，而。中含有该关键字，那么下标操作会改变该关键字对应的值，而。
数据结构与算法分析--c语言描述练习自答（第二章）
fuluoyide312的博客
06-04 1394
2.7 2.7.h #ifndef _2_7_h #define _2_7_h #include <time.h> extern int RandInt(int i,int j); clock_t start,finish; extern void Substitution(int A[],int N); #endif RandInt.c #include <stdlib.h> #include <time.h> int RandInt(int i,int j) { .
数据结构与算法分析--c语言描述练习自答（第三章）(3.1~3.10)
fuluoyide312的博客
07-01 1349
list.h #ifndef _List_H #define _List_H struct Node; typedef struct Node *PtrToNode; typedef PtrToNode List; typedef PtrToNode Position; typedef int ElementType; List MakeEmpty(List L); //List L is unused int IsEmpty(List L); int IsLast(Position P,List L
c++ primer中文版第五版作业第十六章
fuluoyide312的博客
03-08 1275
特例化不影响函数匹配，它并不是为编译器进行函数匹配提供一个新的选择，而是为模版的一个特殊实例提供不同于原模版的特殊定义，本质上是接管了编译器在完成函数匹配后的部分实例化工作。如此一来，非可变参数版本就不在可变参数版本的作用域中，那么递归调用的将永远是可变参数版本的实例，即使res是空包，调用将依然进行下去，无法结束递归。用函数实参来确定模板实参的过程被称为模板实参推断，在模板实参推断的过程中，编译器使用函数调用中的实参类型来寻找模板实参，从而生成对应的模板实例。=而不是<，可减少你的算法适用容器的限制。
数据结构与算法分析--c语言描述(原书第二版)练习自答（第五章）
fuluoyide312的博客
06-30 1254
文章目录5.15.25.35.45.55.65.7 5.1 图片截自答案（非自己画的） 2. 3. 4. 将会插入失败 5.2 待完善 5.3 待完善 5.4 假设p为进行rehash时的装填因子，如果p接近或者等于1.0的话，那么一连串的insert和delete操作就会导致反复的rehash。 如果p为232\over332​，这时假设原tablesize是300，拥有elements200，在进行了100次delete后才需要调用rehash。如果tablesize是150，拥有eleme
c++ primer中文版第五版作业第十八章
最新发布
fuluoyide312的博客
03-08 1191
当mem1是一个string时程序因为更特例化的原因，会调用string中定义的swap版本，而int是内置类型，内置类型没有特定版本的swap，所以会调用std::swap。因为派生类的名字将隐藏基类的同名成员，所以MI不加前缀限定符的print函数只有接受std::vector参数的版本，而42无法隐式转换为该类型，所以调用失败。：使特定的命名空间中所有的名字都可见，这些名字一般被看作是出现在最近的外层作用域中，如果遇到成员冲突的情况，需要使用作用域运算符指明所需的版本。构造函数的执行顺序是。
c++ primer中文版第五版作业第三章
fuluoyide312的博客
02-29 1095
仓库地址 1.cpp 2.cpp 3.cpp 4.cpp 5.cpp 6.cpp 7.cpp 3.2 3-2-1.cpp 3-2-2.cpp 3.3   string类的输入运算符会忽略空白，getline函数会存储空白。3-4-1.cpp 3-4-2.cpp 3.5 3-5-1.cpp 3-5-2.cpp 3.6 3.7 一样的 3.8 3-8-1.cpp 3-8-2.cpp 3.9   不合法，使用下标访问空string的行为未定义。 3.11 合法，的类型是。 3.15 3.16 3.17 3
C++ Primer第五版中文习题集详尽答案
本书旨在提供详尽的指导，包括习题集中的所有题目，覆盖了C++ Primer中文版第5版的所有内容。它不仅包含了理论知识的巩固，还通过实际的编程练习帮助读者深入理解和掌握C++编程技巧。对于想要通过实践来提升C++编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值