C++Primer第五版 习题答案 第十章 泛型算法

于 2022-03-28 15:21:50 发布
阅读量774 收藏
点赞数 2
分类专栏： C++ 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24898229/article/details/123773037
版权

入坑C++、感觉像加入神魔 教一样魔教教主张无忌

10.1

#include<iostream>
#include<algorithm>
#include<vector>

using namespace std;

int main()
{
	vector<int>v1{ 1,2,4,5,3,1,5,6,8,7,1,1,1,1 };
	cout << count(v1.cbegin(), v1.cend(), 1) << endl;
	return 0;
}

10.2

#include<iostream>
#include<algorithm>
#include<string>
#include<list>

using namespace std;

int main()
{
	list<string>l1{ "we","he","we","she","it","we" };
	cout << count(l1.cbegin(), l1.cend(), "we") << endl;
	return 0;
}

10.3

#include<iostream>
#include<vector>
#include<numeric>

using namespace std;

int main()
{
	vector<int>v1{ 1,2,3,4,5,6,7,8,9,10 };
	cout << accumulate(v1.cbegin(), v1.cend(), 0);
	return 0;
}

10.4

第三个参数决定返回值类型，为int，精度降低；

#include<iostream>
#include<vector>
#include<numeric>

using namespace std;

int main()
{
	vector<double>v1{ 1,2,3,4,5,6,7,8,9,10 };
	cout << accumulate(v1.cbegin(), v1.cend(), 0);
	return 0;
}

10.5

equal会表示指针地址，而不是字符串值，比较结果与string类型不一致；

10.6

#include<iostream>
#include<vector>
#include<iterator>

using namespace std;

int main()
{
	vector<int>v1{ 1,2,3,4,5,6,7,8,9,10 };
	fill_n(v1.begin(), v1.size(), 0);
	for (const auto i : v1)
		cout << i << " ";
	cout << endl;

	vector<int>v2;
	fill_n(back_inserter(v2), 10, 1);
	for (const auto i : v2)
		cout << i << " ";
	cout << endl;
	return 0;

}

10.7

a）

copy(lst.cbegin(),lst.cend(),back_inserter(vec));

b)
没有报错，但与预期不符合，vec并没有10个元素，且每个元素都为0；

fill_n(back_inserter(v),10,0);

10.8

back_inserter是迭代器的一部分，而不是算法的一部分；

10.9

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

void elimDups(vector<string>& words)
{
	sort(words.begin(), words.end());
	for (const auto s : words)
		cout << s << " ";
	cout << endl;

	auto unque_end = unique(words.begin(), words.end());
	for ( const auto s : words)
		cout << s << " ";
	cout << endl;
	words.erase(unque_end, words.end());
	for (const auto s : words)
		cout << s << " ";
	cout << endl;
}

int main()
{
	vector<string> s1{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	elimDups(s1);
}

10.10

算法不执行容器操作，因此不改变容器大小，不改变容器大小使得算法更加通用；

10.11

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

vector<string> &elimDups(vector<string>& words)
{
	sort(words.begin(), words.end());
	auto unque_end = unique(words.begin(), words.end());
	words.erase(unque_end, words.end());
	return words;
}
bool isShorter(const string& s1, const string& s2)
{
	return s1.size() < s2.size();
}

int main()
{
	vector<string> s1{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	for (const auto s : elimDups(s1))
		cout << s << " ";
	cout << endl;
	stable_sort(s1.begin(), s1.end(), isShorter);
	for (const auto s : s1)
		cout << s << " ";
	cout << endl;
	return 0;

}

10.12

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include "../ch07_Classes/Sales_data_ex26.h"
#include <sstream>
#include <fstream>
#include <iostream>

using namespace std;

bool compareIsbn(const Sales_data &sales_data1, const Sales_data &sales_data2)
{
	return sales_data1.isbn() < sales_data2.isbn();
}

int main()
{
	vector<string> v1;

	ifstream is("../ch08_The_IO_Library/book_sales");
	string buf;

	if(!is)
	{
		cerr << "open error" << endl;
		return -1;
	}

	while(getline(is, buf))
		v1.push_back(buf);

	vector<Sales_data> v2;
	for(const auto &s : v1)
	{
		// cout << s << endl;
		istringstream iss(s);
		v2.push_back(Sales_data(iss));
	}

	stable_sort(v2.begin(), v2.end(), compareIsbn);

	for(const auto s : v2)
		cout << s.isbn() << endl;

	return 0;
}

10.13

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

bool greater_than_5(const string& s)
{
	return s.size() >= 5;
}

int main()
{
	vector<string> s1{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	for (const auto s : s1)
		cout << s << " ";
	cout << endl;
	auto iter = partition(s1.begin(), s1.end(), greater_than_5);
	s1.erase(iter, s1.end());

	for (const auto s : s1)
		cout << s << " ";
	cout << endl;
	return 0;
}

10.14

#include<iostream>

using namespace std;

int main()
{
	auto add_int = [](int x, int y) {return x + y; };
	cout << add_int(1, 2)<<endl;;
	return 0;
}

10.15

#include<iostream>

using namespace std;

int main()
{
	int x = 1;
	auto add_int = [x](int y) {return x + y; };
	cout << add_int(2)<<endl;;
	return 0;
}

10.16

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>

using namespace std;

vector<string>& elimdUps(vector<string >& words)
{
	sort(words.begin(), words.end());
	auto unique_end = unique(words.begin(), words.end());
	words.erase(unique_end, words.end());
	return words;
}

void bidggies(vector < string>& words, vector<string>::size_type sz)
{
	elimdUps(words);
	stable_sort(words.begin(), words.end(), [](const string& a, const string& b) {return a.size() < b.size(); });
	auto wc = find_if(words.begin(), words.end(), [sz] (const string& a) { return a.size() >= sz; });
	auto count = words.end() - wc;
	cout << count << endl;
	for_each(wc, words.end(), [](const string& s) {cout << s << " "; });
	cout << endl;
}

int main()
{
	vector<string> s1{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	bidggies(s1, 5);
	return 0;
}

10.17

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include "../ch07_Classes/Sales_data_ex26.h"
#include <sstream>
#include <fstream>
#include <iostream>

using namespace std;

int main()
{
	vector<string> v1;

	ifstream is("../ch08_The_IO_Library/book_sales");
	string buf;

	if(!is)
	{
		cerr << "open error" << endl;
		return -1;
	}

	while(getline(is, buf))
		v1.push_back(buf);

	vector<Sales_data> v2;
	for(const auto &s : v1)
	{
		// cout << s << endl;
		istringstream iss(s);
		v2.push_back(Sales_data(iss));
	}

	stable_sort(v2.begin(), v2.end(), []
		(const Sales_data &sales_data1, const Sales_data &sales_data2)
			{ return sales_data1.isbn() < sales_data2.isbn(); });

	for(const auto s : v2)
		cout << s.isbn() << endl;

	return 0;
}

10.18

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>

using namespace std;

vector<string>& elimdUps(vector<string >& words)
{
	sort(words.begin(), words.end());
	auto unique_end = unique(words.begin(), words.end());
	words.erase(unique_end, words.end());
	return words;
}

void bidggies(vector < string>& words, vector<string>::size_type sz)
{
	elimdUps(words);
	stable_sort(words.begin(), words.end(), [](const string& a, const string& b) {return a.size() < b.size(); });
	auto wc = partition(words.begin(), words.end(), [sz] (const string& a) { return a.size() >= sz; });
	auto count = wc-words.begin();
	cout << count << endl;
	for_each(words.begin(),wc, [](const string& s) {cout << s << " "; });
	cout << endl;
}

int main()
{
	vector<string> s1{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	bidggies(s1, 5);
	return 0;
}

10.19

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>

using namespace std;

vector<string>& elimdUps(vector<string >& words)
{
	sort(words.begin(), words.end());
	auto unique_end = unique(words.begin(), words.end());
	words.erase(unique_end, words.end());
	return words;
}

void bidggies(vector < string>& words, vector<string>::size_type sz)
{
	elimdUps(words);
	stable_sort(words.begin(), words.end(), [](const string& a, const string& b) {return a.size() < b.size(); });
	auto wc = stable_partition(words.begin(), words.end(), [sz] (const string& a) { return a.size() >= sz; });
	auto count = wc-words.begin();
	cout << count << endl;
	for_each(words.begin(),wc, [](const string& s) {cout << s << " "; });
	cout << endl;
}

int main()
{
	vector<string> s1{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	bidggies(s1, 5);
	return 0;
}

10.20

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>

using namespace std;

int main()
{
	vector<string> s1{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	string::size_type sz = 6;
	cout << count_if(s1.begin(), s1.end(), [sz](const string& s) {return s.size() >= sz; });
	return 0;
}

10.21

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>

using namespace std;

int main()
{
	int i = 5;
	auto reduce_i = [&i]()->bool 
	{
		if (i <= 0)
			return false;
		else
		{
			--i;
			return true;
		}
	};

	while (reduce_i())
	{
		cout << i << endl;
	}
	return 0;
}

10.22

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<functional>

using namespace std;

bool judue_size(const string& s, string::size_type sz)
{
	return s.size() >= sz;
}

int main()
{
	vector<string> s1{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	cout << count_if(s1.begin(), s1.end(), bind(judue_size, placeholders::_1, 6)) << endl;
}

10.23

n+1。假设函数有n个参数，则绑定这n个参数加上函数本身；

10.24

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<functional>

using namespace std;
bool cheak_size(string& s, int sz)
{
	return s.size() < sz;
}

int main()
{
	vector<int >v1{ 1,2,3,4,5,6 };
	string s1{ "he" };
	auto iter = find_if(v1.begin(), v1.end(), bind(cheak_size, s1, placeholders::_1));
	cout << *iter << endl;
	return 0;
}

10.25

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<functional>

using namespace std;

vector<string>& elimdUps(vector<string >& words)
{
	sort(words.begin(), words.end());
	auto unique_end = unique(words.begin(), words.end());
	words.erase(unique_end, words.end());
	return words;
}

bool cheak_size(const string& s, string::size_type sz)
{
	return s.size() > sz;
}

void bidggies(vector < string>& words, vector<string>::size_type sz)
{
	elimdUps(words);
	stable_sort(words.begin(), words.end(), [](const string& a, const string& b) {return a.size() < b.size(); });
	auto wc = partition(words.begin(), words.end(), bind(cheak_size,placeholders::_1,sz));
	auto count = wc - words.begin();
	cout << count << endl;
	for_each(words.begin(), wc, [](const string& s) {cout << s << " "; });
	cout << endl;
}

int main()
{
	vector<string> s1{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	bidggies(s1, 5);
	return 0;
}

10.26

back_inserter创建一个push_back 的迭代器；
front_inserter创建一个push_front的迭代器；
inserter创建一个inserter迭代器。此函数接受第二个参数，这个参数必须是指向给定容器的迭代器，元素将被插入到给定迭代器所表示的元素之前；

10.27

#include<iostream>
#include<vector>
#include<list>
#include<algorithm>

using namespace std;
 
int main()
{
	list<int>l1;
	vector<int> v1{ 1,5,2,1,4,6,3,2,6,5,7,8,9,4,9,1,2 };
	sort(v1.begin(), v1.end());
	unique_copy(v1.begin(), v1.end(), back_inserter(l1));
	for (const auto i : l1)
		cout << i << " ";
	cout << endl;
	return 0;
}

10.28

#include<iostream>
#include<vector>
#include<list>
#include<algorithm>

using namespace std;
 
int main()
{
	list<int>l1,l2,l3;
	vector<int> v1{ 1,2,3,4,5,6,7,8,9 };
	copy(v1.begin(), v1.end(), inserter(l1,l1.begin()));
	for (const auto i : l1)
		cout << i << " ";
	cout << endl;

	copy(v1.begin(), v1.end(), back_inserter(l2));
	for (const auto i : l2)
		cout << i << " ";
	cout << endl;

	copy(v1.begin(), v1.end(), front_inserter(l3));
	for (const auto i : l3)
		cout << i << " ";
	cout << endl;
}

10.29

#include<iostream>
#include<vector>
#include<fstream>
#include<algorithm>

using namespace std;
 
int main()
{
	ifstream ifs("letter.txt");
	istream_iterator<string> str_istream_iter(ifs), eof;
	vector<string> v1(str_istream_iter, eof);
	ostream_iterator<string> str_ostream_iter(cout, " ");
	copy(v1.begin(), v1.end(), str_ostream_iter);
	return 0;
}

10.30

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;
 
int main()
{
	istream_iterator<int> int_cin(cin), eof;
	vector<int>v1(int_cin, eof);
	sort(v1.begin(), v1.end());
	ostream_iterator<int> out_iter(cout, " ");
	copy(v1.begin(), v1.end(),out_iter);
	return 0;
}

10.31

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;
 
int main()
{
	istream_iterator<int> int_cin(cin), eof;
	vector<int>v1(int_cin, eof);
	sort(v1.begin(), v1.end());
	ostream_iterator<int> out_iter(cout, " ");
	unique_copy(v1.begin(), v1.end(),out_iter);
	return 0;
}

10.32

#include <iostream>
#include <iterator>
#include <fstream>
#include <vector>
#include <algorithm>
#include "../ch01_Getting_Started/Sales_item.h"

using namespace std;

int main()
{
	istream_iterator<Sales_item> int_cin(cin), eof;
	vector<Sales_item> v1(int_cin, eof);
	sort(v1.begin(), v1.end(), compareIsbn);
	// for(const auto s : v1)
	// 	cout << s.isbn() << endl;
	cout << endl;
	for(auto beg = v1.cbegin(), end = beg; beg != v1.cend(); beg = end)
	{
		end = find_if(beg, v1.cend(), [beg](const Sales_item &sale_item){ return sale_item.isbn() != beg->isbn(); });
		cout << accumulate(beg, end, Sales_item(beg->isbn())) << endl;
	}

	return 0;
}

10.33

#include<iostream>
#include<vector>
#include<algorithm>
#include<fstream>


using namespace std;
 
int main(int argc,char **argv)
{
	if (argc != 4)return -1;
	ifstream ifs(argv[1]);
	istream_iterator <int> int_istream_iter(ifs), eof;
	vector<int>v1(int_istream_iter, eof);
	
	ofstream ofs_odd("argv[2]");
	ostream_iterator<int> odd_iter(ofs_odd, " ");
	copy_if(v1.begin(), v1.end(),odd_iter, [](int i) {return i % 2; });
	ofs_odd.close();


	ofstream ofs_even("argv[3]");
	ostream_iterator<int> even_iter(ofs_even, " ");
	copy_if(v1.begin(), v1.end(), even_iter, [](int i) {return !(i % 2); });
	ofs_even.close();
	
}

10.34

#include<iostream>
#include<vector>

using namespace std;
 
int main()
{
vector<int>v1{ 1,2,3,4,5,6,7 };
	for (auto r_iter = v1.crbegin(); r_iter != v1.crend(); ++r_iter)
		cout << *r_iter << " ";
	cout << endl;
	return 0;
}

10.35

#include <iostream>
#include <iterator>
#include <vector>

using namespace std;

int main()
{
vector<int> v1 = { 1,2,3,4,5,6,7,8 };
	for (auto iter = v1.cend() - 1; iter != v1.cbegin() ; --iter)
		cout << *iter << " ";
	cout << *v1.cbegin() << " ";
	cout << endl;
	return 0;
}

10.36

#include <iostream>
#include <iterator>
#include<list>

using namespace std;

int main()
{
	list<int>l1{ 0,1,2,3,4,5,6,0 };
	auto r_iter = find(l1.crbegin(), l1.crend(), 0);
	cout <<*r_iter << endl;
}

10.37

#include <iostream>
#include <iterator>
#include<list>
#include<vector>

using namespace std;

int main()
{
	vector<int>v1{ 0,1,2,3,4,5,6,7,8,9 };
	list<int>l1(v1.crbegin() + 2, v1.crbegin() + 7);
	for (const auto i : l1)
		cout << i << " ";
	cout << endl;
	return 0;
}

10.38

输入迭代器： == , != , ++,*, ->;
输出迭代器：++, *;
前向迭代器： ，!=,++,*,->;
双向迭代器：，!=,++,–，*,->;
随机访问迭代器 ==,!=,++,–,*,->,<=,>,>=,+,+=,-;

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之间，如果谓词条件满足则替换为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之间，如果满足谓词则替换为new_val，将结果复制到dest；

10.42

#include <iostream>
#include<list>
#include<string>
#include<algorithm>

using namespace std;

list<string>& elimDups(list<string >& s)
{
	s.sort();
	s.unique();
	return s;
}
int main()
{
	list<string>l1{ "a","b","a","e","c","g","d" };
	for (const auto s : elimDups(l1))
		cout << s << " ";
	cout << endl;
	return 0;
}
Perz_01
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ Primer(第五版)|练习题答案与解析(第十章:泛型算法)
01-06
C++ Primer(第五版)|练习题答案与解析(第十章:泛型算法) 本博客主要记录C++ Primer(第五版)中的练习题答案与解析。 参考:C++ Primer C++ Primer 练习题10.1 头文件algorithm中定义了一个名为count的函数，它类似find...
《C++ Primer》学习笔记（十）：泛型算法
南方以北
05-17 398
《C++ Primer》学习笔记（十）：泛型算法初识泛型算法只读算法写容器元素的算法重排容器元素的算法定制操作向算法传递函数lambda表达式 泛型算法是一组公共接口，可以用于不同类型的元素和多种容器类型。 泛型算法本身不会执行容器的操作，只会运行于特定迭代器上，执行迭代器的操作，即不会改变底层容器的大小。但是标准库定义了一类特殊的迭代器：插入器（inserter)。与普通迭代器只能遍历所绑定的容器相比，插入器能做更多的事情。当给这类迭代器赋值时，它们会在底层的容器上执行插入操作。因此当一个算法操作这样的迭
C++ 泛型算法（一）初识泛型算法，lambda表达式
强者之路
04-14 674
文章目录概述算法工作原理泛型算法只读算法写容器算法重排容器元素算法指定操作及算法传参lambda表达式谓词lambda介绍lambda传参捕获列表用lambda改写算法lambda捕获和返回值捕获引用捕获隐式捕获显式捕获可变lambda指定lambda返回类型 概述 对于顺序容器的操作，我们前面介绍了添加，删除，大小操作，但是我们还有比如查找，排序等操作，这些操作是基于算法的，C++给我们提供了...
C++Primer第五版 第十章习题答案（1~10）
whjstudy1的博客
10-22 840
1：这个比较简单，类比下 find() 函数也就知道了。 #include&lt;iostream&gt; #include&lt;algorithm&gt; #include&lt;vector&gt; using namespace std; void main() { int number = 0; int arr[] = { 0, 0, 1, 2, 3, 4, 5, 6, 7, 8...
C++Primer 第五版 —— 《第十章 》泛型算法
TAOTAO
01-03 468
目录 目录 Preface 概述（ find 算法） find 算法是如何工作的 只读算法(find、count、accumulate 338P） 使用accumulate 算法将 vector中的 string 元素连接起来 用equal 操作两个序列（339P） 使用 fill 和 fill_n 算法向容器写入元素（340P） 介绍 back_inserter 插入迭代器...
C++ 字符串序列 进行长度 排序的同时，保持字典序排序
Become hunger become strong
03-06 5573
elimDups实现了字典排序： unique()算法的作用是吧重复的元素放到最后并用”???”覆盖；然后用容器erase操作来删除后面。 stable_sort()就是在长度排序下，保持字典序。#include <iostream> #include <algorithm> using namespace std;void elimDups(vector<string> &word
C++Primer第11章-泛型算法-课后习题答案[收集].pdf
10-11
C++Primer第11章-泛型算法-课后习题答案[收集].pdf
C++ Primer习题集(第五版)
12-08
C++ Primer习题集(第五版) , 带目录完整版。 --------------------------------------------------------------------------- 目录 第1章............................................................ 1 练习1.1 ...
C++ Primer第四版【中文高清扫描版】.pdf
03-13
第11章　泛型算法 335 11.1 概述 336 11.2 初窥算法 339 11.2.1 只读算法 339 11.2.2 写容器元素的算法 341 11.2.3 对容器元素重新排序的算法 343 11.3 再谈迭代器 347 11.3.1 插入迭代器 348 11.3.2 iostream迭代器...
java坑爹的笔试题-cpp-primer-5th:C++Primer第五版学习资料
06-13
C++Primer第五版——习题答案+详解(完整版) 作者学习心得 2017年3月23日更新：历时三个月，粗略的算是看完了这本书，简单的进行总结一下： 本书的Part I（C++基础）是C++基础，必须进行通读掌握。这几章有非常多的小...
C++primer 第五版课后习题答案全解
12-04
C++primer 第五版课后习题答案全解，里面的答案很详细，可以配合教材C++primer自己多多学习！
C++primer学习笔记及作业答案之第十章
blue_coffeei的博客
05-09 488
笔记： 1.概述 迭代器令算法不依赖于容器，但算法依赖于元素类型的操作。 标准库通过算法和数据结构的分离来实现泛型。 算法永远不会改变底层容器的大小。 2.初识泛型算法 C风格字符串本质是char *类型，用==比较两个char *对象，只是检查两个指针值是否相等，即地址是否相等，而不会比较其中字符是否相同 标准库算法从来不直接操作容器，它们只操作迭代器，从而间接访问容器。能不能插入...
C++lambda表达式
GUI1259802368的博客
07-02 632
在介绍lambda表达式之前，先来看一下什么是谓词。下面是一个例子 void elimDups(vector&lt;string&gt; &amp;words) { sort(words.begin(),words.end()); //按字典序排序words,以便查找重复单词 //排列在范围的前部，返回指向不重复区域之后一个位置的迭代器 a...
c++primer笔记----泛型算法
看风景的人lsy
07-29 206
大多数算法在&lt;algorithm&gt;。泛型算法运行在迭代器之上 auto result = find(vec.begin(), vec.end(), val); int ia = [1, 2, 3]; int * result = find(begin(ia), end(ia)); 数组利用指针实现泛型算法 只读算法：find、count、accumulate, &lt;n...
C++lambda表达式及bind函数总结
qq_39540537的博客
09-16 602
目录 引入lambda 值捕获 使用捕获列表 参数绑定 标准库bind函数 绑定check_size的sz参数 以下是对阅读<<C++Primer (第5版)>>lambda阅读部分总结 在实际的编程过程中,对于某些函数,我们希望对于传入的参数列表,其中某些参数是固定的值,而另外一个参数随着调用次数的增长而传入一个像STL容器一样的可迭代对象,对象的值随着*iterator值得不同而改变,每次调用该函数后会执行iterator++,并再次通过相同的传入参数调用该函数。
c++primer第五版第十章练习
nonororo的博客
11-18 1538
10.1 #include #include //count #include int main() { using namespace std; vector vec = { 4, 9, 3, 5, 8, 6, 6, 5, 4 }; cout << count(vec.begin(), vec.end(), 4); //统计4在vec元素里出现的次数 system("pau
C++ primer 第五版 中文版 练习 10.9 个人code
jierandefeng的专栏
09-04 731
C++ primer 第五版 中文版 练习 10.9 题目：实现你自己的elimDups。测试你的程序，分别在读取输入后、调用unique后以及调用erase后打印vector的内容。 答：
《C++primer(第五版)》学习之路-第十章：泛型算法
月下的寂寞肖邦
09-25 2395
【 声明：版权所有，转载请标明出处，请勿用于商业用途。  联系信箱：[email protected]】 10.1 概述 1.大多数算法都定义在头文件algorithm中。标准库还在文件numeric中定义了一组数值泛型算法。 10.2 初识泛型算法 1. accumulate：定义在头文件numeric中。作用是对范围求和。 euqal：定
c++ 泛型算法
杨博东的博客
02-25 999
1：c++的算法库中有超过100个算法，这些算法均不会直接操作底层的元素，他们是通过操作迭代器规定的范围来实现的。3：只读算法,操作两个序列的算法，写容器的算法,插入迭代器，拷贝算法(1)：只读算法如”std::find”,”std::count”之类的算法，不会改变元素的值。对于只读取而不改变元素的算法，通常最好使用cbegin()和cend(),但是如果计划了使用算法返回的迭代器来改变元素的值，
c++ primer第五版课后习题
最新发布
07-08
C++ Primer第五版是一本非常经典的C++编程入门教材，它包含了大量的课后习题帮助读者巩固所学的知识。这些习题涵盖了从基础到高级的各个方面，可以帮助读者提升编程能力。 如果你有具体的习题需要帮助或者想要了解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值