1、泛型程序设计：将程序尽可能写的通用，将算法从特定的数据结构中抽象出来，成为通用的；C++模板为泛型程序设计奠定了关键的基础；STL是泛型程序设计的一个范例：容器container、迭代器iterator、算法algorithms和函数对象function object。
2、命名空间namespace：一个命名空间将不同的标识符集合在一个命名作用域（named scope）中，是为了解决命名冲突。没有声明命名空间的标识符都处在无名的命名空间中。
例如，声明一个命名空间NS：
namspace NS {
class File;
void Fun ();
}
则引用标识符的方式如下，
NS:: File obj;
NS:: Fun ();
可以利用using namespace std;指定在命名空间std中所有标识符都可以直接饮用，using NS::file；在当前作用域中就可以直接饮用file。
在新的C++标准程序库中，所有标识符都声明在命名空间std中，头文件都不使用扩展名。
3、容器：容器类是容纳、包含一组元素或元素集合的对象。异类容器类与同类容器类。还可以分为顺序容器与关联容器。七种基本容器：向量（vector）、双端队列（deque）、列表（list）、集合（set）、多重集合（multiset）、映射（map）和多重映射（multimap）
容器的接口：外界可以使用的功能。包括方法函数和运算符。
通用运算符：==，!=，>，>=，<，<=，=
迭代方法begin()，end()，rbegin()，rend()；访问方法size()，max_size()，swap()，empty()
顺序容器：接口：插入方法 push_front(), push_back(), insert(), 运算符"="。
删除方法 pop(), erase(),clear()
迭代访问方法 使用迭代器
其他顺序容器访问方法（不修改的访问方法） front(),back(),下标运算符[]。
顺序容器向量：向量属于顺序容器，用于容纳不定长的线性序列，提供对序列的快速随机访问，就是直接访问。向量是动态结构，它的大小不固定，可以在程序运行时增加或者减少。
例子：求反问2~N中的质数，N在程序运行时由键盘输入。
#include <iostream>
#include <iomanip>
#include <vector> //包含向量容器头文件
using namespace std ;
int main()
{
vector<int> A(10); // 用来存放质数的向量，初始状态有10个元素。
int n; //质数范围的上限，运行时输入
int primecount = 0, i, j;
cout << "Enter a value >= 2 as upper limit for prime numbers: ";
cin >> n;
A[primecount++] = 2; // 2是一个质数
for(i = 3; i < n; i++)
{
if (primecount == A.size()) // 如果质数表已满，则再申请10个元素的空间
A.resize(primecount + 10);
if (i % 2 == 0) //大于2的偶数不是质数，因此略过本次循环的后继部分
continue;
// 检查3,5,7,...,i/2是否i的因子
j = 3;
while (j <= i/2 && i % j != 0)
j += 2;
if (j > i/2) // 若上述参数均不为i的因子,则i为质数
A[primecount++] = i;
}
for (i = 0; i < primecount; i++) //输出质数
{
cout << setw(5) << A[i];
if ((i+1) % 10 == 0) //每输出10个数换行一次
cout << endl;
}
cout << endl;
}
4、适配器：适配器是一种接口类，为已有的类提供新的接口，目的是简化、约束，使之安全、隐藏或者改变被修改类提供的服务的集合。主要有三种适配器类型：容器适配器（用来扩展7中基本容器），迭代器适配器和函数对象适配器。
5、迭代器：是面向对象版本的指针，提供了访问容器、序列中每个元素的方法
输入迭代器
可以用来从序列中读取数据
输出迭代器
允许向序列中写入数据
前向迭代器
既是输入迭代器又是输出迭代器，并且可以对序列进行单向的遍历
双向迭代器
与前向迭代器相似，但是在两个方向上都可以对数据遍历
随机访问迭代器
也是双向迭代器，但能够在序列中的任意两个位置之间进行跳转。
6、算法：标准模板库中包括了70多个算法，其中包括了查找算法、排序算法、消除算法、计数算法、比较算法、变换算法、置换算法和容器管理等等
算法是一种函数模板，可以分为
不可变序列算法（non-mutating algorithms），不直接修改所操作的容器内容的算法
可变序列算法（mutating algorithms），可以修改它们所操作的容器的元素。
排序相关算法和数值算法
例6-1，应用不可变序列算法对数据序列进行分析
例6-2，以可变序列算法对数据序列进行复制，生成，删除，替换，倒序，旋转等可变性操作。
例6-3，应用排序相关算法对序列进行各项操作
例6-4，应用数值算法对数据序列进行操作
//6-1.cpp
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;
int main()
{
int iarray[]={0,1,2,3,4,5,6,6,6,7,8};
vector<int> ivector(iarray,iarray+sizeof(iarray)/sizeof(int));
int iarray1[]={6,6};
vector<int> ivector1(iarray1,iarray1+sizeof(iarray1)/sizeof(int));
int iarray2[]={5,6};
vector<int> ivector2(iarray2,iarray2+sizeof(iarray2)/sizeof(int));
int iarray3[]={0,1,2,3,4,5,7,7,7,9,7};
vector<int> ivector3(iarray3,iarray3+sizeof(iarray3)/sizeof(int));
//找出ivector之中相邻元素值相等的第一个元素
cout<<*adjacent_find(ivector.begin(),ivector.end())<<endl;
//找出ivector之中元素值为6的元素个数
cout<<count(ivector.begin(),ivector.end(),6)<<endl;
//找出ivector之中小于7的元素个数
cout<<count_if(ivector.begin(),ivector.end(),bind2nd(less<int>(),7))<<endl;
//找出ivector之中元素值为4的第一个元素所在位置的元素
cout<<*find(ivector.begin(),ivector.end(),4)<<endl;
//找出ivector之中大于2的第一个元素所在位置的元素
cout<<*find_if(ivector.begin(),ivector.end(),bind2nd(greater<int>(),2))
<<endl;
//找出ivector之中子序列ivector1所出现的最后一个位置，再往后3个位置的元素
cout<<*(find_end(ivector.begin(),ivector.end(),ivector1.begin(),
ivector1.end())+3)<<endl;
//找出ivector之中子序列ivector1所出现的第一个位置，再往后3个位置的元素
cout<<*(find_first_of(ivector.begin(),ivector.end(),ivector1.begin(),
ivector1.end())+3)<<endl;
//子序列ivector2在ivector中出现的起点位置元素
cout<<*search(ivector.begin(),ivector.end(),ivector2.begin(),ivector2.end())
<<endl;
//查找连续出现3个6的起点位置元素
cout<<*search_n(ivector.begin(),ivector.end(),3,6,equal_to<int>())<<endl;
//判断两个区间ivector和ivector3相等否(0为假，1为真）
cout << equal(ivector.begin(), ivector.end(), ivector3.begin()) << endl;
//查找区间ivector3在ivector中不匹配点的位置
pair<int*,int*>result=mismatch(ivector.begin(),ivector.end(),ivector3.begin());
cout<< result.first - ivector.begin() << endl;
}
//6-2.cpp
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;
class even_by_two{ //类定义形式的函数对象
public:
int operator()() const
{return _x+=2;}
private:
static int _x;
};
int even_by_two::_x=0; //静态数据成员初始化
int main()
{
int iarray[]={0,1,2,3,4,5,6,6,6,7,8};
int iarray1[]={0,1,2,3,4,4,5,5,6,6,6,6,6,7,8};
vector<int> ivector(iarray,iarray+sizeof(iarray)/sizeof(int));
vector<int> ivector1(iarray+6,iarray+8);
vector<int> ivector2(iarray1,iarray1+sizeof(iarray1)/sizeof(int));
ostream_iterator< int > output( cout, " " ); //定义流迭代器用于输出数据
//迭代遍历ivector1区间，对每一个元素进行even_by_two操作
generate(ivector1.begin(),ivector1.end(),even_by_two());
copy(ivector1.begin(),ivector1.end(),output);
cout<<endl;
//迭代遍历ivector的指定区间（起点和长度），对每一个元素进行even_by_two操作
generate_n(ivector.begin(),3,even_by_two());
copy(ivector.begin(),ivector.end(),output);
cout<<endl;
//删除元素6
remove(ivector.begin(),ivector.end(),6);
copy(ivector.begin(),ivector.end(),output);
cout<<endl;
//删除(实际并未从原序列中删除）元素6，结果置于另一个区间
vector<int> ivector3(12);
remove_copy(ivector.begin(),ivector.end(),ivector3.begin(),6);
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;
//删除(实际并未从原序列中删除）小于6的元素
remove_if(ivector.begin(),ivector.end(),bind2nd(less<int>(),6));
copy(ivector.begin(),ivector.end(),output);
cout<<endl;
//删除(实际并未从原序列中删除)小于7的元素，结果置于另一个区间，
remove_copy_if(ivector.begin(),ivector.end(),ivector3.begin(),
bind2nd(less<int>(),7));
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;
//将所有的元素值6，改为元素值3
replace(ivector.begin(),ivector.end(),6,3);
copy(ivector.begin(),ivector.end(),output);
cout<<endl;
//将所有的元素值3，改为元素值5,结果放置到另一个区间
replace_copy(ivector.begin(),ivector.end(),ivector3.begin(),3,5);
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;
//将所有小于5的元素值，改为元素值2
replace_if(ivector.begin(),ivector.end(),bind2nd(less<int>(),5),2);
copy(ivector.begin(),ivector.end(),output);
cout<<endl;
//将所有的元素值8，改为元素值9,结果放置到另一个区间
replace_copy_if(ivector.begin(),ivector.end(),ivector3.begin(),
bind2nd(equal_to<int>(),8),9);
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;
//逆向重排每一个元素
reverse(ivector.begin(),ivector.end());
copy(ivector.begin(),ivector.end(),output);
cout<<endl;
//逆向重排每一个元素,结果置于另一个区间
reverse_copy(ivector.begin(),ivector.end(),ivector3.begin());
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;
//旋转（互换元素）[first,middle), 和[middle,end)
rotate(ivector.begin(),ivector.begin()+4,ivector.end());
copy(ivector.begin(),ivector.end(),output);
cout<<endl;
//旋转（互换元素）[first,middle], 和[middle,end]，结果置于另一个区间，
rotate_copy(ivector.begin(),ivector.begin()+5,ivector.end(),
ivector3.begin());
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;
}
//6-3.cpp
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;
int main()
{
int iarray[]={26,17,15,22,23,33,32,40};
vector<int> ivector(iarray,iarray+sizeof(iarray)/sizeof(int));
// 查找并输出最大、最小值元素
cout<<*max_element(ivector.begin(),ivector.end())<<endl;
cout<<*min_element(ivector.begin(),ivector.end())<<endl;
//将ivector.begin()+4-ivector.begin()各元素排序，
//放进[ivector.begin(),ivector.begin()+4]区间。剩余元素不保证维持原来相对次序
partial_sort(ivector.begin(),ivector.begin()+3,ivector.end());
copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));
cout<<endl;
//局部排序并复制到别处
vector<int> ivector1(5);
partial_sort_copy(ivector.begin(),ivector.end(),ivector1.begin(),
ivector1.end());
copy(ivector1.begin(),ivector1.end(),ostream_iterator<int>(cout," "));
cout<<endl;
//排序，缺省为递增。
sort(ivector.begin(),ivector.end());
copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));
cout<<endl;
//将指定元素插入到区间内不影响区间原来排序的最低、最高位置
cout<<*lower_bound(ivector.begin(),ivector.end(),24)<<endl;
cout<<*upper_bound(ivector.begin(),ivector.end(),24)<<endl;
//对于有序区间，可以用二分查找方法寻找某个元素
cout<<binary_search(ivector.begin(),ivector.end(),33)<<endl;
cout<<binary_search(ivector.begin(),ivector.end(),34)<<endl;
//下一个排列组合
next_permutation(ivector.begin(),ivector.end());
copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));
cout<<endl;
//上一个排列组合
prev_permutation(ivector.begin(),ivector.end());
copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));
cout<<endl;
//合并两个序列ivector和ivector1，并将结果放到ivector2中
vector<int> ivector2(13);
merge(ivector.begin(),ivector.end(),ivector1.begin(),ivector1.end(),
ivector2.begin());
copy(ivector2.begin(),ivector2.end(),ostream_iterator<int>(cout," "));
cout<<endl;
//将小于*(ivector.begin()+5)的元素放置在该元素之左
//其余置于该元素之右。不保证维持原有的相对位置
nth_element(ivector2.begin(),ivector2.begin()+5,ivector2.end());
copy(ivector2.begin(),ivector2.end(),ostream_iterator<int>(cout," "));
cout<<endl;
//排序，并保持原来相对位置
stable_sort(ivector2.begin(),ivector2.end());
copy(ivector2.begin(),ivector2.end(),ostream_iterator<int>(cout," "));
cout<<endl;
//针对一个有序区间，找出其中一个子区间，其中每个元素都与某特定元素值相同
pair<vector<int>::iterator,vector<int>::iterator> pairIte;
pairIte=equal_range(ivector2.begin(),ivector2.end(),22);
cout<<*(pairIte.first)<<endl;
cout<<*(pairIte.second)<<endl;
//合并两个有序序列，然后就地替换
int iarray3[] = { 1, 3, 5, 7, 2, 4, 6, 8 };
vector<int> ivector3(iarray3,iarray3+sizeof(iarray3)/sizeof(int));
inplace_merge(ivector3.begin(), ivector3.begin()+ 4, ivector3.end());
copy(ivector3.begin(),ivector3.end(), ostream_iterator<int>(cout, " "));
cout<<endl;
//以字典顺序比较序列ivector3和ivector4
int iarray4[] = { 1, 3, 5, 7,1, 5, 9, 3 };
vector<int> ivector4(iarray4,iarray4+sizeof(iarray4)/sizeof(int));
cout<< lexicographical_compare(ivector3.begin(),ivector3.end(),
ivector4.begin(),ivector4.end()) << endl;
}
//6-4.cpp
#include <iostream>
#include <numeric>
#include <functional>
#include <vector>
using namespace std;
int main()
{
int iarray[]={1,2,3,4,5};
vector<int> ivector(iarray,iarray+sizeof(iarray)/sizeof(int));
//元素的累计
cout<<accumulate(ivector.begin(),ivector.end(),0)<<endl;
//向量的内积
cout<<inner_product(ivector.begin(),ivector.end(),ivector.begin(),10)<<endl;
//向量容器中元素局部求和
partial_sum(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));
cout<<endl;
//向量容器中相邻元素的差值
adjacent_difference(ivector.begin(),ivector.end(),
ostream_iterator<int>(cout," "));
cout<<endl;
}
7、函数对象：一个行为类似于函数的对象，它可以没有参数，也可以带有若干参数，其功能是获取一个值，或者改变操作的状态。任何普通的函数和任何重载了调用运算符operate()的类的对象都满足函数对象的特征，STL中也定义了一些标准的函数对象，如果以功能划分，可以分为算术运算、关系运算、逻辑运算三大类。为了调用这些标准函数对象，需要包含头文件<functional>。