1.STL(Standard Template Library,是用泛型技术来设计完成的实例)的概念与组成
Iterator(迭代器)
Container(容器)
Algorithm(算法)
Adaptors(配接器)
STL的六大组件分别是：
容器（Container）
算法（Algorithm）
迭代器（Iterator）
仿函数（Function object）
适配器（Adapter）
空间配置器（allocator）:只能分配内存等
2.容器与算法
案例如下：
#include<iostream>
#include<vector>//容器
#include<array>//数组
#include<algorithm>
usingnamespacestd;
//实现一个模板类，专门实现打印的功能
template<classT> //类模板实现了方法
classmyvectorprint
{
public:
void operator ()(constT &t)//重载，使用(),打印
{
std::cout << t <<std::endl;
}
};
voidmain()
{
vector<int> myvector;
myvector.push_back(11);
myvector.push_back(21);
myvector.push_back(31);
myvector.push_back(81);
myvector.push_back(51);
array<int, 10> myarray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
myvectorprint<int>print;//对于打印进行实例化
//begin,endl迭代器，是一个指针
for_each(myvector.begin(),myvector.end(),print);
std::cout << "---------------------" <<std::endl;
for_each(myarray.begin(),myarray.end(),print);
cin.get();
//算法可以适用于任何一个容器，for_each是一个算法
}
3.容器
序列式容器（Sequence containers）
每个元素都有固定位置----取决于插入实际和地点，和元素之无关
Vector,deque,list
关联式容器（Associated containers）
元素位置取决于特定的排序准则，和插入顺序无关
set、multiset、map、multimap
4.vectors:
将元素置于一个动态数组中加以管理
可以随机存取元素（用索引直接存取）
数组尾部添加或移除元素非常快速，但是在中部或头部安插元素比较费时。
5.数组线程容器
#include<iostream>
#include<vector>
#include<array>
#include<tuple>
usingnamespacestd;
voidmain()
{
//数组，静态数组，栈上
array<int, 5> myarray = { 1, 2, 3, 4, 5 };
//动态数组，堆上
vector <int>myvector;
myvector.push_back(1);
//不需要变长，容量较小时，使用array
//不需要变长，容量较大是，使用vector
}
6.list容器（添加和迭代输出）
#include<iostream>
#include<hash_set>
#include<list> //实际上是一个双向链表
#include<stdio.h>
//list使用于经常插入，经常删除
usingnamespacestd;
voidmain()
{
list<int>mylist;
mylist.push_back(1);
mylist.push_back(2);
mylist.push_back(3);
mylist.push_back(4);
mylist.push_front(4);//往头部插入
//指针，指向一个迭代器，迭代器存储了位置
autoibegin =mylist.begin();
autoiend =mylist.end();
//list用迭代器进行遍历
for (;ibegin !=iend;ibegin++)
{
cout << *ibegin <<endl;
printf("%p,&p\n",ibegin._Ptr,ibegin);//重载
}
cin.get();
}
运行结果是：
7.list删除应该注意的地方
#include<iostream>
#include<hash_set>
#include<list> //实际上是一个双向链表
#include<stdio.h>
//list使用于经常插入，经常删除
usingnamespacestd;
voidmain()
{
list<int>mylist;
mylist.push_back(1);
mylist.push_back(2);
mylist.push_back(3);
mylist.push_back(4);
mylist.push_back(5);
//auto i = mylist.begin();删除元素，依赖于迭代器
//++i
//++i
//++i
autoi =mylist.end();//end最后一个没有实体
i--;
mylist.erase(i);//链式存储，不允许下标访问
//只能用迭代器，链表迭代器只能用++，--
//mylist.clear();清空
//指针，指向一个迭代器，迭代器存储了位置
autoibegin =mylist.begin();
autoiend =mylist.end();
for (;ibegin !=iend;ibegin++)
{
if ((*ibegin) == 3)
{
mylist.erase(ibegin);//删除，删除的时候迭代器会发生
break;//这里一定要记住，要使用break;因为list原来的结构已经发生了变化
}
//cout <<*ibegin << endl;
}
{
//指针，指向一个迭代器，迭代器存储了位置
autoibegin =mylist.begin();
autoiend =mylist.end();
for (;ibegin !=iend;ibegin++)
{
cout << *ibegin <<endl;
}
}
cin.get();
}
运行结果：
8.通过数组的方式为list初始化
#include<iostream>
#include<hash_set>
#include<list> //实际上是一个双向链表
#include<stdio.h>
//list使用于经常插入，经常删除
usingnamespacestd;
voidmain()
{
inta[5] = { 1, 2, 3, 4, 5 };
list<int>mylist(a,a + 5);//根据数组初始化
//传递开始地址，传递结束地址
//mylist(0)
//mylist[1];只能用迭代器访问
mylist.push_back(10);
mylist.push_front(12);//在前添加数值
//指针，指向一个迭代器，迭代器存储了位置
autoibegin =mylist.begin();
autoiend =mylist.end();
for (;ibegin !=iend;ibegin++)
{
if (*ibegin == 3)
{
mylist.insert(ibegin, 30);
break;//删除或者插入，迭代器都会发生变化
}
}
mylist.remove(30);//直接一个函数，根据元素来删除
{
autoibegin =mylist.begin();//指针，指向一个迭代器，迭代器存储了位置
autoiend =mylist.end();
for (;ibegin !=iend;ibegin++)
{
cout << *ibegin <<endl;
}
}
cin.get();
}
运行结果：
9.数组初始化，并逆向输出
#include<iostream>
#include<hash_set>
#include<list> //实际上是一个双向链表
#include<stdio.h>
//list使用于经常插入，经常删除
usingnamespacestd;
voidmain()
{
inta[5] = { 1, 2, 3, 4, 5 };
list<int>mylist(a,a + 5);//根据数组初始化
autorb =mylist.rbegin();
autore =mylist.rend();
//同时正向方向查找
for (;rb !=re;rb++)
{
cout << *rb <<endl;
}
cin.get();
}
运行结果：
10.list合并，排序
#include<iostream>
#include<hash_set>
#include<list> //实际上是一个双向链表
#include<stdio.h>
//list使用于经常插入，经常删除
usingnamespacestd;
voidmain()
{
inta[5] = { 1, 2, 3, 104, 5 };
list<int > mylist1(a,a + 5);//根据数组初始化，
intb[5] = { 11, 122, 33, 44, 55 };
list<int > mylist2(b,b + 5);//根据数组初始化，
mylist1.sort();
mylist2.sort();//两个list合并到list之前需要数组排序
mylist1.merge(mylist2);//合并之前必须有序
{
autoibegin =mylist1.begin();//指针，指向一个迭代器，迭代器存储了位置
autoiend =mylist1.end();
for (;ibegin !=iend;ibegin++)
{
cout << *ibegin <<endl;
}
}
cout <<"\n\n\n";
{
autoibegin =mylist2.begin();//指针，指向一个迭代器，迭代器存储了位置
autoiend =mylist2.end();
for (;ibegin !=iend;ibegin++)
{
cout << *ibegin <<endl;
}
}
cin.get();
}
运行结果：
11.list中通过unique()方法去掉重复的元素
#include<iostream>
#include<hash_set>
#include<list> //实际上是一个双向链表
#include<stdio.h>
//list使用于经常插入，经常删除
usingnamespacestd;
voidmain()
{
inta[6] = { 1, 2, 98, 2, 5, 98 };
list<int>mylist1(a,a + 6);//根据数组初始化
{
autoibegin =mylist1.begin();
autoiend =mylist1.end();
for (;ibegin !=iend;ibegin++)
{
cout << *ibegin <<endl;
}
}
mylist1.sort();
mylist1.unique();//唯一依赖于排序,通过这个方法实现了去掉重复的
cout <<"\n\n\n";
{
//指针，指向一个迭代器，迭代器存储了位置
autoibegin =mylist1.begin();
autoiend =mylist1.end();
for (;ibegin !=iend;ibegin++)
{
cout << *ibegin <<endl;
}
}
cin.get();
}
运行结果：
list迭代输出
#include<iostream>
#include<set>
#include<stdio.h>
#include<list>
#include<vector>
#include<algorithm>
#include<functional>
usingnamespacestd;
voidmain()
{
list<int>mylist;
mylist.push_back(1);
mylist.push_back(2);
mylist.push_back(3);
mylist.push_back(4);
//mylist[1];
autoibegin =mylist.begin();//指针，指向一个迭代器，迭代器存储了位置
autoiend =mylist.end();
//list用迭代器进行遍历
for (;ibegin !=iend;ibegin++)
{
cout << *ibegin <<endl;
printf("%p,%p\n",ibegin._Ptr,ibegin);//重载
}
cin.get();
}
运行结果：
12算法find
#include<algorithm>
#include<iostream>
usingnamespacestd;
structprint
{
void operator()(intx)//重载了()符号，直接调用()
{
std::cout << x <<endl;
}
};
voidprintA(intx)
{
std::cout << x <<endl;
}
//find这个算法
voidmain()
{
inta[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int *p =find(a,a + 10, 8);
std::cout << (void*)a << (void*)(a + 10) << std::endl;
std::cout << *p <<endl;
std::cout << p <<endl;
if (p == (a + 10))
{
std::cout << "没有找到\n";
}
//下面的方式是调用重载的print函数
for_each(a,a + 10,print());//遍历每一个元素
//printA是一个函数指针，必须是函数类型
std::cout << "-------------------------" <<std::endl;
for_each(a,a + 10,printA);
cin.get();
}
运行结果：
13.find_if,bind1st,仿函数
#include<iostream>
#include<set>
#include<stdio.h>
#include<list>
#include<vector>
#include<algorithm> //find_if的头文件
#include<functional> //仿函数需要这里
usingnamespacestd;
boolless3(intx)
{
returnx < 3;
}
voidmain()
{
vector<int>mylist;
mylist.push_back(1);
mylist.push_back(2);
mylist.push_back(16);
mylist.push_back(17);
mylist.push_back(18);
autoib =mylist.begin();
autoie =mylist.end();
for (;ib !=ie;ib++)
{
std::cout << *ib <<std::endl;
}
//防函数可以实现一定的算法策略
//bind1st表示要绑定一个函数
//绑定一个函数，greater<int>(),3，表示比三大的数
//查找第一个比3大的数值,下面的代码的意思是找到第一个3比取出的数值大的数的位置
autoifind =find_if(++mylist.begin(),mylist.end(),bind1st(greater<int>(), 3));
std::cout << "\n\n\n\n" << *ifind << endl;
std::cout << "---------------------" <<std::endl;
autoifind2 =find_if(mylist.begin(),mylist.end(),less3);
std::cout << "\n\n\n\n" << *ifind << endl;
cin.get();
}
STL之vector,数组线性容器array,list容器，算法find,find_if,bind1st,仿函数
原文：http://blog.csdn.net/tototuzuoquan/article/details/38948693
