STL

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()个字符，如果字符串内没有足够字符，则复制到字符串最后一个字符

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() 算法，在容器中查找一个元素，
并返回一个指向该元素的迭代器
　　算法可以处理容器，也可以处理普通数组