-
STL
STL是Standard Template Library的简称，中文名标准模板库，惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。从根本上说，STL是一些“容器”的集合，这些“容器”有list,vector,set,map等，STL也是算法和其他一些组件的集合。这里的“容器”和算法的集合指的是世界上很多聪明人很多年的杰作。STL的目的是标准化组件，这样就不用重新开发，可以使用现成的组件。STL现在是C++的一部分，因此不用安装额外的库文件。STL的版本很多，常见的有HP STL、PJ STL、 SGI STL等。在C++标准中，STL被组织为下面的17个头文件：<algorithm>、<deque>、<functional>、<iterator>、<array>、<vector>、<list>、<forward_list>、<map>、<unordered_map>、<memory>、<numeric>、<queue>、<set>、<unordered_set>、<stack>和<utility>。
泛型程序设计
C++ 语言的核心优势之一就是便于软件的重用
C++中有两个方面体现重用：
1. 面向对象的思想：继承和多态，标准类库
2. 泛型程序设计(generic programming) 的思想： 模板机制，以及标准模板库 STL
泛型程序设计简单地说就是使用模板的程序设计法。
将一些常用的数据结构（比如链表，数组，二叉树）
和算法（比如排序，查找）写成模板，以后则不论数据
结构里放的是什么对象，算法针对什么样的对象，则都
不必重新实现数据结构，重新编写算法。
标准模板库 (Standard Template Library) 就是一些
常用数据结构和算法的模板的集合。
有了STL，不必再写大多的标准数据结构和算法，并
且可获得非常高的性能。
string类
• string 类是模板类：
typedef basic_string <char> string;
• 使用string类要包含头文件 <string>
• string 对象的初始化:
· string s("Hello");
· string month = "March";
· string s1(8, 'x');
· string error1 = 'c';
· string error2('u');
· string error3 = 22;
· string error4(8);
string s("hello");
for (int i=0; i < s.length(); ++i) {
cout << s.at(i) << endl;
}
//成员函数at会做范围检查，如果超出范围，会抛出out_of_range异常，而下标运算符[]不做范围检查。
string s1("good"), s2("morning");
s1.append(s2);
s2.append(s1,3,s1.size()); //s1.size() s1字符数
//下标为3开始，s1.size()个字符，如果字符串内没有足够字符，则复制到字符串最后一个字符
| 输出 | |
| 0 | // hello == hello |
| 1 | // hello > hell |
| -1 | // hell < hello |
string s1("hello"), s2("hello"), s3("hell");
int f1 = s1.compare(s2);
int f2 = s1.compare(1,2,s3,0,3); //s1 1-2;s3 0-3
int f3 = s1.compare(0,s1.size(),s2); //s1 0-end
删除 string 中的字符
成员函数 erase()
string s("hello world");
cout << s1.erase(5);
//output:world 去掉下标5及之后的字符
替换 string 中的字符
成员函数 replace()
s1.replace(2,3,"abcd");
//将s1中下标为2开始的3个字符换成"abcd"
s1.replace(2,3,"haha",1,2);
//s1中s1[2]-s1[4]换成"ah"
在 string 中插入字符
成员函数 insert()
s1.insert(5,s2);
//将s2插入s1下标5的位置(s1[4]与s1[5]之间)
s1.insert(2,s2,5,3);
//将s2[5]-s2[7]插入到s1下标为2的位置
转换成C语言式char *字符串
成员函数 c_str()
printf("%s\n",s1.c_str());
//s1.str()返回传统的 const char * 类型字符串，且该字符串以 '\0' 结尾
成员函数 data()
const char * p = s.data();
//s.data() 返回一个char * 类型的字符串，对s的修改可能会使p出错
字符串流处理
除了标准流和文件流输入输出外，还可以从string进行输入输出；
类似 istream和osteram进行标准流输入输出，我们用istringstream 和 ostringstream进行字符串上的输入输出，也称为内存输入输出。
#include <string>
#include <iostream>
#include <sstream>
字符串流处理 - 字符串输入流 istringstream
string input("Input test 123 4.7 A");
istringstream inputString(input);
string string1, string2;
int i;
double d;
char c;
inputString >> string1 >> string2 >> i >> d >> c;
cout << string1 << endl << string2 << endl;
cout << i << endl << d << endl << c <<endl;
long L;
if(inputString >> L) cout << "long\n"; //流里数据是否读完
else cout << "empty\n";
/*
输出：
Input
test
123
4.7
A
empty
*/
ostringstream outputString;
int a = 10;
outputString << "This " << a << "ok" << endl;
cout << outputString.str(); // outputString.str()的返回值是string对象
输出：
This 10ok
STL中的基本的概念
容器：可容纳各种数据类型的通用数据结构,是类模板
迭代器：可用于依次存取容器中元素，类似于指针
算法：用来操作容器中的元素的函数模板
sort()来对一个vector中的数据进行排序
find()来搜索一个list中的对象
算法本身与他们操作的数据的类型无关，因此他们可以在从简单数组到高
度复杂容器的任何数据结构上使用。
容器概述
可以用于存放各种类型的数据（基本类型的变量，对象等）的数据结构，都是类模版,分为三种：
1)顺序容器
vector, deque,list
2)关联容器
set, multiset, map, multimap
3)容器适配器
stack, queue, priority_queue
对象被插入容器中时，被插入的是对象的一个复制品。许多算法，比如排序，查找，要求对容器中的元
素进行比较，有的容器本身就是排序的，所以，放入容器的对象所属的类，往往还应该重载 == 和 < 运算符。
顺序容器简介
容器并非排序的，元素的插入位置同元素的值无关。
有vector,deque,list 三种
vector 头文件 <vector>
动态数组。元素在内存连续存放。随机存取任何元素都能在常数时间
完成。在尾端增删元素具有较佳的性能(大部分情况下是常数时间）。
deque 头文件 <deque>
双向队列。元素在内存连续存放。随机存取任何元素都能在常数时间
完成(但次于vector，因为会做一个是否超出储存长度，储存到队头的判定，如下图的a7)。在两端增删元素具有较佳的性能(大部分情况下是常
数时间）。
list 头文件 <list>
双向链表。元素在内存不连续存放。在任何位置增删元素都能在常数
时间完成。不支持随机存取。
关联容器简介
元素是排序的
插入任何元素，都按相应的排序规则来确定其位置
在查找时具有非常好的性能
通常以平衡二叉树方式实现，插入和检索的时间都是 O(log(N))
set/multiset 头文件 <set>
set 即集合。set中不允许相同元素，multiset中允许存在相同的元素。
map/multimap 头文件 <map>
map与set的不同在于map中存放的元素有且仅有两个成员变量，一个
名为first,另一个名为second, map根据first值对元素进行从小到大排序，
并可快速地根据first来检索元素。
map同multimap的不同在于是否允许相同first值的元素。
容器适配器简介
stack :头文件 <stack>
栈。是项的有限序列，并满足序列中被删除、检索和修改的项只能是最近插入
序列的项（栈顶的项）。后进先出。
queue 头文件 <queue>
队列。插入只可以在尾部进行，删除、检索和修改只允许从头
部进行。先进先出。
priority_queue 头文件 <queue>
优先级队列。最高优先级元素总是第一个出列
顺序容器和关联容器中都有的成员函数
begin 返回指向容器中第一个元素的迭代器
end 返回指向容器中最后一个元素后面的位置的迭代器
rbegin 返回指向容器中最后一个元素的迭代器
rend 返回指向容器中第一个元素前面的位置的迭代器
erase 从容器中删除一个或几个元素
clear 从容器中删除所有元素
顺序容器的常用成员函数
front : 返回容器中第一个元素的引用
back : 返回容器中最后一个元素的引用
push_back : 在容器末尾增加新元素
pop_back : 删除容器末尾的元素
erase : 删除迭代器指向的元素(可能会使该迭代器失效），或删除一个区间，返回被删除元素后面的那个元素的迭代器
迭代器
用于指向顺序容器和关联容器中的元素
迭代器用法和指针类似
有const 和非 const两种
通过迭代器可以读取它指向的元素
通过非const迭代器还能修改其指向的元素
定义一个容器类的迭代器的方法可以是：
容器类名::iterator 变量名;
或：
容器类名::const_iterator 变量名;
访问一个迭代器指向的元素：
* 迭代器变量名
迭代器上可以执行 ++ 操作, 以使其指向容器中的下一个元素。
如果迭代器到达了容器中的最后一个元素的后面，此时再使用
它，就会出错，类似于使用NULL或未初始化的指针一样。
#include <vector>
#include <iostream>
using namespace std;
int main() {
vector<int> v; //一个存放int元素的数组，一开始里面没有元素
v.push_back(1); v.push_back(2);
v.push_back(3);v.push_back(4);
vector<int>::const_iterator i; //常量迭代器
for( i = v.begin();i != v.end();++i )
cout << * i << ",";
cout << endl;
vector<int>::reverse_iterator r; //反向迭代器
for( r = v.rbegin();r != v.rend();r++ )
cout << * r << ",";
cout << endl;
vector<int>::iterator j; //非常量迭代器
for( j = v.begin();j != v.end();j ++ )
* j = 100;
for( i = v.begin();i != v.end();i++ )
cout << * i << ",";
return 0;
}
双向迭代器
若p和p1都是双向迭代器，则可对p、p1可进行以下操作：
++p, p++ 使p指向容器中下一个元素
--p, p-- 使p指向容器中上一个元素
* p 取p指向的元素
p = p1 赋值
p == p1 , p!= p1 判断是否相等、不等
随机访问迭代器
若p和p1都是随机访问迭代器，则可对p、p1可进行以下操作：
双向迭代器的所有操作
p += i 将p向后移动i个元素
p -= i 将p向向前移动i个元素
p + i 值为: 指向 p 后面的第i个元素的迭代器
p - i 值为: 指向 p 前面的第i个元素的迭代器
p[i] 值为: p后面的第i个元素的引用
p < p1, p <= p1, p > p1, p>= p1
p – p1 : p1和p之间的元素个数
vector的迭代器是随机迭代器，
遍历 vector 可以有以下几种做法(deque亦然)：
vector<int> v(100);
int i;
for(i = 0;i < v.size() ; i ++)
cout << v[i]; //根据下标随机访问
vector<int>::const_iterator ii;
for( ii = v.begin(); ii != v.end ();++ii)
cout << * ii;
for( ii = v.begin(); ii < v.end ();++ii )
cout << * ii;
list 的迭代器是双向迭代器，
正确的遍历list的方法：
list<int> v;
list<int>::const_iterator ii;
for( ii = v.begin(); ii != v.end ();++ii )
cout << * ii;
错误的做法：
for( ii = v.begin(); ii < v.end ();++ii )
cout << * ii;
//双向迭代器不支持 <,list没有 [] 成员函数
for(int i = 0;i < v.size() ; i ++)
cout << v[i];
算法简介
算法就是一个个函数模板, 大多数在<algorithm> 中定义
STL中提供能在各种容器中通用的算法，比如查找，排序等
算法通过迭代器来操纵容器中的元素。许多算法可以对容器中的一个
局部区间进行操作，因此需要两个参数，一个是起始元素的迭代器，
一个是终止元素的后面一个元素的迭代器。比如，排序和查找
有的算法返回一个迭代器。比如 find() 算法，在容器中查找一个元素，
并返回一个指向该元素的迭代器
算法可以处理容器，也可以处理普通数组
算法示例：find()
template<class InIt, class T>
InIt find(t InIt first, t InIt last, t const T& val; );
first 和 last 这两个参数都是容器的迭代器，它们给出了容器中的查找
区间起点和终点[first,last)。区间的起点是位于查找范围之中的，而终
点不是。find在[first,last)查找等于val的元素
用 == 运算符判断相等
函数返回值是一个迭代器。如果找到，则该迭代器指向被找到的元素。
如果找不到，则该迭代器等于last
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() { //find算法示例
int array[10] = {10,20,30,40};
vector<int> v;
v.push_back(1); v.push_back(2);
v.push_back(3); v.push_back(4);
vector<int>::iterator p;
p = find(v.begin(),v.end(),3);
if( p != v.end())
cout << * p << endl; //输出3
p = find(v.begin(),v.end(),9);
if( p == v.end())
cout << "not found " << endl;
p = find(v.begin()+1,v.end()-2,1);
//整个容器：[1,2,3,4]， 查找区间：[2,3)
if( p != v.end())
cout << * p << endl;
int * pp = find( array,array+4,20);//数组名是迭代器
cout << * pp << endl;
}
vector算法示例：
#include <iostream>
#include <vector>
using namespace std;
template<class T>
void PrintVector( T s, T e)
{
for(; s != e; ++s)
cout << * s << " ";
cout << endl;
}
int main() {
int a[5] = { 1,2,3,4,5 };
vector<int> v(a,a+5); //将数组a的内容放入v
cout << "1) " << v.end() - v.begin() << endl;
//两个随机迭代器可以相减，输出 1) 5
cout << "2) "; PrintVector(v.begin(),v.end());
//2) 1 2 3 4 5
v.insert(v.begin() + 2, 13); //在begin()+2位置插入 13
cout << "3) "; PrintVector(v.begin(),v.end());
//3) 1 2 13 3 4 5
v.erase(v.begin() + 2); //删除位于 begin() + 2的元素
cout << "4) "; PrintVector(v.begin(),v.end());
//4) 1 2 3 4 5
vector<int> v2(4,100); //v2 有4个元素，都是100
v2.insert(v2.begin(),v.begin()+ 1,v.begin()+3);
//将v的一段插入v2开头
cout << "5) v2: "; PrintVector(v2.begin(),v2.end());
//5) v2: 2 3 100 100 100 100
v.erase(v.begin() + 1, v.begin() + 3);
//删除 v 上的一个区间,即 2,3
cout << "6) "; PrintVector(v.begin(),v.end());
//6) 1 4 5
return 0;
}
用vector实现二维数组：
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<vector<int> > v(3);
//v 有3 个元素，每个元素都是vector<int> 容器
for(int i = 0;i < v.size(); ++i)
for(int j = 0; j < 4; ++j)
v[i].push_back(j);
for(int i = 0;i < v.size(); ++i) {
for(int j = 0; j < v[i].size(); ++j)
cout << v[i][j] << " ";
cout << endl;
}
return 0;
}
所有适用于 vector的操作都适用于 deque。
deque还有 push_front（将元素插入到前面）和pop_front(删除最前面的元素）操作，复杂度是O(1)
list 容器
在任何位置插入删除都是常数时间，不支持随机存取。
除了具有所有顺序容器都有的成员函数以外，还支持8个成员函数：
push_front: 在前面插入
pop_front: 删除前面的元素
sort: 排序 ( list不支持 STL的算法 sort)
remove: 删除和指定值相等的所有元素
unique: 删除所有和前一个元素相同的元素(要做到元素不重复，则unique之前还需要 sort)
merge: 合并两个链表，并清空被合并的那个
reverse: 颠倒链表
splice: 在指定位置前面插入另一链表中的一个或多个元素,并在另一链表中删除被插入的元素
#include <list>
#include <iostream>
#include <algorithm>
using namespace std;
class A {
private:
int n;
public:
A( int n_ ) { n = n_; }
friend bool operator<( const A & a1, const A & a2);
friend bool operator==( const A & a1, const A & a2);
friend ostream & operator <<( ostream & o, const A & a);
};
bool operator < ( const A & a1, const A & a2) {
return a1.n < a2.n;
}
bool operator == ( const A & a1, const A & a2) {
return a1.n == a2.n;
}
ostream & operator << ( ostream & o, const A & a) {
o << a.n;
return o;
}
template <class T>
void PrintList(const list<T> & lst) {
//不推荐的写法，还是用两个迭代器作为参数更好
int tmp = lst.size();
if( tmp > 0 ) {
typename list<T>::const_iterator i;
i = lst.begin();
for( i = lst.begin();i != lst.end(); i ++)
cout << * i << ",";
}
}// typename用来说明 list<T>::const_iterator是个类型
//在vs中不写也可以
int main() {
list<A> lst1,lst2;
lst1.push_back(1);lst1.push_back(3);
lst1.push_back(2);lst1.push_back(4);
lst1.push_back(2);
lst2.push_back(10);lst2.push_front(20);
lst2.push_back(30);lst2.push_back(30);
lst2.push_back(30);lst2.push_front(40);
lst2.push_back(40);
cout << "1) "; PrintList( lst1); cout << endl;
// 1) 1,3,2,4,2,
cout << "2) "; PrintList( lst2); cout << endl;
// 2) 40,20,10,30,30,30,40,
lst2.sort();
cout << "3) "; PrintList( lst2); cout << endl;
//3) 10,20,30,30,30,40,40,
lst2.pop_front();
cout << "4) "; PrintList( lst2); cout << endl;
//4) 20,30,30,30,40,40,
lst1.remove(2); //删除所有和A(2)相等的元素
cout << "5) "; PrintList( lst1); cout << endl;
//5) 1,3,4,
lst2.unique(); //删除所有和前一个元素相等的元素
cout << "6) "; PrintList( lst2); cout << endl;
//6) 20,30,40,
lst1.merge (lst2); //合并 lst2到lst1并清空lst2
cout << "7) "; PrintList( lst1); cout << endl;
//7) 1,3,4,20,30,40,
cout << "8) "; PrintList( lst2); cout << endl;
//8)
lst1.reverse();
cout << "9) "; PrintList( lst1); cout << endl;
//9) 40,30,20,4,3,1,
lst2.push_back (100);lst2.push_back (200);
lst2.push_back (300);lst2.push_back (400);
list<A>::iterator p1,p2,p3;
p1 = find(lst1.begin(),lst1.end(),3);
p2 = find(lst2.begin(),lst2.end(),200);
p3 = find(lst2.begin(),lst2.end(),400);
lst1.splice(p1,lst2,p2, p3);
//将[p2,p3)插入p1之前，并从lst2中删除[p2,p3)
cout << "10) "; PrintList( lst1); cout << endl;
//10) 40,30,20,4,200,300,3,1,
cout << "11) "; PrintList( lst2); cout << endl;
//11) 100,400,
return 0;
}
ACM/ICPC 竞赛之STL--pair
STL的<utility>头文件中描述了一个看上去非常简单的模板类
pair，用来表示一个二元组或元素对，并提供了按照字典序对元素对
进行大小比较的比较运算符模板函数。
例如，想要定义一个对象表示一个平面坐标点，则可以：
pair<double, double> p1;
cin >> p1.first >> p1.second;
pair 模板类需要两个参数：首元素的数据类型和尾元素的数据类型。
pair 模板类对象有两个成员：first 和 second，分别表示首元素和尾
元素。
在<utility>中已经定义了 pair 上的六个比较运算符：<、>、<=、>=、
==、!=，其规则是先比较 first，first 相等时再比较 second，这符合大多数应
用的逻辑。当然，也可以通过重载这几个运算符来重新指定自己的比较逻辑。
除了直接定义一个 pair 对象外，如果需要即时生成一个 pair 对象，
也可以调用在<utility>中定义的一个模板函数：make_pair。
make_pair 需要两个参数，分别为元素对的首元素和尾元素。
就可以用 pair 来表示推演树上的结点，用 first 表示结点的值，用 second 表示结点是由父结点乘以哪一
个因子得到的。
#include <iostream>
#include <queue>
using namespace std;
typedef pair<unsigned long, int> node_type;
int main() {
unsigned long result[1500];
priority_queue<node_type, vector<node_type>,greater<node_type> > Q;
Q.push( make_pair(1, 2) );
for (int i=0; i<1500; i++) {
node_type node = Q.top(); Q.pop();
switch(node.second) {
case 2: Q.push( make_pair(node.first*2, 2) );
case 3: Q.push( make_pair(node.first*3, 3) );
case 5: Q.push( make_pair(node.first*5, 5) );
}
result[i] = node.first;
}
int n;
cin >> n;
while (n>0) {
cout << result[n-1] << endl;
cin >> n;
}
return 0;
}
<utility>看上去是很简单的一个头文件，但是<utility>的设计中却浓缩
反映了 STL 设计的基本思想。有意深入了解和研究 STL 的同学，仔
细阅读和体会这个简单的头文件，不失为一种入门的途径。
全排列函数 next_permutation
STL 中专门用于排列的函数（可以处理存在重复数据集的排列问题）
头文件：#include <algorithm>
using namespace std;
调用： next_permutation(start, end);
注意：函数要求输入的是一个升序排列的序列的头指针和尾指针.
用法：
// 数组
int a[N];
sort(a, a+N);
next_permutation(a, a+N);
// 向量
vector<int> ivec;
sort(ivec.begin(), ivec.end());
next_permutation(ivec.begin(), ivec.end());
例子：
vector<int> myVec;
// 初始化代码
sort(myVec.begin(),myVec.end());
do {
for (i = 0 ;i < size;i ++ ) cout << myVec[i] << " /t " ;
cout << endl;
}while (next_permutation(myVec.begin(), myVec.end()));
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
