＜学习笔记＞STL标准模板库

1.输入流迭代器 istream_iterator<T>

以输入流（如cin）为参数构造

可用*(p++)获得下一个输入的元素

2.输出流迭代器 ostream_iterator<T>

构造时需要提供输出流（如cout）

可用(*p++) = x将x输出到输出流

transform算法的一种实现：

template <class InputIterator, class OutputIterator, class UnaryFunction>

OutputIterator transform(InputIterator first, InputIterator last, OutputIterator result, UnaryFunction op) {     

for (;first != last; ++first, ++result)         

*result = op(*first);     return result; }

例1从标准输入读入几个实数，分别将它们的平方输出 

#include <iterator>
#include <iostream>
#include <algorithm>
using namespace std;

//求平方的函数
double square(double x) {
	return x * x;
}

int main() {
	//从标准输入读入若干个实数，分别将它们的平方输出
    transform(istream_iterator<double>(cin), istream_iterator<double>(),
		ostream_iterator<double>(cout, "\t"), square);
    cout << endl;
    return 0;
}

两个迭代器表示一个区间：[p1, p2)区间包含p1，但不包含p2 

例2综合运用几种迭代器的示例 

//10_3.cpp
#include <algorithm>
#include <iterator>
#include <vector>
#include <iostream>
using namespace std;

//将来自输入迭代器p的n个T类型的数值排序，将结果通过输出迭代器result输出
template <class T, class InputIterator, class OutputIterator>
void mySort(InputIterator first, InputIterator last, OutputIterator result) {
	//通过输入迭代器p将输入数据存入向量容器s中
	vector<T> s;
	for (;first != last; ++first)
		s.push_back(*first);
	//对s进行排序，sort函数的参数必须是随机访问迭代器
	sort(s.begin(), s.end());
	//将s序列通过输出迭代器输出
	copy(s.begin(), s.end(), result);
}

int main() {
	//将s数组的内容排序后输出
	double a[5] = { 1.2, 2.4, 0.8, 3.3, 3.2 };
	mySort<double>(a, a + 5, ostream_iterator<double>(cout, " "));
	cout << endl;
	//从标准输入读入若干个整数，将排序后的结果输出
	mySort<int>(istream_iterator<int>(cin), istream_iterator<int>(), ostream_iterator<int>(cout, " "));
	cout << endl;
	return 0;
}

 顺序容器的接口

赋值 assign

插入函数 insert， push_front（只对list和deque）， push_back

删除函数 erase，clear，pop_front（只对list和deque） ，pop_back

其他顺序容器访问函数 front，back 改变大小 resize

 3.输出指定的整型顺序容器的元素

//10_4.cpp
#include <iostream>
#include <list>
#include <deque>
#include <iterator>
#include <algorithm>
using namespace std;

//输出指定的整型顺序容器的元素
template <class T>
void printContainer(const char* msg, const T& s) {
	cout << msg << ": ";
	copy(s.begin(), s.end(), ostream_iterator<int>(cout, " "));
	cout << endl;
}

int main() {
	//从标准输入读入10个整数，将它们分别从s的头部加入
	deque<int> s;
	for (int i = 0; i < 10; i++) {
		int x;
		cin >> x;
		s.push_front(x);
	}
	printContainer("deque at first", s);

	//用s容器的内容的逆序构造列表容器l
	list<int> l(s.rbegin(), s.rend());
	printContainer("list at first", l);

	//将列表容器l的每相邻两个容器顺序颠倒
	list<int>::iterator iter = l.begin();
	while (iter != l.end()) {
		int v = *iter;			//得到一个元素
		iter = l.erase(iter);	//将该元素删除，得到指向下一个元素的迭代器
		l.insert(++iter, v);	//将刚刚删除的元素插入下一个位置
	}
	printContainer("list at last", l);

	//用列表容器l的内容给s赋值，将s输出
	s.assign(l.begin(), l.end());
	printContainer("deque at last", s);

	return 0;
}

运行结果如下：  

0 9 8 6 4 3 2 1 5 4    

deque at first: 4 5 1 2 3 4 6 8 9 0    

list at first: 0 9 8 6 4 3 2 1 5 4    

list at last: 9 0 6 8 3 4 1 2 4 5    

deque at last: 9 0 6 8 3 4 1 2 4 5

vector

容量(capacity)：实际分配空间的大小 s.capacity() ：返回当前容量 s.reserve(n)：若容量小于n，则对s进行扩展，使其容量至少为n 

例奇偶排序 

sort(iterator first, iterator last);[first,last)

排序

copy(iterator first, iterator last,outputiterator result)

输出

//10_5.cpp
#include <vector>
#include <deque>
#include <algorithm>
#include <iterator>
#include <iostream>
using namespace std;

int main() {
	istream_iterator<int> i1(cin), i2;	//建立一对儿输入流迭代器
	vector<int> s1(i1, i2);	//通过输入流迭代器从标准输入流中输入数据
	sort(s1.begin(), s1.end());			//将输入的整数排序
	deque<int> s2;
	//以下循环遍历s1
	for (vector<int>::iterator iter = s1.begin(); iter != s1.end(); ++iter) {
		if (*iter % 2 == 0)	//偶数放到s2尾部
			s2.push_back(*iter);
		else				//奇数放到s2首部
			s2.push_front(*iter);
	}
	//将s2的结果输出
	copy(s2.begin(), s2.end(), ostream_iterator<int>(cout, " "));
	cout << endl;
	return 0;
}

 容器set

 set 元素升序排列 s.begin就是最小值 存储一组无重复的元素

例10-9  输入一串实数，将重复的去掉，取最大和最小者的中值，分别输出小于等于此中值和大于等于此中值的实数

//10_9.cpp
#include <set>
#include <iterator>
#include <utility>
#include <iostream>
using namespace std;

int main() {
	set<double> s;
	while (true) {
		double v;
		cin >> v;
		if (v == 0) break;	//输入0表示结束
		pair<set<double>::iterator, bool> r = s.insert(v);	//尝试将v插入
		if (!r.second)		//如果v已存在，输出提示信息
			cout << v << " is duplicated" << endl;
	}
	set<double>::iterator iter1 = s.begin();	//得到第一个元素的迭代器
	set<double>::iterator iter2 = s.end();		//得到末尾的迭代器
	double medium = (*iter1 + *(--iter2)) / 2;	//得到最小和最大元素的中值
	//输出小于或等于中值的元素
	cout << "<= medium: ";
	copy(s.begin(), s.upper_bound(medium), ostream_iterator<double>(cout, " "));
	cout << endl;
	//输出大于或等于中值的元素
	cout << ">= medium: ";
	copy(s.lower_bound(medium), s.end(), ostream_iterator<double>(cout, " "));
	cout << endl;
	return 0;
}

 map

映射与集合同属于单重关联容器，它们的主要区别在于，集合的元素类型是键本身，而映射的元素类型是由键和附加数据所构成的二元组。 在集合中按照键查找一个元素时，一般只是用来确定这个元素是否存在，而在映射中按照键查找一个元素时，除了能确定它的存在性外，还可以得到相应的附加数据。

例10-10 有五门课程，每门都有相应学分，从中选择三门，输出学分总和

//10_10.cpp
#include <iostream>
#include <map>
#include <string>
#include <utility>
using namespace std;

int main() {
	map<string, int> courses;
	//将课程信息插入courses映射中
	courses.insert(make_pair("CSAPP", 3));
	courses.insert(make_pair("C++", 2));
	courses.insert(make_pair("CSARCH", 4));
	courses.insert(make_pair("COMPILER", 4));
	courses.insert(make_pair("OS", 5));

	int n = 3;		//剩下的可选次数
	int sum = 0;	//学分总和
	while (n > 0) {
		string name;
		cin >> name;	//输入课程名称
		map<string, int>::iterator iter = courses.find(name);//查找课程
		if (iter == courses.end()) {	//判断是否找到
			cout << name << " is not available" << endl;
		} else {
			sum += iter->second;	//累加学分
			courses.erase(iter);	//将刚选过的课程从映射中删除
			n--;
		}
	}

	cout << "Total credit: " << sum << endl;	//输出总学分
	return 0;
}

10-11统计一句话中每个字母出现的次数

//10_11.cpp
#include <iostream>
#include <map>
#include <cctype>
using namespace std;

int main() {
	map<char, int> s;	//用来存储字母出现次数的映射
	char c;		//存储输入字符

	do {
		cin >> c;			//输入下一个字符
		if (isalpha(c)) {	//判断是否是字母
			c = tolower(c);	//将字母转换为小写
			s[c]++;			//将该字母的出现频率加1
		}
	} while (c != '.');		//碰到“.”则结束输入

	//输出每个字母出现次数
	for (map<char, int>::iterator iter = s.begin(); iter != s.end(); ++iter)
		cout << iter->first << " " << iter->second << "  ";
	cout << endl;

	return 0;
}

多重集合（multiset）与多重映射（multimap） 

 多重集合是允许有重复元素的集合，多重映射是允许一个键对应多个附加数据的映射。 多重集合与集合、多重映射与映射的用法差不多，只在几个成员函数上有细微差异，其差异主要表现在去除了键必须唯一的限制。

例10-12 上课时间查询

#include <iostream>
#include <map>
#include <utility>
#include <string>
using namespace std;

int main() {
	multimap<string, string> courses;
	typedef multimap<string, string>::iterator CourseIter;

	//将课程上课时间插入courses映射中
	courses.insert(make_pair("C++", "2-6"));
	courses.insert(make_pair("COMPILER", "3-1"));
	courses.insert(make_pair("COMPILER", "5-2"));
	courses.insert(make_pair("OS", "1-2"));
	courses.insert(make_pair("OS", "4-1"));
	courses.insert(make_pair("OS", "5-5"));
	//输入一个课程名，直到找到该课程为止，记下每周上课次数
	string name;
	int count;
	do {
		cin >> name;
		count = courses.count(name);
		if (count == 0)
			cout << "Cannot find this course!" << endl;
	} while (count == 0);
	//输出每周上课次数和上课时间
	cout << count << " lesson(s) per week: ";
	pair<CourseIter, CourseIter> range = courses.equal_range(name);
	for (CourseIter iter = range.first; iter != range.second; ++iter)
		cout << iter->second << " ";
	cout << endl;
	
	return 0;
}