C++primer-学习心得-第十章-泛型算法

于 2020-02-25 19:11:33 发布
阅读量399 收藏
点赞数
分类专栏： 笔记 C/C++ 文章标签： c++ 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhh22900/article/details/104503309
版权
笔记 同时被 2 个专栏收录
35 篇文章 3 订阅
订阅专栏
C/C++
31 篇文章 3 订阅
订阅专栏

文章目录

C++primer-学习心得-第十章-泛型算法

上个章节学习了各种顺序容器，但顺序只定义了很少的操作，我们能做的事情还很少，我们希望能做更多的事情如：查找特定元素、替换或删除一个特定值、重排元素顺序等。标准库没有给每个容器定义相关的成员函数来实现这些操作，但定义了一组泛型算法：算法：实现了一些经典算法的公共接口（如排序和搜索），泛型：可以用于不同类型的元素和多种容器类型（不仅包括标准库类型还包括内置的数组类型），还能用于其他类型的序列。

10.1 概述

大多数算法都定义在头文件algorithm中，标准库还在头文件numeric中定义了一组数值泛型算法。为了说明算法是如何用于不同容器的，我们以find为例，find的工作是在一个未排序的元素序列中查找一个特定元素。概念上find将执行如下步骤。

  1. 访问序列中的首元素
  2. 比较此元素与我们要查找的值
  3. 如果此值与我们要查找的值匹配，find返回表示此元素的值
  4. 否则，find前进到下一个元素，重复步骤2、3
  5. 如果到达序列尾，find应停止
  6. 如果find到达序列末尾，它应该返回一个指出元素未找到的值，这个值的类型应与步骤3中返回值的类型相容。

这些步骤都不依赖容器保存的元素类型，因此只要有一个迭代器可用来访问元素，find就完全不依赖于容器类型。

练习10.1
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>

using namespace std;
int main() {
	vector<int> vi = { 1,2,3,2,1,2,3,2,3,22,4,52,3,4,5,67,78,76,6,5,5,4 };
	auto test = count(vi.cbegin(), vi.cend(), 2);
	cout << test << endl;
}
练习10.2
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
using namespace std;
int main() {
	list<string>ls = {"a","a","a","reo","reoreo","b","b"};
	auto a=count(ls.cbegin(), ls.cend(), "a");
	cout << a << endl;
}

10.2 初识泛型算法

标准库提供了超过一百种算法，有容器类似地这些算法有一致的结构，所以我从理解结构入手更好一点。除了少数例外，标准库算法都对一个范围内的元素（输入范围）进行操作，这个范围通常由一对迭代器表示。通常他们使用范围内的元素的方式是不同的，如是否读取元素，改变元素，重排元素顺序。

1. 只读算法

如前面接触的find和count，不会改变元素。另一个只读算法是accumulate，定义在头文件numeric中。

练习10.3
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;
int main() {
	vector<int>vi = { 1,2,3,23,23,12,12,23,32,3,423,3,2,21,2,3,4,67,8,9,6 };
	auto sum = accumulate(vi.begin(), vi.end(), 0);
	cout << sum << endl;
}

另一个只读算法是equal，

equal(r1.cbegin(),r1.cend(),r2.cbegin());

2.写容器元素的算法

如fill将给定值赋予给输入范围的每个元素。fill_n接受一个单迭代器，一个计数值和一个值，将定值赋予给迭代器指向的元素开始的n个值。

back_insert

插入迭代器：向容器中添加元素的迭代器。而back_insert定义在头文件iterator中，它接受一个指向容器的引用返回一个与容器绑定的插入迭代器。

vector<int>vec;
auto it=back_insert(vec);
*it=22;
fill_n(back_insert(vec),10,0);

copy算法

int a[]={0,1,2,3,4,5};
int a2[sizeof(a)/sizeof(*a)];
auto ret=copy(begin(a),end(a),a2);
练习10.6
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;
int main() {
	vector<int>vi = { 1,2,3,23,23,12,12,23,32,3,423,3,2,21,2,3,4,67,8,9,6 };
	fill_n(vi.begin(), vi.size(), 0);
	for (auto c : vi) {
		cout << c << endl;
	}
}

3.重排容器元素的算法

sort,unique

练习10.9
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;
void elimdups(vector<int>&vi) {
	sort(vi.begin(), vi.end());
	auto end_u = unique(vi.begin(), vi.end());
	vi.erase(end_u, vi.end());
}
int main() {
	vector<int>vi = { 1,2,3,23,23,12,12,23,32,3,423,3,2,21,2,3,4,67,8,9,6 };
	elimdups(vi);
	for (auto c : vi) {
		cout << c << endl;
	}
}

10.3定制操作

1.向算法传递函数

谓词：是一个可调用的表达式，其返回结果是一个可用作条件的值。有两类谓词：一元谓词（只接受单一参数）、二元谓词（两个参数）。接受谓词参数的算法对输入序列中的元素调用谓词，因此元素类型必须能转换为谓词的参数类型。如sort接受一个二元谓词参数。（JavaScript也有类似的机制）

bool isShorter(const string &s1,const string &s2){
return s1.size()<s2.size();
}
sort(words.begin(),words.end(),isShorter);

另外还有stable_sort保存等长元素间的字典序。

练习10.11
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;
bool isShorter(const int& v1,const int& v2) { return v1 > v2; }//二元谓语
void elimdups(vector<int>&vi) {
	sort(vi.begin(), vi.end(),isShorter);
	auto end_u = unique(vi.begin(), vi.end());
	vi.erase(end_u, vi.end());
}
int main() {
	vector<int>vi = { 1,2,3,23,23,12,12,23,32,3,423,3,2,21,2,3,4,67,8,9,6 };
	elimdups(vi);
	for (auto c : vi) {
		cout << c << endl;
	}
}
练习10.12
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;
class Sales_data {//偷个懒就创建一个简单的Sales_data类
public:
	string getisbn() { return bookNo; }
	Sales_data(string s, unsigned u, double d) :bookNo(s), sold(u), revenue(d) {}
	Sales_data() :Sales_data(" ", 0, 0.0) {}
	Sales_data(string s) :Sales_data(s, 0, 0.0) {}
private:
	string bookNo;
	unsigned sold;
	double revenue;
};
bool isShorter(Sales_data& s1,  Sales_data& s2) {
	return s1.getisbn() > s2.getisbn();
}
void elimdups(vector<Sales_data>&vi) {
	sort(vi.begin(), vi.end(),isShorter);
	//auto end_u = unique(vi.begin(), vi.end());
	//vi.erase(end_u, vi.end());
}
int main() {
	vector<Sales_data>vi;
	vi.emplace_back("ssss");
	vi.emplace_back("asdf", 12, 22);
	vi.emplace_back("afasd", 12, 22);
	vi.emplace_back("dsfa", 23, 223);
	elimdups(vi);
	for (auto it = vi.begin(); it != vi.end();it++) {
		cout << it->getisbn() << endl;
	}
}
练习10.13
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;

bool sizes(string s) {
	return s.size()<5?true:false;
}
int main() {
	vector<string> vs = { "asdf","afdfasd","q3qwer","asd","dfg" };
	auto end_p=partition(vs.begin(), vs.end(), sizes);
	if (end_p == vs.end()) {
		cout << "没有长度大于等于5的字符串" << endl;
	}
	else {
		for (auto it = end_p; it != vs.end(); it++) {
			cout << *it << endl;
		}
	}
}

2.lambda表达式

一个lambda表达式表示一个可调用的代码单元。可以理解未未命名的内联函数。与函数类似，一个lambda具有一个返回类型、一个参数列表和一个函数体。但不同的是它可以定义在函数内部。

[capture list](parameter list)->return type{function body}
练习10.14
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;

bool sizes(string s) {
	return s.size()<5?true:false;
}
int main() {
	int a = 10, b = 20;
	auto c = [](int a,int b) {return a + b; };
	cout<<c(a,b)<<endl;
}
练习10.15
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;

bool sizes(string s) {
	return s.size()<5;
}
int main() {
	int a = 10, b = 20;
	auto c = [a](int b) {return a + b; };
	cout<<c(b)<<endl;
}
练习10.17
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;
class Sales_data {//偷个懒就创建一个简单的Sales_data类
public:
	string getisbn() { return bookNo; }
	Sales_data(string s, unsigned u, double d) :bookNo(s), sold(u), revenue(d) {}
	Sales_data() :Sales_data(" ", 0, 0.0) {}
	Sales_data(string s) :Sales_data(s, 0, 0.0) {}
private:
	string bookNo;
	unsigned sold;
	double revenue;
};
void elimdups(vector<Sales_data>& vi) {
	sort(vi.begin(), vi.end(), [](Sales_data& s1, Sales_data& s2) {
		return s1.getisbn() > s2.getisbn();
		});
	//auto end_u = unique(vi.begin(), vi.end());
	//vi.erase(end_u, vi.end());
}
int main() {
	vector<Sales_data>vi;
	vi.emplace_back("ssss");
	vi.emplace_back("asdf", 12, 22);
	vi.emplace_back("afasd", 12, 22);
	vi.emplace_back("dsfa", 23, 223);
	elimdups(vi);
	for (auto it = vi.begin(); it != vi.end(); it++) {
		cout << it->getisbn() << endl;
	}
}
练习10.18
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;

void elimdups(vector<string>& vi) {
	sort(vi.begin(), vi.end());
	auto end_u = unique(vi.begin(), vi.end());
	vi.erase(end_u, vi.end());
}
void biggies(vector<string>& words, vector<string>::size_type sz) {
	elimdups(words);
	auto end_p = partition(words.begin(), words.end(), [sz](const string s) {return s.size() < sz; });
	for (auto it = end_p; it != words.end(); it++) {
		cout << *it << endl;
	}
}
int main() {
	vector<string>words = { "reoreo","The world","flandre","a","b","sss","sasdf","aaa" };
	vector<string>::size_type sz = 6;
	biggies(words, sz);
}
练习10.19
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;

void elimdups(vector<string>& vi) {
	sort(vi.begin(), vi.end());
	auto end_u = unique(vi.begin(), vi.end());
	vi.erase(end_u, vi.end());
}
void biggies(vector<string>& words, vector<string>::size_type sz) {
	elimdups(words);
	auto end_p = stable_partition(words.begin(), words.end(), [sz](const string s) {return s.size() < sz; });
	for (auto it = end_p; it != words.end(); it++) {
		cout << *it << endl;
	}
}
int main() {
	vector<string>words = { "reoreo","The world","flandre","a","b","sss","sasdf","aaa" };
	vector<string>::size_type sz = 6;
	biggies(words, sz);
}

3.lambda的捕获和返回

  • []
  • [names]
  • [&]：引用捕获
  • [=]：值捕获
  • [&,identifier_list]
  • [=,identifier_list]

对于一个值被拷贝的变量可以加关键字mutable来允许改变被捕获的值。（值捕获+mutable–>引用捕获）

当我们需要为lambda表达式定义返回类型时必须使用尾置返回类型。

练习10.20
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;

void elimdups(vector<string>& vi) {
	sort(vi.begin(), vi.end());
	auto end_u = unique(vi.begin(), vi.end());
	vi.erase(end_u, vi.end());
}
void biggies(vector<string>& words, vector<string>::size_type sz) {
	elimdups(words);
	auto counts = count_if(words.begin(), words.end(), [sz](const string s) {return s.size() >= sz; });
	cout << counts << endl;
}
int main() {
	vector<string>words = { "reoreo","The world","flandre","a","b","sss","sasdf","aaa" };
	vector<string>::size_type sz = 6;
	biggies(words, sz);
}
练习10.21
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;


int main() {
	int a = 10;
	auto f = [&]() {
		if (a == 0) {
			return true;
		}
		else {
			while (a > 0)
				--a;
			return false;
		}

		};
	cout << f() << endl;
}

4.参数绑定

在我们这里lambda表达式相比较谓词具有的一个决定性优势就是它可以捕获变量，而谓词定义的时候参数列表是受限的。但如果我们希望能在能多地方使用，lambda表达式的话就需要重复的编写，这时函数就更具有优势了。那么有没有什么办法解决参数捕获的问题呢，方法是有的。

我们可以使用名为bind 的标准库函数，它定义在头文件functional中。一般形式为

auto newCallable=bind(callable,arg_list);

如一元谓词check_size

bool check_size(const string &s,string::size_type sz){
return s.size()>=sz;}
auto wc=find_if(words.begin(),words.end(),bind(check_size,_1,sz));

_n为占位符，定义在名为placeholders的命名空间中，而这个命名空间又定义在std中。可以通过声明：

using namespace std::placeholders;

来使得其中的名字可用。

练习10.22
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
#include<functional>
using namespace std;
using namespace placeholders;
void elimdups(vector<string>& vi) {
	sort(vi.begin(), vi.end());
	auto end_u = unique(vi.begin(), vi.end());
	vi.erase(end_u, vi.end());
}
bool check_size(const string& s, vector<string>::size_type sz) {
	return s.size() >= sz;
}
void biggies(vector<string>& words, vector<string>::size_type sz) {
	elimdups(words);
	auto counts = count_if(words.begin(), words.end(), bind(check_size,_1,sz));
	cout << counts << endl;
}
int main() {
	vector<string>words = { "reoreo","The world","flandre","a","b","sss","sasdf","aaa" };
	vector<string>::size_type sz = 6;
	biggies(words, sz);
}
练习10.23
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
#include<functional>
using namespace std;
using namespace placeholders;

bool check_size(const int& i, string s) {
	return i >s.size();
}
int main() {
	vector<int>vi = { 1,2,3,4,5,6,7,8,9,10 };
	string str = "asdfsadf";
	auto a = find_if(vi.begin(), vi.end(), bind(check_size, _1, str));
	cout << *a << endl;
}
练习10.24
#include<vector>
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
#include<functional>
using namespace std;
using namespace placeholders;
void elimdups(vector<string>& vi) {
	sort(vi.begin(), vi.end());
	auto end_u = unique(vi.begin(), vi.end());
	vi.erase(end_u, vi.end());
}
bool check_size(const string &s,vector<string>::size_type sz) {return s.size() < sz; }
void biggies(vector<string>& words, vector<string>::size_type sz) {
	elimdups(words);
	auto end_p = partition(words.begin(), words.end(), bind(check_size,_1,sz));
	for (auto it = end_p; it != words.end(); it++) {
		cout << *it << endl;
	}
}
int main() {
	vector<string>words = { "reoreo","The world","flandre","a","b","sss","sasdf","aaa" };
	vector<string>::size_type sz = 6;
	biggies(words, sz);
}

另外要注意的是用bind绑定参数的方式都是以拷贝的形式，相当于值传递的lambda函数，那么如果需要改变绑定的参数时，需要用到标准库函数ref或者cref。

10.4 再探迭代器

迭代器可以分为以下几类：

  • 插入迭代器
  • 流迭代器
  • 反向迭代器
  • 移动迭代器

1.插入迭代器

有三种类型的插入迭代器

  • back_inserter：创建一个使用push_back的迭代器
  • front_inserter：创建一个使用front_back的迭代器
  • inserter：创建一个使用insert的迭代器。接受两个参数
练习10.27
#include<vector>
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
#include<functional>
using namespace std;
using namespace placeholders;

int main() {
	vector<string>words = { "reoreo","The world","flandre","a","b","sss","sasdf","aaa" ,"aaa","reoreo","reoreo"};
	list<string>ls;
	
	unique_copy(words.begin(), words.end(), back_inserter(ls));
	vector<string>::size_type sz = 6;
	//biggies(words, sz);
	for (auto& c : ls)
		cout << c << endl;
}
练习10.28
#include<vector>
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
#include<deque>
#include<forward_list>
#include<functional>
#include<iterator>
using namespace std;
using namespace placeholders;

int main() {
	vector<int>vi = { 1,2,3,4,5,6,7,8,9 };
	list<int>li;
	deque<int>di;
	forward_list<int>fi;
	unique_copy(vi.begin(), vi.end(), back_inserter(li));
	unique_copy(vi.begin(), vi.end(), front_inserter(fi));//forward_list没有push_back
	unique_copy(vi.begin(), vi.end(), back_inserter(di));
	vector<string>::size_type sz = 6;
	//biggies(words, sz);
	cout << "list" << endl;
	for (auto& c : li)
		cout << c << endl;
	cout << "forward_lsit" << endl;
	for (auto& c : fi)
		cout << c << endl;
	cout << "deque" << endl;
	for (auto& c : di)
		cout << c << endl;
}

2. iostream 迭代器

istream_iterator读取输入流

  • istream_iterator<T> in(is);
  • istream_iterator<T>end;
  • in1==in2
  • in1!=in2
  • *in
  • in->men
  • ++in,in++

ostream_iterator读取输出流

  • ostream_iterator<T>out(os)
  • ostream_iterator<T>(os,d)
  • out=val
  • *out,++out,out++
练习10.29
#include<fstream>
#include<string>
#include<vector>
#include<iterator>
#include<iostream>
using namespace std;
int main() {
	ifstream is("源.cpp");
	istream_iterator<string>in(is);
	istream_iterator<string> ends;
	vector<string> file_text;
	for (auto it = in; it != ends; it++) {
		file_text.push_back(*it);
	}
	is.close();
	for (auto c : file_text)
		cout << c << endl;
}
练习10.30
#include<fstream>
#include<string>
#include<vector>
#include<iterator>
#include<iostream>
#include<algorithm>
using namespace std;
int main() {
	istream_iterator<int>in(cin);
	istream_iterator<int> ends;
	vector<int> file_text;
	for (auto it = in; it != ends; it++) {
		file_text.push_back(*it);
	}
	sort(file_text.begin(), file_text.end());
	ostream_iterator<int> out(cout, "\n");
	copy(file_text.begin(), file_text.end(), out);
	cout << endl;
}
练习10.31
#include<fstream>
#include<string>
#include<vector>
#include<iterator>
#include<iostream>
#include<algorithm>

using namespace std;
int main() {
	istream_iterator<int>in(cin);
	istream_iterator<int> ends;
	vector<int> file_text;
	vector<int>ff;

	for (auto it = in; it != ends; it++) {
		file_text.push_back(*it);
	}
	sort(file_text.begin(), file_text.end());
	auto end_u = unique_copy(file_text.begin(), file_text.end(), back_inserter(ff));
	//ff.erase(end_u, ff.end());
	ostream_iterator<int> out(cout, "\n");
	copy(ff.begin(), ff.end(), out);
	cout << endl;
}
练习10.32
#include<fstream>
#include<string>
#include<vector>
#include<iterator>
#include<iostream>
#include<algorithm>
#include<numeric>
using namespace std;
class Sales_data {//偷个懒就创建一个简单的Sales_data类
public:
	string getisbn() { return bookNo; }
	double getrevenue() { return revenue; }
	Sales_data(string s, unsigned u, double d) :bookNo(s), sold(u), revenue(d) {}
	Sales_data() :Sales_data(" ", 0, 0.0) {}
	Sales_data(string s) :Sales_data(s, 0, 0.0) {}
private:
	string bookNo;
	unsigned sold;
	double revenue;
};
bool isShorter(Sales_data& s1, Sales_data& s2) {
	return s1.getisbn() > s2.getisbn();
}
void elimdups(vector<Sales_data>& vi) {
	sort(vi.begin(), vi.end(), isShorter);
	//auto end_u = unique(vi.begin(), vi.end());
	//vi.erase(end_u, vi.end());
}
int main() {
	vector<Sales_data>vi;
	vi.emplace_back("ssss");
	vi.emplace_back("asdf", 12, 22);
	vi.emplace_back("afasd", 12, 22);
	vi.emplace_back("dsfa", 23, 223);
	elimdups(vi);
	vector<double>re;
	for (auto it = vi.begin(); it != vi.end(); it++) {
		//cout << it->getisbn() << endl;
		re.push_back(it->getrevenue());
	}
	auto sum = accumulate(re.begin(), re.end(), 0.0);
	cout << sum << endl;
}
练习10.33
#include<fstream>
#include<string>
#include<vector>
#include<iterator>
#include<iostream>
#include<algorithm>
#include<numeric>
#include<fstream>

using namespace std;
void f(string f1, string f2, string f3) {
	ifstream in(f1);
	istream_iterator<int> ins(in);
	istream_iterator<int> endi;
	ofstream o1, o2;
	o1.open(f2);
	o2.open(f3);
	ostream_iterator<int>oo1(o1, "\n "),oo2(o2," ");
	for (auto it = ins; it != endi; it++) {
		cout << *it << endl;
		if (*it % 2)
			oo2 = *it;
		else
			oo1 = *it;
	}
}

int main() {
	ofstream out;
	string ff = "num.txt";
	out.open(ff);
	int i;
	ostream_iterator<int> outs(out,"\n");
	istream_iterator<int> in(cin);
	istream_iterator<int>endi;
	while (in != endi) {
		*outs++=*in++;
	}
		
	out.close();
	f(ff, "a.txt", "b.txt");
}

3.反向迭代器

练习10.34
#include<fstream>
#include<string>
#include<vector>
#include<iterator>
#include<iostream>
#include<algorithm>

using namespace std;
int main() {
	vector<int> ff = { 1,2,3,4,5,6,7,8,9 };
	ostream_iterator<int> out(cout, "\n");
	copy(ff.rbegin(), ff.rend(), out);
	cout << endl;
}
练习10.35
#include<fstream>
#include<string>
#include<vector>
#include<iterator>
#include<iostream>
#include<algorithm>

using namespace std;
int main() {
	vector<int> ff = { 1,2,3,4,5,6,7,8,9 };
	vector<int>f;
	ostream_iterator<int> out(cout, "\n");
	for (auto it : ff)
		f.insert(f.begin(), it);
	copy(f.begin(), f.end(), out);
	cout << endl;
}
练习10.36
#include<fstream>
#include<string>
#include<vector>
#include<iterator>
#include<iostream>
#include<algorithm>
#include <list>
using namespace std;
int main() {
	list<int> ff = { 1,2,3,4,5,6,7,8,9,1,2,3 };
	auto lasts = find(ff.rbegin(), ff.rend(),0);
	if (lasts == ff.rend())
		cout << "no value is equal 0";
	else
		cout << "have" << endl;
}
练习10.37
#include<fstream>
#include<string>
#include<vector>
#include<iterator>
#include<iostream>
#include<algorithm>
#include <list>
using namespace std;
int main() {
	vector<int> ff = { 0,1,2,3,4,5,6,7,8,9 };
	list<int>f; int i = 0;
	for(auto it=ff.cbegin();it!=ff.cend() ;++it,++i)
	{
		if(i >= 3 && i < 7)
			f.push_back(*it);
	}
	ostream_iterator<int> out(cout, "\n");
	copy(f.begin(), f.end(), out);
	cout << endl;
}

10.5泛型算法结构

泛型算法所要求的迭代器一共5类

  • 输入迭代器：只读，不写，单遍扫描，只能递增
  • 输出迭代器：只写，不读，单遍扫描，只能递增
  • 前向迭代器：可读写，多遍扫描，只能递增
  • 双向迭代器：可读写，多遍扫描，可递增递减
  • 随机访问迭代器：可读写，多遍扫描，指出全部迭代器操作

10.6 特定容器算法

list和forward_list成员函数版本的算法

  • lst.merge(list2)
  • lst.merge(list2,comp)
  • lst.remove(val)
  • lst.remove_if(pred)
  • lst.reverse()
  • lst.sort()
  • lst.sort(comp)
  • lst.unique()
  • lst.unique(pred)
练习10.40
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<numeric>
using namespace std;
void elimdups(list<int>& vi) {
	vi.sort();
	vi.unique();
}
int main() {
	list<int>vi = { 1,2,3,23,23,12,12,23,32,3,423,3,2,21,2,3,4,67,8,9,6 };
	elimdups(vi);
	for (auto c : vi) {
		cout << c << endl;
	}
}
xhh22900
关注
专栏目录
C++ primer笔记----泛型算法
六道的博客
08-30 211
1、泛型算法：算法是因为其实现了一些经典算法的公共接口，如排序和搜索。泛型是因为他们可以作用于不同类型的元素和多种容器类型甚至是内置数组。故称泛型算法 2、基本上都定义在algorithm和numeric两个头文件中，这些算法遍历由两个迭代器指定的一个元素范围来进行操作，不对容器进行直接操作 3、所谓泛型算法就是作用于容器和元素上面的一些操作的合集，在实际情况中要善于使用 4、标准库基本上都...
c++primer学习心得
08-28
c++primer学习心得 c++primer学习心得
C++ Primer学习心得和遇到的问题
Jack Zhou的专栏
06-30 1689
  学习心得：  我学习C++ Primer是在Ubuntu8.04下进行的。经过一个多月的学习，我硬是把vi给用熟了，包括选项设置、文本编辑、多窗口编辑等，对gcc的选项和使用也有了全面的了解。其实vi的功能非常强大，可以设置C/C++代码的缩进格式，也可以用ctag进行代码的导航，而gcc就更不用说了，不仅可以编译多种语言的程序，而且还支持交叉编译。我建议大家在学习标准C++时，最好用原始
C++primer学习心得（一）
u012088066的专栏
11-07 428
指针和const限定符 #include using namespace std; int main() {  int num =3; int e = 9;   //定义了一个整型变量，并且赋初值 int *const p =&e;   //p是只指向int类型的const指针 ,所以p不能指向其他的对象,任何视图给p赋值的操作都是非法的   *p=6;   //通过指针变量改变指
C++ Primer 学习心得
Chris_Home
11-19 505
C++提供了函数参数缺省时的定义： 例如： #include using namespace std; extern int min(int ,int ) ; int min(int a,int b=0){ return a<b?a:b ; } int main(){ int a=min(4); cout<<a<<endl; return 0 ; } 在类中的使用如下： cla
学习C++primer心得08.5.27
yyouyou的专栏
05-27 462
  typedef 可以用来定义类型的同义词枚举的定义包括关键字 enum，其后是一个可选的枚举类型名，和一个用花括号括起来、用逗号分开的枚举成员列表。     // input is 0, output is 1, and append is 2     enum open_modes {input, output, append};     // shape is 1, s
C++Primer第11章-泛型算法-课后习题答案[收集].pdf
10-11
在C++编程中，泛型算法是用于处理各种不同数据结构（如数组、向量、列表等）的一组通用函数，这些函数不依赖于特定的数据类型。本篇内容主要涉及了两个重要的泛型算法——`count`和`accumulate`，以及如何在实际编程...
C++-Primer-Plus(第6版源码)
最新发布
06-02
《C++ Primer Plus（第6版）》是学习C++编程语言的一本经典教材，它为初学者提供了全面且深入的指导。这本书的源码包含了书中各个章节的示例程序，帮助读者更好地理解和实践C++编程概念。在这个压缩包中，你将找到一...
java坑爹的笔试题-cpp-primer-5th:C++Primer第五版学习资料
06-13
第10、11章有点基础的看起来不是很难，第十章的泛型算法，如果能用起来会让你的程序更上一层楼。第12章动态内存个人觉得对于一个想要深入学习C++的人来说非常重要，对于内存的理解、动态数组、new和delete运算符，...
学习c++ primer plus心得
weixin_30587025的博客
11-21 125
导读部分 1、RTTI RTTI（Run-Time Type Information)，通过运行时类型信息程序能够使用基类的指针或引用来检查这些指针或引用所指的对象的实际派生类型 2、内联函数优缺点：提高程序的执行速度，但会增加程序的长度。 转载于:https://www.cnblogs.com/yun123456/p/9994562.html...
C++primer学习心得-第七章-类
xhh22900的博客
02-21 237
文章目录C++primer学习心得-第七章-类7.1 定义抽象数据类型1.设计Sales_data类2.定义Sales_data类3. 定义类相关的非成员函数4. 构造函数5. 拷贝、赋值、析构7.2 访问控制与封装1. 友元7.3 类的其他特性1.类成员再探2.返回*this的成员函数3. 类类型4. 友元再探7.4 类的作用域1.名字查找与类的作用域7.5 构造函数再探1.构造函数初始值列表2...
C++primer 学习心得-第一章-开始
xhh22900的博客
02-17 222
文章目录第一章 开始1. 书店问题2. 编写一个简单的c++程序1. 编译运行2. 输入输出3. 注释简介4. 控制流3. 读取不确定数量的输出语句4. if语句5. 类简介 第一章 开始 1. 书店问题 首先注意这个问题（书中好几章都会涉及），书店保存销售记录，每条销售记录包含三个数据项：书的ISBN号，销售的册数，书的单价。有时书店老板需要查询档案获取一些信息：每本书的销售量、销售额、平均...
C++ Primer学习心得第四章
miaobeihai的博客
11-21 236
4.1 基础 4.2 算术运算符 4.3 逻辑与关系运算符 4.4 赋值运算符 4.5 递增和递减运算符 4.6 成员访问运算符 4.7 条件运算符 4.8 位运算符 4.9 sizeof运算符 4.10 逗号运算符 4.11 类型转换 4.12 运算符优先级表 4.1基础 左值和右值： 书中简单做了个归纳： 当一个对象被用作为右值
C++Primer的练习和心得
nuc_Sheryl的博客
03-11 336
未完…… #include #include #include #include using namespace std; int main() {     //string     string s1;     string s2(s1);     string s3("value");     string s4(10, 'c');     cin
《C++ Primer》心得（一）
wangnanuestc的专栏
10-17 291
学习型博客与其说是给别人看，不如说是给自己一个机会把知识梳理清楚----  CSDN C++博客  刘未鹏       以前听人说：C++只是C语言加上类而已。深入学习后才发现其实不然，对于现代C++而言，已经不能这么描述了，也逐渐明白了为什么C++之父一直在呼吁 要把C++当做一种全新的语言来学习。从上个学期末开始看《C++ Primer》到现在已经近一百天了，书也看了超过400页，现在正在进行第十三章《复制控制》，趁机把一些心得记录一下。    1  面向对象思想：毫无疑问这个是C++的精
C++ primer 个人学习总结
小二笙的博客
11-08 2279
欢迎大家来访二笙的小房子，一同学习分享生活！ 文章目录1. 个人见解：C++2. primer学习总结2.1 第一章：开始2.2 Part1：C++基础2.3 Part2：C++标准库2.4 Part3：类设计者的工具2.5 高级主题3. future 1. 个人见解：C++ 先来说说对C++的感觉吧，由于个人不是特别热爱学习的那种，自律性也比较差，加之上学期才刚接触C++，于是在经过一个学期的c...
C++ Primer 学习心得第八章
miaobeihai的博客
12-06 265
8.1 IO类 8.2 文件输入输出 8.3 string流 •1. 输入输出机制 •2. 流类库 •3. 标准输入输出流 •4. 文件输入输出流 •5. 字符串输入输出流 •C++语言的输入输出机制包含3层，前两层是从传统的C语言继承而来，分别是底层I/O和高层I/O，第3层是C++中增添的流类库。 •（1）底层I/O:底层I/O依赖
C++ primer 5th 读完的一点心得体会
King_DJF的博客
12-18 2645
作为一个通信的研究生，其实我对自己所从事的方向还是有很多迷茫的。本科的时候参加过很多比赛，搞过单片机、ARM嵌入式，做过信号处理，学过matlab，学过C、C++,但是始终觉得自己浮于表面，并没有一种深入的感觉。好比我做了一个四旋翼飞行器，我知道它的控制原理，我花足够多的时间也能看明白它里面的每一个函数，我也可以对这个开源的飞控做适当的修改，但是也就仅此而已了，如果让我自己从无到有的搭建这样一个庞
C++ Primer(第五版)第十章练习：泛型算法解答
"C++ Primer(第五版)的泛型算法练习题答案与解析，包括了使用count函数统计序列中特定值出现次数、使用accumulate计算序列元素之和以及关于equal函数和迭代器的问题讨论。" 在C++编程中，泛型算法是能够处理不同...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值