c++ primer（第五版）笔记 第十章 泛型算法（2）

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
using std::cout;
using std::cin;
using std::endl;
using std::vector;
using std::string;
//_1 占位符的空间
using namespace std::placeholders;

inline string make_plural( string::size_type count, const string &, const string &);
void practice_10_13( vector<string> &, vector<string>::size_type);
void practice_10_24( vector<string> &);
int main()
{
	vector<string> vs{ "world", "hahahahahahah", "hhhhh", "hello", "lesson10", "c++", "vector"};
	practice_10_24( vs);
	
	practice_10_13( vs, 5);
	//创建 lambda 表达式时，编译器生成一个 lambda 类类型，该对象中包含与 capture list 一致的数据成员，可以通过值或引用初始化这些成员
	// 向一个函数传递 lambda 时，创建了类类型和其对象
	
	// capture list 值传递
	int val = 57;
	//创建时，拷贝 capture list 的值，后续的改变不影响 lambda
	auto f = [ val] { return val;};
	val = 0;
	cout << "f() :" << f() << endl;
	cout << "val :" << val << endl;
	
	// capture list 引用传递, 使用时要保证所引用的对象有效
	auto f2 = [ &val] { return val;};
	val = 32;
	cout << "f2() :" << f2() << endl;
	cout << "val :" << val << endl;
	
	//捕获列表中的变量是只读的，将捕获列表声明为 mutable，可在 lambda 中改变该值 
	auto f3 = [ val] () mutable { return ++val;};
	cout << "f3() :" << f3() << endl;
	cout << "val :" << val << endl;
	

}

void practice_10_13( vector<string> &vs, vector<string>::size_type sz)
{
	// 谓词是一个可调用的表达式，返回结果可用于条件，接受谓词参数的算法对输入的序列中元素调用谓词
	// 一元谓词（unary predicate），接受以一个参数
	// 二元谓词（binary predicate），接受以两个参数

	// 可调用对象（callable object）:函数，函数指针，重载了函数运算符的类，lambda 表达式
	// lambda 表达式可以理解为未命名的内联函数
	// 形式：[capture list] (parameter list) -> return type {function body}
	// capture list 是 lambda 表达式所在函数中定义的局部变量
	// 必须使用尾置返回，可以省略参数列表和返回类型
	// auto f = []{ return 42;}
	// cout << f() << endl;
	//实参数量必须与形参一致，不允许默认参数

	// auto vsi = partition(vs.begin(), vs.end(), is_shorter);
	// 使用 lambda 表达式替换函数
	// 空的 capture list 表示不能使用任何其所在函数内的局部变量
	
	//字典排序
	sort( vs.begin(), vs.end());
	//去重
	auto vsi = unique( vs.begin(), vs.end());
	//删除重复
	vs.erase( vsi, vs.end());
	//长度排序，稳定排序
	stable_sort(
					vs.begin(),
					vs.end(),
					[] ( const string &s1,  const string &s2) -> bool { return s1.size() < s2.size();}
					);
	//筛选长度，返回指针
	auto wc = find_if(
								vs.begin(),
								vs.end(),
								// []									空捕获列表，不能使用所在函数的变量
								// [ =]								隐式捕获列表，lambda 拷贝所有来自所在函数的实体的值		
								// [ &]								隐式捕获列表，lambda 采用引用方式使用所有来自所在函数的实体		
								// [ &, identifier_list]		采用拷贝方式使用 identifier_list 来自所在函数的实体的值，其他实体采用引用方式
								// [ =, identifier_list]		和上一条相反
								// [identifier_list]			显式捕获列表
								// [ sz] ( const string &s) -> bool { return s.size() >= sz;}
								[ =] ( const string &s) -> bool { return s.size() >= sz;}
					);
	auto count = vs.end() - wc;
	cout << count << " " << make_plural( count, "word", "s") << " of length " << sz << " or longer" << endl;
	// 打印
	for_each(
				wc,
				vs.end(),
				[] ( const string &s) -> void { cout << s << " ";}
				);
	cout << endl;
}

string make_plural( string::size_type count, const string &s1, const string &s2)
{
	return ( count > 1) ? s1 + s2 : s1;
}

//课后练习
bool check_size( const string &s, string::size_type sz)
{
	return s.size() >= sz;
}

void practice_10_24( vector<string> &vs)
{
	string str;
	
	cin  >> str;
	auto wc = find_if( vs.begin(),
					vs.end(),
					bind( check_size, _1, str.size()));
	cout << *wc << endl;
}