xiegenwendada
xiegenwendada

C++STL基础

什么是STL

STL就是Standard Template Library，标准模板库。STL是泛型编程的实例，用到的技术就是类模板和函数模板。STL的一个重要特点是数据结构和算法的分离。

模板：所谓模板是一种使用无类型参数来产生一系列函数或类的机制。通过模板可以产生类或函数的集合，使它们操作不同的数据类型，从而避免需要为每一种数据类型产生一个独立的类或函数。 

STL简介

STL的代码从广义上讲分为3类：algorithm(算法)、container(容器)和iterator(迭代器)。几乎所有的代码都采用了模板类和模板函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用几乎。在C++标准中，STL由13个头文件组成，如<list>

STL的代码从广义上讲分为三类(共13个头文件)

算法(algorithm)  3个头文件

algorithm,numeric,functional

容器(container)  7个头文件

vector,list,deque,stack,set(set,multiset),map(map,multimap),queue(queue,priority_queue)   共10个数据结构

迭代器(iterator)  3个头文件

iterator,memory,utility

算法

算法是用来操作容器中的数据的模版函数。例如，STL用sort()来对一个vector中的数据进行排序，用find()来搜索一个list中的对象。函数本身与他们操作的数据的结构和类型无关，因此他们可以从简单的数组到高度复杂容器的任何数据结构上使用。

算法部分主要由头文件<algorithm>，<numeric>和<functional>组成。<algorithm>是所有STL头文件中最大的一个（尽管它很好理解），它是由一大堆模版函数组成的，可以认为每个函数在很大程度上都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操作。<functional>中则定义了一些模板类，用以声明函数对象。

容器

容器是一种数据结构，如list，vector和deques，以模板类的方法提供。为了访问容器中的数据，可以使用容器类输出的迭代器。 

数据结构 描述 头文件
vector向量 连续存储元素 <vector>
list列表 由节点组成的双向链表，每个节点包含一个元素 <list>
deque双列表 连续存储的指向不同元素的指针所组成数组 <deque>
set集合

由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序

 <set>
multiset多重集合

允许存在两个次序相等的元素的集合

 <set>
stack栈

后进先出的值的排列

 <stack>
queue队列

先进先出的执的排列

 <queue>
priority_queue优先队列

元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列

 <queue>
map映射

由{键，值}对组成的集合，以某种作用于键对上的谓词排列

 <map>
multimap多重映射

允许键对有相等的次序的映射

 <map>

对应的数据结构：vector线性表，list双向链表，stack栈，queue队列，deque可以理解为vector和list的结合体，set红黑树，map平衡二叉树

 

容器分为三大类
顺序容器

vector：后部插入/删除，直接访问

deque：前/后部插入/删除，直接访问

list：双向链表，任意位置插入/删除
关联容器

set：快速查找，无重复元素

multiset：快速查找，可有重复元素

map：一对一映射，无重复元素，基于关键字查找

multimap：一对一映射，可有重复元素，基于关键之查找
容器适配器

stack：LIFO

queue：FIFO

priority_queue：优先级高的元素先出

 

迭代器

迭代器提供了访问容器中对象的方法。例如，可以使用一对迭代器指定list或vector中的一定范围的对象。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器也可以是那些定义了operator*()以及其他类似于指针的操作符地方法的类对象。

软件设计有一个基本原则，所有的问题都可以通过引进一个间接层来简化，这种简化在STL中就是用迭代器来完成的。概括来说，迭代器在STL中用来将算法和容器联系起来，起着一种黏和剂的作用。几乎STL提供的所有算法都是通过迭代器存取元素序列进行工作的，每一个容器都定义了其本身所专有的迭代器，用以存取容器中的元素。

迭代器部分主要由头文件<utility>,<iterator>和<memory>组成。

<utility>是一个很小的头文件，它包括了贯穿使用在STL中的几个模板的声明，

<iterator>中提供了迭代器使用的许多方法，

而对于<memory>的描述则十分的困难，它以不同寻常的方式为容器中的元素分配存储空间，同时也为某些算法执行期间产生的临时对象提供机制,<memory>中的主要部分是模板类allocator，它负责产生所有容器中的默认分配器。

容器

同一种类型对象的集合。这些容器的共有成员函数：empty()判断容器中是否有元素，max_size()容器中最多能装多少元素，swap()交换两个容器的内容。

比较两个容器大小的运算符：=,<,<=,>,>=,==,!=

  • 1.若两容器长度相同、所有元素相等，则两个容器就相等，否则为不等。
  • 2.若两容器长度不同，但较短容器中所有元素都等于较长容器中对应的元素，则较短容器小于另一个容器。
  • 3.若两个容器均不是对方的子序列，则取决于所比较的第一个不等的元素)

线性表

在实际应用中，线性表都是以字符串string，数组array，栈stack，队列queue，优先队列priority_queue，向量vector，列表list，双向队列deque等特殊线性表的形式来使用的。根据存储方式可分为顺序表，链表；链表又分为单链表，双链表，循环链表。

顺序容器(vector,list,deque)

元素排列次序与元素值无关，而是由元素添加到容器里的顺序决定的。

  • 1.定义赋值，它们的定义赋值assign及用法完全相同。
  • 2.都有返回表头元素表尾元素front(),back(),对于双向链表list和双向队列deque来说也只有一个表头和一个表尾，这里的双向是对元素可以双向添加删除而言的。
  • 3.增加删除元素，都提供了在表尾增加删除元素方法push_back(),pop_back(),在任意位置增加删除元素方法insert(),erase()，全部删除元素clear()。
  • 4.返回iterator和reverse_iterator 返回指向表头元素的指针begin(),返回表尾元素下一个位置end(),返回指向表尾元素的指针rbegin(),返回表头元素前一个位置rend()。
  • 5.其他 获取长度size(),重置长度resize(),返回最大长度max_size(),两个容器互换swap()，判断是否为空empty()

vector

向量vector就是动态数组。顺序存储(说明可以用索引值，at()来进行元素访问，且其iterator可以+-n)，连续存储元素。比list和deque多提供了获取容量capacity(),设置最小容量reserve()

list

列表list是一个双向链表。链式存储(不可以用索引值来进行访问，且其iterator不可以+-n)，由节点组成的双向链表，每个节点包含着一个元素。由于是双向链表，所以比vector多提供了在表头增加删除函数push_front(),pop_front(),此外比vector和deque多提供了排序函数sort(),队列合并merge()(注意：合并前需要排序),接合函数splice(),去重函数unique(),删除元素函数remove()，remove_if()

deque

双向队列deque。顺序存储(说明可以用索引值，at()来进行元素访问，且其iterator可以+-n)，连续存储指向不同元素的指针所组成的数组。由于是双向队列，所以比vector多提供了在表头增加删除函数push_front(),pop_front(),此外比vector少提供了逆序函数reverse()

选择容器类型的法则

如果程序要求随机访问元素，则应使用 vector 或 deque 容器。
如果程序必须在容器的中间位置插入或删除元素，则应采用 list 容器。
如果程序不是在容器的中间位置，而是在容器首部或尾部插入或删除元素，则应采用 deque 容器。
如果只需在读取输入时在容器的中间位置插入元素，然后需要随机访问元素，则可考虑在输入时将元素读入到一个 list 容器，接着对此容器重新排序，使其适合顺序访问，然后将排序后的 list 容器复制到一个 vector 容器。


关联容器，通过 键 存储和读取元素。顺序容器，通过元素在容器中的位置顺序存储和读取元素。
关联容器和顺序容器的本质差别在于：关联容器通过键（key）存储和读取元素，而顺序容器则通过元素在容器中的位置顺序存储和访问元素。 

map映射

map是标准关联式容器之一，一个map是一个键值对序列，即(key，value)对。它提供了基于key的快速检索能力，在一个map中key值是唯一的。map提供了双向迭代器，即从前往后的(iterator)，也有从后往前的(reverse_iterator)。
map要求能对key进行操作，且保持按key值递增有序，因此map上的迭代器也是递增有序的。如果对于元素并不需要保持有序，可以使用hash_map。
map中key值是唯一的，如果map中已存在一个键值对(昵称，密码):("sky",789852)，而我们还是想插入一个键值对("sky",789852)则会报错(不是报错，准确的说是，返回插入不成功！)。而我们有的确想这样做，即一个键对于多个值，幸运的是multimap可以实现这个功能。

小demo

   网上实例

[cpp] view plain copy print ?
  1. #include <string>  
  2. #include <map>    
  3. #include <conio.h>  
  4. #include<iostream>  
  5. using namespace std;     
  6. //定义及初始化；没有返回值，或void  
  7. void test0()  
  8. {    
  9.     map<int,string> first;  
  10.     first.insert(pair<int,string>(3,"hello"));  
  11.     map<int,string> second(first);//拷贝构造函数  
  12.     map<int,string> third(first.begin(),first.end());//区间构造函数  
  13. }  
  14. //增加删除元素；返回值是void,除erase()的返回值是iterator外  
  15. void test1()  
  16. {      
  17.     //first insert 用insert()函数插入pair数据  
  18.     map<char,int> myfirst;  
  19.     myfirst.insert(pair<char,int>('a',100));   
  20.     //second insert 用insert()函数插入value_type数据  
  21.     myfirst.insert(map<char,int>::value_type('f',50));   
  22.     //third insert 使用数组方式插入数据  
  23.     myfirst['w']=60;   
  24.     //fourth insert 在iterator位置上插入pair数据  
  25.     map<char,int>::iterator ite=myfirst.begin();  
  26.     myfirst.insert(ite,pair<char,int>('b',300));    
  27.        
  28.     cout<<"myfirst\n";  
  29.     for (map<char,int>::iterator iter=myfirst.begin();iter!=myfirst.end();iter++)  
  30.     {  
  31.         cout<<iter->first<<"=>"<<iter->second<<endl;  
  32.         //a=>100  
  33.         //b=>300  
  34.         //f=>50  
  35.         //w=>60  
  36.     }   
  37.     map<int,int>mymap;  
  38.     for (int i=0;i<3;i++)  
  39.     {  
  40.         mymap[i]=i*100;  
  41.     }   
  42.     for (map<int,int>::iterator iter=mymap.begin();iter!=mymap.end();iter++)  
  43.     {  
  44.         cout<<iter->first<<"=>"<<iter->second<<endl;  
  45.         //0=>0  
  46.         //1=>100  
  47.         //2=>200  
  48.     }  
  49.     mymap.clear();  
  50.     mymap[8]=20;  
  51.     mymap[5]=60;   
  52.     while(!mymap.empty())  
  53.     {  
  54.         cout<<mymap.begin()->first<<"=>"<<mymap.begin()->second<<endl;  
  55.         //5=>60  
  56.         //8=>20  
  57.         mymap.erase(mymap.begin());  
  58.     }  
  59.     map<char,int> first;  
  60.     map<char,int>::iterator it;  
  61.     first['a']=10;  
  62.     first['b']=20;  
  63.     first['c']=30;  
  64.     first['d']=40;  
  65.     first['e']=50;  
  66.     first['f']=60;  
  67.     first['g']=70;  
  68.     first['h']=80;  
  69.       
  70.     it=first.find('b');  
  71.     first.erase(it); //用迭代器删除  
  72.     first.erase('c');//用关键字删除  
  73.     it=first.find('e');  
  74.     first.erase(it,first.end());//成片删除  
  75.     cout<<"--------------erase-------------\n";  
  76.     for (it=first.begin();it!=first.end();it++)  
  77.     {  
  78.         cout<<it->first<<"=>"<<it->second<<endl;  
  79.         //a=>10  
  80.         //b=>40  
  81.     }     
  82. }  
  83. //访问获取元素；返回值是Type T  
  84. void test2()  
  85. {    
  86.     map<char,int> first;  
  87.     map<char,int>::iterator it;  
  88.     first['a']=10;  
  89.     first['b']=20;  
  90.     first['c']=30;  
  91.     first['d']=40;  
  92.     it=first.find('b');  
  93.     first.erase(it);  
  94.     first.erase(first.find('d'));  
  95.     cout<<"a=>"<<first.begin()->second<<endl;//a=>10  
  96.     cout<<"c=>"<<first.find('c')->second<<endl;//c=>30  
  97.     //cout<<"w=>"<<first.find('w')->second<<endl;//当关键字不存在时，运行出现错误  
  98.        
  99. }  
  100. //返回迭代器；返回值是iterator，或reverse_iterator  
  101. void test3()  
  102. {   
  103.     map<char,int> mymap;  
  104.     mymap['b']=100;  
  105.     mymap['a']=200;  
  106.     mymap['c']=500;  
  107.     map<char,int>::iterator iter=mymap.begin();  
  108.     for (;iter!=mymap.end();iter++)  
  109.     {  
  110.         cout<<iter->first<<"=>"<<iter->second<<endl;  
  111.         //a=>200  
  112.         //b=>100  
  113.         //c=>500  
  114.     }      
  115.     cout<<"----reverse_iterator----"<<endl;  
  116.     map<char,int>::reverse_iterator riter=mymap.rbegin();  
  117.     for (;riter!=mymap.rend();++riter)  
  118.     {   
  119.         cout<<riter->first<<"=>"<<riter->second<<endl;  
  120.         //c=>500  
  121.         //b=>100  
  122.         //a=>200  
  123.     }  
  124.       
  125. }   
  126. //其他  
  127. void test4()  
  128. {    
  129.     map<char,int>mymap,second;  
  130.     mymap['a']=101;  
  131.     mymap['b']=202;  
  132.     mymap['c']=303;  
  133.     mymap['d']=404;  
  134.     for (char c='a';c<'h';c++)  
  135.     {  
  136.         cout<<c;  
  137.         if (mymap.count(c)>0)  
  138.         {  
  139.             cout<<" is an element of mymap.\n";//a,b,c,d  
  140.         }  
  141.         else  
  142.             cout<<" is not an element of mymap.\n";//d,e,f,g        
  143.     }  
  144.     cout<<"mymap.size() is "<<mymap.size()<<endl;//3  
  145.   
  146.     second['x']=11;  
  147.     second['y']=22;  
  148.     second['z']=33;  
  149.     second.swap(mymap);  
  150.   
  151.     cout<<"mymap-----\n";  
  152.     for (map<char,int>::iterator it=mymap.begin();it!=mymap.end();it++)  
  153.     {  
  154.         cout<<it->first<<"=>"<<it->second<<endl;  
  155.         //x=>11  
  156.         //y=>22  
  157.         //z=>33  
  158.     }  
  159.     cout<<"second-----\n";  
  160.     for (map<char,int>::iterator it=second.begin();it!=second.end();it++)  
  161.     {  
  162.         cout<<it->first<<"=>"<<it->second<<endl;  
  163.         //a=>101  
  164.         //b=>202  
  165.         //c=>303  
  166.         //d=>404  
  167.     }  
  168.     //equal_range()：返回pair(iterator,iterator),pair中的第一个迭代器是lower_bound()返回的迭代器，pair中的第二个迭代器是upper_bound()返回的迭代器，如果两个迭代器相等，则说明map中不存在这个关键字  
  169.     pair<map<char,int>::iterator,map<char,int>::iterator> ret=mymap.equal_range('y');  
  170.     cout<<"lower bound points to: "<<ret.first->first<<"=>"<<ret.first->second<<endl;//y=>22  
  171.     cout<<"upper bound points to: "<<ret.second->first<<"=>"<<ret.second->second<<endl;//z=>33  
  172.   
  173.     map<char,int>::iterator itlow,itup;  
  174.     //lower_bound():返回是iterator，返回要查找关键字的下界(是一个迭代器)  
  175.     //upper_bound():返回是iterator，返回要查找关键字的上界(是一个迭代器)  
  176.     itlow=second.lower_bound('b');//itlow points to b  
  177.     itup=second.upper_bound('c');//itup points to d (not c)  
  178.     second.erase(itlow,itup);//删除[itlow,itup)  
  179.     cout<<"itlow,itup\n";  
  180.     for (map<char,int>::iterator it=second.begin();it!=second.end();it++)  
  181.     {  
  182.         cout<<it->first<<"=>"<<it->second<<endl;   
  183.         //a=>101  
  184.         //d=>404  
  185.     }  
  186.     second['p']=505;  
  187.     map<char,int>::key_compare mycomp=second.key_comp();  
  188.     char highest=second.rbegin()->first;  
  189.     map<char,int>::iterator item=second.begin();  
  190.     cout<<"key_compare\n";  
  191.     do   
  192.     {  
  193.         cout<<item->first<<"=>"<<item->second<<endl;   
  194.     }while(mycomp((*item++).first,highest));  
  195.   
  196.     cout<<"value_compare\n";  
  197.     pair<char,int> high=*second.rbegin();  
  198.     map<char,int>::iterator io=second.begin();  
  199.     do   
  200.     {  
  201.         cout<<io->first<<"=>"<<io->second<<endl;   
  202.     } while (second.value_comp()(*io++,high));  
  203.       
  204. }   
  205. //遍历map中的数据  
  206. void test5()  
  207. {    
  208.     //1.使用前向迭代器  
  209.     //2.使用相反迭代器  
  210.     //3.使用数组(不完全正确，当数据插入时键值完全顺序才正确，不然会出现二叉树的输出结果)  
  211.     map<int,int> mymap;  
  212.     mymap[0]=100;  
  213.     mymap[3]=200;  
  214.     mymap[2]=500;  
  215.     map<int,int>::iterator iter=mymap.begin();  
  216.     for (;iter!=mymap.end();iter++)  
  217.     {  
  218.         cout<<iter->first<<"=>"<<iter->second<<endl;  
  219.         //0=>100  
  220.         //2=>500  
  221.         //3=>200  
  222.     }      
  223.     cout<<"----reverse_iterator----"<<endl;  
  224.     map<int,int>::reverse_iterator riter=mymap.rbegin();  
  225.     for (;riter!=mymap.rend();++riter)  
  226.     {   
  227.         cout<<riter->first<<"=>"<<riter->second<<endl;  
  228.         //3=>200  
  229.         //2=>500  
  230.         //0=>100  
  231.     }  
  232.     cout<<"mymap size:"<<mymap.size()<<endl;  
  233.     for (int i=0;i<mymap.size();i++)  
  234.     {  
  235.         cout<<mymap[i]<<endl;  
  236.         //100  
  237.         //0  
  238.         //500   
  239.         //200  
  240.         //map中由于他内部有序，由红黑树保证，因此很多函数执行的时间复杂度都是log2N  
  241.     }     
  242. }   
  243. void Test(char h)  
  244. {  
  245.     cout<<"press key===="<<h<<endl;  
  246.     switch(h)  
  247.     {   
  248.     case '0':  test0();break;  
  249.     case '1':  test1();break;  
  250.     case '2':  test2();break;  
  251.     case '3':  test3();break;  
  252.     case '4':  test4();break;  
  253.     case '5':  test5();break;   
  254.     case 27:  
  255.     case 'q':exit(0);break;   
  256.     default:cout<<"default "<<h<<endl;break;  
  257.     }  
  258. }  
  259. void main()  
  260. {  
  261.     while(1)  
  262.     {  
  263.         Test(getch());  
  264.     }   
  265. }  

 

map是一类关联容器。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他节点都没有什么影响。因为它内部结构式红黑二叉树。对于迭代器来说可以修改实值value，而不能修改关键字key。map的功能如下：

  • 自动建立key-value的对应。key和value可以使任意你需要的类型。
  • 根据key值快速查找记录，查找的复杂度基本是log(N)
  • 快速插入key-value记录
  • 快速删除记录
  • 根据key修改value记录
  • 遍历所有记录

Vector 网上教程有实例的

vector的函数共有五大类：定义及初始化，增加删除元素，访问元素，返回迭代器，获取设置长度容器

 

[cpp] view plain copy print ?
  1. #include <string>  
  2. #include <vector>   
  3. #include <conio.h>  
  4. #include<iostream>  
  5. using namespace std;    
  6. //定义及初始化；返回void或无返回值  
  7. void test0()  
  8. {   
  9.     vector<int> v;//只定义了v，没有分配内存空间  
  10.     vector<int> ve(2);//定义并分配了2int空间的ve，缺省为0  
  11.     vector<int> vec(3,4);//定义并初始化了3个4的vec  
  12.     cout<<v.size()<<" "<<ve.size()<<" "<<vec.size()<<endl;//0 2 3  
  13.     cout<<"ve:"<<ve[0]<<" "<<ve[1]<<endl;//ve: 0 0  
  14.     cout<<"vec:"<<vec[0]<<" "<<vec[1]<<" "<<vec[2]<<endl;//vec: 4 4 4  
  15.     v.assign(3,8);//赋值3个8  
  16.     ve.assign(vec.begin(),vec.end());//赋值3个4  
  17.     for (int i=0;i<v.size();i++)   
  18.         cout<<v[i]<<" "; //8 8 8   
  19.     cout<<endl;  
  20.     for (int i=0;i<ve.size();i++)   
  21.         cout<<ve[i]<<" ";//4 4 4   
  22.     cout<<endl;  
  23.     ve.assign(0,0);//赋值0个0，且可以看出它的内存是变化的.此为空  
  24.     for (int i=0;i<ve.size();i++)   
  25.         cout<<ve[i]<<" ";//为空   
  26.     cout<<endl;      
  27. }  
  28. //增加删除元素；返回void，处erase()返回iterator外  
  29. void test1()  
  30. {   
  31.     vector<char> v(2,'A');  
  32.     v.push_back('B');//在尾部加入一个数据  
  33.     cout<<v[0]<<" "<<v[1]<<' '<<v[2]<<endl;//A A B  
  34.     v.pop_back();//删除最后一个数据  
  35.     v.insert(v.begin()+1,'C');//在第二个位置上插入了'C'  
  36.     v.insert(v.begin(),2,'D'); //在第一个第二个位置上分别插入'C'  
  37.     v.insert(v.end(),v.begin(),v.end());//在其末端插入了其之前的所有元素，等于复制了  
  38.     for (int i=0;i<v.size();i++)   
  39.         cout<<v[i]<<" "; //D D A C A D D A C A  
  40.     cout<<endl;  
  41.   
  42.     v.erase(v.begin());//删除第一个元素  
  43.     for (int i=0;i<v.size();i++)   
  44.         cout<<v[i]<<" "; //D A C A D D A C A  
  45.     cout<<endl;  
  46.     v.erase(v.begin()+1,v.end()-1);//留下两端的元素，删除中间的元素  
  47.     for (int i=0;i<v.size();i++)   
  48.         cout<<v[i]<<" "; //D A  
  49.     cout<<endl;  
  50.     v.clear();//删除全部  
  51.     for (int i=0;i<v.size();i++)   
  52.         cout<<v[i]<<" "; //为空  
  53.     cout<<endl;  
  54. }  
  55. //访问获取元素；返回TYPE &T  
  56. void test2()  
  57. {   
  58.     string str[]={"one","two","three","four","five","six"};  
  59.     vector<string> ve;  
  60.     for(int i=0;i<6;i++)   
  61.     {  
  62.         ve.push_back(str[i]);   
  63.         cout<<ve[i]<<" ";//通过索引值i来进行访问,使用的是数组的形式，当然不能越界  
  64.     }  
  65.     cout<<endl;  
  66.     for(int i=0;i<6;i++)   
  67.     {   
  68.         cout<<ve.at(i)<<" ";//使用at()通过i来进行访问，也不能越界。若越界，在调试时，会抛出异常；在运行时直接弹出错误  
  69.     }  
  70.     cout<<endl;  
  71.     cout<<ve.front()<<endl;//one //返回第一个元素的引用  
  72.     cout<<ve.back()<<endl;//six //返回最后一个元素的引用   
  73. }  
  74. //迭代器；返回iterator，或reverse_iterator  
  75. void test3()  
  76. {   
  77.     vector<int>ve(4);  
  78.     ve[0]=0;ve[1]=1;ve[2]=2;ve[3]=3;  
  79.     cout<<ve[0]<<" "<<ve[1]<<" "<<ve[2]<<" "<<ve[3]<<endl;  
  80.     vector<int>::iterator iter;//定义一个迭代器iter  
  81.     iter=ve.begin();//返回一个iterator，它指向vector第一个元素  
  82.     cout<<*iter<<endl;//0  
  83.      iter=ve.end();//返回一个iterator，它指向vector最末尾元素的下一个位置(它不是末尾元素)  
  84.      //cout<<*iter<<endl;//会出现错误  
  85.      cout<<*(iter-1)<<endl;//3 用此方法访问末尾元素  
  86.      vector<int>::reverse_iterator reIter;//定义一个反向的迭代器  
  87.      reIter=ve.rbegin();//返回一个方向iterator，它指向vector末尾元素  
  88.     cout<<*reIter<<endl;//3  
  89.     reIter=ve.rend();//返回一个方向iterator，它指向vector第一个元素之前的位置(它是不存在的)  
  90.     cout<<*(reIter-1)<<endl;//0  用此方法访问第一个元素  
  91. }   
  92. //取得、设置长度、容量；返回void或size_type  
  93. void test4()  
  94. {   
  95.     vector<string> ve(8);  
  96.     cout<<ve.size()<<endl;//8  
  97.     cout<<ve.max_size()<<endl;//134217727，10737441823  
  98.     cout<<ve.capacity()<<endl;//8  
  99.     cout<<ve.empty()<<endl;//0,说明不为空，因为默认值是0  
  100.   
  101.     ve.assign(12,"3");  
  102.     cout<<ve.size()<<endl;//12  
  103.     cout<<ve.max_size()<<endl;//134217727(string),10737441823(int)  
  104.     cout<<ve.capacity()<<endl;//12  
  105.     cout<<ve.empty()<<endl;//0   
  106.   
  107.     ve.assign(1,"003");  
  108.     cout<<ve.size()<<endl;//1  返回vector当前持有元素的个数  
  109.     cout<<ve.max_size()<<endl;//他的最大个数与数据类型有关  
  110.     cout<<ve.capacity()<<endl;//12 容量 取得vector目前可容纳的最大元素个数。这个方法与存储配置有关，它通常只会增加，不会因为元素被删除而随之减少  
  111.     cout<<ve.empty()<<endl;//0 为空时，返回true  
  112.   
  113.     ve.resize(15,"W");//改变vector目前持有元素的个数  
  114.     cout<<ve.size()<<endl;//15  
  115.     cout<<ve.max_size()<<endl;//134217727(string),10737441823(int)  
  116.     cout<<ve.capacity()<<endl;//18  
  117.     cout<<ve.empty()<<endl;//0   
  118.   
  119.     ve.reserve(5);//如有必要，可改变vector的容量大小(只会增加，减少不起作用)  
  120.     cout<<ve.size()<<endl;//15  
  121.     cout<<ve.max_size()<<endl;//134217727(string),10737441823(int)  
  122.     cout<<ve.capacity()<<endl;//18 当ve.reserve(35);则输出35；则说明容量capacity只会增加不会减少  
  123.     cout<<ve.empty()<<endl;//0   
  124.   
  125.     vector<int> v(2,4);  
  126.     vector<int>vec(5,9);  
  127.     vec.swap(v);//两个vector进行交换  
  128.     cout<<v.size()<<" "<<v[0]<<endl;//5 9  
  129.     cout<<vec.size()<<" "<<vec[0]<<endl;//2 4  
  130.   
  131. }   
  132. //遍历vector  
  133. void test5()  
  134. {   
  135.     vector<int> vec;  
  136.     for (int i=0;i<10;i++)  
  137.     {  
  138.         vec.push_back(i);  
  139.     }  
  140.     for (int i=0;i<vec.size();i++)   
  141.         cout<<vec[i]<<" ";  
  142.     cout<<endl;  
  143.   
  144.     vector<int>::iterator iter;  
  145.     for (iter=vec.begin();iter!=vec.end();iter++)  
  146.         cout<<*iter<<" ";  
  147.     cout<<endl;  
  148.   
  149.     vector<int>::reverse_iterator reIter;  
  150.     for (reIter=vec.rbegin();reIter!=vec.rend();reIter++)   
  151.         cout<<*reIter<<" ";//9 8 7 6 5 4 3 2 1 0  
  152.     cout<<endl;  
  153.   
  154.     vector<int>::reverse_iterator revIter;  
  155.     for (revIter=vec.rend()-1;revIter!=vec.rbegin();revIter--)   
  156.         cout<<*revIter<<" ";//0 1 2 3 4 5 6 7 8 //有点残缺  
  157.     cout<<endl;  
  158. }   
  159. void Test(char h)  
  160. {  
  161.     cout<<"press key===="<<h<<endl;  
  162.     switch(h)  
  163.     {   
  164.     case '0':  test0();break;  
  165.     case '1':  test1();break;  
  166.     case '2':  test2();break;  
  167.     case '3':  test3();break;  
  168.     case '4':  test4();break;  
  169.     case '5':  test5();break;    
  170.     case 27:  
  171.     case 'q':exit(0);break;   
  172.     default:cout<<"default "<<h<<endl;break;  
  173.     }  
  174. }  
  175. void main()  
  176. {  
  177.     while(1)  
  178.     {  
  179.         Test(getch());  
  180.     }   
  181. }  

list网上实例

 

list的函数共有五大类：定义及初始化，增加删除元素，访问元素，返回迭代器，其他

[cpp] view plain copy print ?
  1. #include <string>  
  2. #include <vector>   
  3. #include <list>  
  4. #include <conio.h>  
  5. #include<iostream>  
  6. using namespace std;    
  7. void PrintListInt(list<int>& param)  
  8. {  
  9.     for (list<int>::iterator iter=param.begin();iter!=param.end();iter++)  
  10.     {  
  11.         cout<<*iter<<" ";  
  12.     }  
  13.     cout<<endl;      
  14. }  
  15. void PrintListString(list<string>& param)  
  16. {  
  17.     for (list<string>::iterator iter=param.begin();iter!=param.end();iter++)  
  18.     {  
  19.         cout<<*iter<<" ";  
  20.     }  
  21.     cout<<endl;      
  22. }  
  23. //定义及初始化；没有返回值，或void  
  24. void test0()  
  25. {   
  26.     list<int> first(4);//定义并初始化4个0  
  27.     PrintListInt(first);//0 0 0 0  
  28.     list<int> second(3,88);//定义并初始化3个88  
  29.     PrintListInt(second);//88 88 88   
  30.     first.assign(4,90);//assign赋值  //4个90  
  31.     second.assign(first.begin(),first.end());//second拷贝first  
  32.     int arr[]={23,45,56};  
  33.     second.assign(arr,arr+2);  
  34.     PrintListInt(second);//23 45 (没有56，者说明assign赋值是[begin,end),而不是[begin,end])  
  35.     second.assign(0,0);//清空second  
  36.     PrintListInt(second);//为空    
  37. }  
  38. //增加删除元素；返回值是void,除erase()的返回值是iterator外  
  39. void test1()  
  40. {   
  41.     list<int> first(3,8);  
  42.     first.push_back(6);//增加一个元素在list末端  
  43.     first.push_front(2);//增加一个元素在list前端  
  44.     PrintListInt(first);//2 8 8 8 6  
  45.     first.pop_back();//删除list末端元素  
  46.     first.pop_front();//删除list前端元素  
  47.     PrintListInt(first);//8 8 8   
  48.     first.insert(first.begin(),5);//在前端添加一个元素,不可以first.begin()+1;但vector<int>ve(4);ve.insert(ve.begin()+1,4);却可以  
  49.     first.insert(first.end(),2,9);//在末端添加两个元素，同上，end()-2不可以，但vector的end()-2可以  
  50.     PrintListInt(first);//5 8 8 8 9 9  
  51.     list<int>second;  
  52.     second.insert(second.end(),first.begin(),first.end());//second赋值first  
  53.     PrintListInt(second);//5 8 8 8 9 9  
  54.   
  55.     second.erase(second.begin());//删除前端元素，参数不能为second.begin()+1,当然也不能为second.end();若要删除第二个元素，则可通过++second.begin(),或iterator，然后iterator++  
  56.     PrintListInt(second);//8 8 8 9 9   
  57.     second.erase(second.begin(),second.end());//全部删除  
  58.     PrintListInt(second);//为空  
  59.   
  60.     first.remove(77);//删除77这个不存在的元素   
  61.     PrintListInt(first);//5 8 8 8 9 9  
  62.     first.remove(8);//删除所有的8这个元素  
  63.     PrintListInt(first);//5 9 9  
  64.     if (!first.empty())   
  65.         first.clear();//全部清除  
  66.     PrintListInt(first);//为空   
  67.     //在list的函数insert(),erase()的函数参数时（iterator+2）是不可以的，只可以通过不停地iterator++；这一点与vector的insert(),erase()不同，可以通过iterator+2来很方便的删除任意位置的元素。因为它们存储的内存地址不一定连续的，所以不能通过iterator+、-N来访问第N个元素，只能通过iterator++来逐一访问,甚至量iterator=iterator+1都不行  
  68.     //由于list是双向链表，所以比线性表vector多提供了增加删除元素的函数，push_front(),pop_front(),remove(),remove_if()  
  69. }  
  70. //访问获取元素；返回值是Type T  
  71. void test2()  
  72. {   
  73.     list<int> first;  
  74.     for(int i=0;i<5;i++)  
  75.         first.push_back(i);  
  76.      cout<<first.front()<<endl;//0 返回前端元素的引用  
  77.      cout<<first.back()<<endl;//4 返回末端元素的引用  
  78.     //由于list是双向链表，所有没有像线性表vector那样提供下标索引，at()来提供方便的数据访问函数  
  79. }  
  80. //返回迭代器；返回值是iterator，或reverse_iterator  
  81. void test3()  
  82. {   
  83.     list<int> first;  
  84.     for(int i=0;i<5;i++)  
  85.         first.push_back(i);   
  86.      cout<<*first.begin()<<endl;//0 不可以 cout<<*first.end()<<endl;不然会崩溃  
  87.      cout<<*first.rbegin()<<endl;//4 不可以cout<<*first.rend()<<endl;不然会崩溃  
  88.      for(list<int>::iterator it=first.begin();it!=first.end();it++)  
  89.          cout<<*it<<" ";//0 1 2 3 4  
  90.      cout<<endl;  
  91.      list<int>::reverse_iterator reIt=first.rbegin();  
  92.      while(reIt!=first.rend())  
  93.      {  
  94.          cout<<*reIt<<" ";//4 3 2 1 0  
  95.          reIt++;//记住是++，因为他是rbegin中的begin  
  96.      }  
  97.      cout<<endl;  
  98.      //与vector提供的函数相同begin(),end(),rbegin(),rend();不同的iterator不可以+N  
  99. }   
  100. //其他  
  101. void test4()  
  102. {   
  103.     list<string> ve(2);  
  104.     cout<<ve.size()<<endl;//2   
  105.     cout<<ve.max_size()<<endl;//134217727(string),10737441823(int)  
  106.     ve.resize(7);  
  107.     cout<<ve.size()<<endl;//7   
  108.     //与vector不同的是少了capacity(),reserve()获取容量，设置容量  
  109.   
  110.     list<int> first;  
  111.     for(int i=0;i<5;i++)  
  112.         first.push_back(i);   
  113.     first.reverse();//逆序  
  114.     PrintListInt(first);//4 3 2 1 0  
  115.     list<int>second(2,9);  
  116.     second.swap(first);//两个list之间交互数据  
  117.     PrintListInt(first);//9 9  
  118.     PrintListInt(second);// 4 3 2 1 0  
  119.     first.sort();  
  120.     second.sort();//排序(从小到大)  
  121.     PrintListInt(second);//0 1 2 3 4  
  122.     first.merge(second);//second合并到first中，之后second为空。这里需要注意的是：在调用合并函数merge()之前，first和second都必须是从小到大的排序的  
  123.     PrintListInt(first);//0 1 2 3 4 9 9  
  124.     PrintListInt(second);//为空  
  125.     first.unique();//使唯一，删除相同的数据  
  126.     PrintListInt(first);//0 1 2 3 4 9  
  127.     //比vector多提供了逆序reverse(),排序sort(),和并merge()，使唯一unique()等数据处理的函数  
  128.   
  129.     list<int> one,two;  
  130.     for(int i=0;i<4;i++)  
  131.     {  
  132.         one.push_back(i*5);//0 5 10 15  
  133.         two.push_back(i*10);//0 10 20 30   
  134.     }  
  135.     one.splice(one.begin(),two);//在begin位置拼接整个two列表元素  
  136.     PrintListInt(one);//0 10 20 30 0 5 10 15  
  137.     PrintListInt(two);//为空  
  138.     two.assign(3,2);  
  139.     one.splice(one.begin(),two,two.begin());//在one列表的前端拼接two列表的一个前端元素  
  140.     PrintListInt(one);//2 0 10 20 30 0 5 10 15  
  141.     PrintListInt(two);//2 2  
  142.     one.splice(one.end(),two,two.begin(),two.end());//在one列表的end位置拼接整个two列表元素  
  143.     PrintListInt(two);//2 0 10 20 30 0 5 10 15 2 2  
  144.     PrintListInt(one);//为空  
  145. }   
  146. //遍历list  
  147. void test5()  
  148. {   
  149.     list<int> vec;  
  150.     for (int i=0;i<10;i++)  
  151.     {  
  152.         vec.push_back(i);  
  153.     }   
  154.   
  155.     list<int>::iterator iter;  
  156.     for (iter=vec.begin();iter!=vec.end();iter++)  
  157.         cout<<*iter<<" ";  
  158.     cout<<endl;  
  159.   
  160.     list<int>::reverse_iterator reIter;  
  161.     for (reIter=vec.rbegin();reIter!=vec.rend();reIter++)   
  162.         cout<<*reIter<<" ";//9 8 7 6 5 4 3 2 1 0  
  163.     cout<<endl;  
  164.   
  165.     vec.reverse();  
  166.     list<int>::reverse_iterator reveIter=vec.rbegin();  
  167.     while(reveIter!=vec.rend())  
  168.     {  
  169.         cout<<*reveIter<<" ";//0 1 2 3 4 5 6 7 8 9  
  170.         reveIter++;  
  171.     }  
  172.     cout<<endl;      
  173. }   
  174. void Test(char h)  
  175. {  
  176.     cout<<"press key===="<<h<<endl;  
  177.     switch(h)  
  178.     {   
  179.     case '0':  test0();break;  
  180.     case '1':  test1();break;  
  181.     case '2':  test2();break;  
  182.     case '3':  test3();break;  
  183.     case '4':  test4();break;  
  184.     case '5':  test5();break;   
  185.     case 27:  
  186.     case 'q':exit(0);break;   
  187.     default:cout<<"default "<<h<<endl;break;  
  188.     }  
  189. }  
  190. void main()  
  191. {  
  192.     while(1)  
  193.     {  
  194.         Test(getch());  
  195.     }   
  196. }</int>  

deque   上网实例

list的函数共有五大类：定义及初始化，增加删除元素，访问元素，返回迭代器，其他

 

[cpp] view plain copy print ?
  1. #include <string>  
  2. #include <deque>  
  3. #include <conio.h>  
  4. #include<iostream>  
  5. using namespace std;    
  6. //定义及初始化；无返回值或void  
  7. void PrintDequeInt(deque<int> param)  
  8. {  
  9.     for (deque<int>::iterator iter=param.begin();iter!=param.end();iter++)  
  10.     {  
  11.         cout<<*iter<<" ";  
  12.     }  
  13.     cout<<endl;     
  14. }  
  15. void PrintDequeString(deque<string> param)  
  16. {  
  17.     for (deque<string>::iterator iter=param.begin();iter!=param.end();iter++)  
  18.     {  
  19.         cout<<*iter<<" ";  
  20.     }  
  21.     cout<<endl;     
  22. }  
  23. void test0()  
  24. {    
  25.     deque<int> d;//创建一个空的deque  
  26.     deque<int> de(2);//创建一个deque，含有2个缺省默认的数据0  
  27.     deque<int> deq(3,5);//创建一个含有3个5拷贝的deque  
  28.     deque<int> dequ(deq);//复制一个deque  
  29.     deque<int> first(dequ.begin(),dequ.end());//创建一个以[beg,end)区间的deque  
  30.     PrintDequeInt(first);//5 5 5  
  31.     d.assign(2,7);  
  32.     PrintDequeInt(d);//7 7  
  33.     de.assign(deq.begin(),deq.end());  
  34.     PrintDequeInt(de);//5 5 5  
  35.     //deque,list,vector的完全相同  
  36. }  
  37. //增加删除元素；返回值为void,除erase()的返回值为iterator外  
  38. void test1()  
  39. {    
  40.     deque<string> first(2);//创建一个deque，含有2个缺省默认的数据" "  
  41.     cout<<first.at(0)<<" "<<first.at(1)<<" "<<endl;  
  42.     first.push_back("world");//在尾部加入一个数据  
  43.     first.push_front("hello ");//在头部插入一个数据  
  44.     first.pop_back();//删除最后一个数据  
  45.     first.pop_front();//删除头部数据  
  46.        
  47.     first.assign(1,"women");  
  48.     PrintDequeString(first);  
  49.     first.insert(first.begin()+1,"nihao");//在pos位置插入一个“nihao”；返回新数据的位置；注意pos位置要存在，eg:此begin()+2就不行，因为它表示第3个位置  
  50.     PrintDequeString(first); //women nihao  
  51.     first.insert(first.end(),2,"W");//注意他返回的是void  
  52.     PrintDequeString(first);//women nihao W W  
  53.     //first.insert(first.end(),first.begin(),first.end()); 不可以，当vector却可以   
  54.   
  55.     first.erase(first.begin());//删除pos位置的数据，返回下一个数据的位置  
  56.     PrintDequeString(first);//nihao W W  
  57.     first.erase(first.begin(),first.begin()+2);//删除[beg,end)区间的数据；放回下一个数据的位置  
  58.     PrintDequeString(first);//W  
  59.     first.clear();//删除容器中所有的的数据，可以用empty()来判断是否删除完  
  60.     //比vector多提供了pop_front()和push_front(),其他的完全相同  
  61.     //与list提供的函数完全相同，不过list的参数first.begin()不可以+1，+2，而deque却可以  
  62. }  
  63. //访问获取元素；返回值为TYPE T  
  64. void test2()  
  65. {    
  66.     string str[]={"one","two","three","four","five","six"};  
  67.     deque<string> ve(str,str+6);   
  68.     for(int i=0;i<6;i++)   
  69.     {   
  70.         cout<<ve.at(i)<<" ";//使用at()通过i来进行访问，也不能越界。若越界，在调试时，会抛出异常；在运行时直接弹出错误  
  71.     }  
  72.     cout<<endl;  
  73.     cout<<ve.front()<<endl;//one //返回第一个元素的引用  
  74.     cout<<ve.back()<<endl;//six //返回最后一个元素的引用   
  75.     //与vector完全相同，也提供了at()  
  76.     //比list多提供了一个访问元素的函数at()  
  77. }  
  78. //返回迭代器；返回值为iterator或reverse_iterator  
  79. void test3()  
  80. {    
  81.     deque<int>ve(4);  
  82.     ve[0]=0;ve[1]=1;ve[2]=2;ve[3]=3;  
  83.     cout<<ve[0]<<" "<<ve[1]<<" "<<ve[2]<<" "<<ve[3]<<endl;  
  84.     deque<int>::iterator iter;//定义一个迭代器iter  
  85.     iter=ve.begin();//返回一个iterator，它指向deque第一个元素  
  86.     cout<<*iter<<endl;//0  
  87.     iter=ve.end();//返回一个iterator，它指向deque最末尾元素的下一个位置(它不是末尾元素)  
  88.     //cout<<*iter<<endl;//会出现错误  
  89.     cout<<*(iter-1)<<endl;//3 用此方法访问末尾元素  
  90.     deque<int>::reverse_iterator reIter;//定义一个反向的迭代器  
  91.     reIter=ve.rbegin();//返回一个方向iterator，它指向deque末尾元素  
  92.     cout<<*reIter<<endl;//3  
  93.     reIter=ve.rend();//返回一个方向iterator，它指向deque第一个元素之前的位置(它是不存在的)  
  94.     cout<<*(reIter-1)<<endl;//0  用此方法访问第一个元素  
  95.     //与vector提供的函数与用法完全相同  
  96.     //与list提供的函数相同，用法略有不同：list的iterator不可以加减n；deque却可以  
  97. }   
  98. //其他  
  99. void test4()  
  100. {    
  101.     deque<string> ve(8,"ss");  
  102.     cout<<ve.size()<<endl;//8  
  103.     cout<<ve.max_size()<<endl;//134217727，10737441823   
  104.     ve.resize(2);//重置长度2    cout<<ve[2]<<endl;//会有问题因为[2]不存在      
  105.     deque<string> de(4,"hh");  
  106.     de.swap(ve);//将de与ve元素互换  
  107.     cout<<ve.size()<<" "<<ve.front()<<endl;//4 hh  
  108.     cout<<de.size()<<" "<<de.front()<<endl;//2 ss  
  109.     //比vector少了获得容量函数capacity(),设置容量函数reserve()  
  110.     //比list少了sort(),merge(),remove(),remove_if(),reverse(),splice(),unique()  
  111. }   
  112. //遍历deque  
  113. void test5()  
  114. {    
  115.     deque<int> vec;  
  116.     for (int i=0;i<10;i++)  
  117.     {  
  118.         vec.push_back(i);  
  119.     }  
  120.     for (int i=0;i<vec.size();i++)   
  121.         cout<<vec[i]<<" ";  
  122.     cout<<endl;  
  123.   
  124.     deque<int>::iterator iter;  
  125.     for (iter=vec.begin();iter!=vec.end();iter++)  
  126.         cout<<*iter<<" ";  
  127.     cout<<endl;  
  128.   
  129.     deque<int>::reverse_iterator reIter;  
  130.     for (reIter=vec.rbegin();reIter!=vec.rend();reIter++)   
  131.         cout<<*reIter<<" ";//9 8 7 6 5 4 3 2 1 0  
  132.     cout<<endl;  
  133.   
  134.     deque<int>::reverse_iterator revIter;  
  135.     for (revIter=vec.rend()-1;revIter!=vec.rbegin();revIter--)   
  136.         cout<<*revIter<<" ";//0 1 2 3 4 5 6 7 8 //有点残缺  
  137.     cout<<endl;  
  138. }   
  139. void Test(char h)  
  140. {  
  141.     cout<<"press key===="<<h<<endl;  
  142.     switch(h)  
  143.     {   
  144.     case '0':  test0();break;  
  145.     case '1':  test1();break;  
  146.     case '2':  test2();break;  
  147.     case '3':  test3();break;  
  148.     case '4':  test4();break;  
  149.     case '5':  test5();break;   
  150.     case 27:  
  151.     case 'q':exit(0);break;   
  152.     default:cout<<"default "<<h<<endl;break;  
  153.     }  
  154. }  
  155. void main()  
  156. {  
  157.     while(1)  
  158.     {  
  159.         Test(getch());  
  160.     }   
  161. } 

栈、队列、优先队列

栈stack    网上实例

队列queue    网上实例

优先队列priority_queue   网上实例

[cpp] view plain copy print ?
  1. #include <string>  
  2. #include <stack>  
  3. #include <queue>   
  4. #include <conio.h>  
  5. #include<iostream>  
  6. using namespace std;     
  7. //栈stack的用法  
  8. void test0()  
  9. {  
  10.     stack<int> st;   
  11.     for (int i=0;i<4;i++)  
  12.         st.push(i*10); //压栈  
  13.     cout<<st.top()<<" "<<st.size()<<endl; //30 4  
  14.     for (int i=0;i<4;i++)   
  15.     {  
  16.         cout<<st.top()<<" ";//30 20 10 0  
  17.         st.pop();//出栈  
  18.     }  
  19.     cout<<endl<<st.size()<<" "<<st.empty()<<endl;//0 1  
  20.   
  21.     stack<int> first,scond;  
  22.     for (int i=0;i<5;i++)  
  23.     {  
  24.         first.push(i*5);  
  25.         scond.push(i*2);  
  26.     }  
  27.     first.swap(scond);//将栈first与scond元素互换  
  28.     first.emplace(444); //安放 它与push()的功能相同  
  29.     scond.emplace(852);  
  30.   
  31.     while (!first.empty())  
  32.     {  
  33.         cout<<first.top()<<" ";//444 8 6 4 2 0  
  34.         first.pop();  
  35.     }  
  36.     cout<<endl;  
  37.     while (!scond.empty())  
  38.     {  
  39.         cout<<scond.top()<<" ";//852 20 15 10 5 0  
  40.         scond.pop();  
  41.     }  
  42.     cout<<endl;      
  43.     //栈stack，提供访问数据的接口只有一个top();而vector，list，deque则提供访问数的接口有：iterator，front(),back()；queue则提供的是back(),front(),没有iterator  
  44. }  
  45. //队列queue的用法  
  46. void test1()  
  47. {  
  48.     queue<int> q;  
  49.     for(int i=0;i<5;i++)  
  50.         q.push(i);//在队尾增加元素  
  51.     //返回元素数目，返回队头元素，返回队尾元素，是否为空  
  52.     cout<<q.size()<<" "<<q.front()<<" "<<q.back()<<" "<<q.empty()<<endl;//5 0 4 0  
  53.     q.pop();//删除队头元素  
  54.     cout<<q.front()<<" "<<q.back()<<endl;//1 4   
  55.   
  56.     queue<int> first,scond;  
  57.     for (int i=0;i<5;i++)  
  58.     {  
  59.         first.push(i*5);  
  60.         scond.push(i*2);  
  61.     }  
  62.     first.swap(scond);//将队列first与scond元素互换  
  63.     first.emplace(444); //安放 它与push()的功能相同  
  64.     scond.emplace(852);  
  65.   
  66.     while (!first.empty())  
  67.     {  
  68.         cout<<first.front()<<" ";//0 2 4 6 8 444  
  69.         first.pop();  
  70.     }  
  71.     cout<<endl;  
  72.     while (!scond.empty())  
  73.     {  
  74.         cout<<scond.front()<<" ";//0 5 10 15 20 852  
  75.         scond.pop();  
  76.     }  
  77.     cout<<endl;  
  78. }  
  79. //优先队列priorityQueue的用法；插入的数据(按照某种顺序)自动排序  
  80. void test2()  
  81. {  
  82.     priority_queue<int>pq;  
  83.     pq.push(34);  
  84.     pq.push(21);  
  85.     pq.push(45);  
  86.     pq.push(9);  
  87.     //返回元素数目，返回队头元素，返回队尾元素，是否为空  
  88.     cout<<pq.size()<<" "<<pq.top()<<" "<<pq.empty()<<endl;//4 45 0  
  89.     while(!pq.empty())  
  90.     {  
  91.         cout<<pq.top()<<" ";//45 34 21 9  
  92.         pq.pop();  
  93.     }  
  94.     cout<<endl;   
  95.     priority_queue<int> first,scond;  
  96.     for (int i=0;i<5;i++)  
  97.     {  
  98.         first.push(i*5);  
  99.         scond.push(i*2);  
  100.     }  
  101.     first.swap(scond);//将优先队列first与scond元素互换  
  102.     first.emplace(444); //安放 它与push()的功能相同  
  103.     scond.emplace(852);  
  104.   
  105.     while (!first.empty())  
  106.     {  
  107.         cout<<first.top()<<" ";//444 8 6 4 2 0  
  108.         first.pop();  
  109.     }  
  110.     cout<<endl;  
  111.     while (!scond.empty())  
  112.     {  
  113.         cout<<scond.top()<<" ";//852 20 15 10 5 0  
  114.         scond.pop();  
  115.     }  
  116.     cout<<endl;  
  117. }  
  118. void Test(char h)  
  119. {  
  120.     cout<<"press key===="<<h<<endl;  
  121.     switch(h)  
  122.     {   
  123.     case '0':  test0();break;  
  124.     case '1':  test1();break;  
  125.     case '2':  test2();break;   
  126.     case 27:  
  127.     case 'q':exit(0);break;   
  128.     default:cout<<"default "<<h<<endl;break;  
  129.     }  
  130. }  
  131. void main()  
  132. {  
  133.     while(1)  
  134.     {  
  135.         Test(getch());  
  136.     }   
  137. }  

 

容器适配器

容器适配器：是用基本的容器改造出的容器。共有的成员函数：empty(),size(),push(),pop(),(front(),back()/top()),swap(),emplace()
栈stack：是先进后出(FILO)的数据结构，可用vector，list，deque来实现，默认用deque实现。只能插入push()，删除pop()，访问栈顶元素top()
队列queue：是先进先出(FIFO)的数据结构，可用list，deque来实现，默认用deque实现。也提供了push(),pop()但是push()发生在队尾，pop()发生在队头。与stack不同的是top()变成了(front(),back())返回队头元素front(),返回队尾元素back(),
优先队列priority_queue：可用vector，deque实现，默认用vector实现。插入到容器中的元素自动排序(从大到小)，这些元素是有优先级的，大的在前小的在后，与queue不同的是由front(),back()变成一个top()


你可能感兴趣的:(C++STL基础)

  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 从0到500+，我是如何利用自媒体赚钱？ 一列脚印
    运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • 大伟说成语之唉声叹气 求索大伟
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • MongoDB Oplog 窗口 喝醉酒的小白 MongoDB运维
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • 高级 ECharts 技巧：自定义图表主题与样式 SnowMan1993 echarts信息可视化数据分析
    ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
  • 01-Git初识 Meereen Gitgit
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • Rust基础知识 GRKF15 rust开发语言后端
    1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • ExpRe[25] bash外的其它shell：zsh和fish tritone ExpRebashlinuxubuntushell
    文章目录zsh基础配置实用特性插件`autojump`语法高亮自动补全fish优点缺点时效性本篇撰写时间为2021.12.15，由于计算机技术日新月异，博客中所有内容都有时效和版本限制，具体做法不一定总行得通，链接可能改动失效，各种软件的用法可能有修改。但是其中透露的思想往往是值得学习的。本篇前置：ExpRe[10]Ubuntu[2]准备神秘软件、备份恢复软件https://www.cnblogs
  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • 2021-01-24 9ce517ee104c
    【打卡素材】《香帅金融学讲义》【标题】公司治理：怎样同床异梦地过下去【日期】2021.1.24【字数】公司本质上是一连串的合约关系。降低合同执行中的各种摩擦是公司正常有效运行的基础。协同各方的利益、制衡各方的权力是关键。为解决利益冲突问题、协同各方利益，进行权力制衡的机制设计就是公司治理机制。001什么是公司治理治理是管理的基础，治理机制越好，权、责、利就越清晰，管理的目标也就会更容易实现。002
  • 如何在心上用功？ 余超林AIA财富管家
    思考：如何在心上用功？学习心得：心-道-德-事的理解心-道-德-事这四部曲，本质上就是一个人的思维智慧的四个层面：事是最底层，这是所有人在这个社会谋求生存的基础，一个人能够把事情彻底做好，保质保量的完成，才会有真正的结果，但是这个层面要获得真正成功很困难，因为会做事的人很多，最终会出现恶性竞争；德是第三层，如果说整个社会做事的竞争激烈程度为100%，那么上升到德上的竞争激烈程度降低为80%，德是一
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • 第二十 python基础--语句 九樱MOL
    目录具体内容1：if语句的使用格式判断语句2：if-else的使用格式3：if-elif-else的使用格式4：if嵌套1：while循环的格式循环语句2：while循环嵌套3：for循环的格式一、判断语句在程序中如果某些条件满足，才能做某件事情，而不满足时不允许做，这就是所谓的判断1.1if语句的使用格式if要判断的条件:条件成立时，要做的事情案例:判断年纪，如果age大于18，输入成年age=
  • (179)时序收敛---＞(29)时序收敛二九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛二九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • (180)时序收敛---＞(30)时序收敛三十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • (158)时序收敛---＞(08)时序收敛八 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛八（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (159)时序收敛---＞(09)时序收敛九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • Js函数返回值 _wy_ jsreturn
    一、返回控制与函数结果，语法为：return 表达式;作用: 结束函数执行，返回调用函数，而且把表达式的值作为函数的结果 二、返回控制语法为：return;作用: 结束函数执行，返回调用函数，而且把undefined作为函数的结果 在大多数情况下,为事件处理函数返回false,可以防止默认的事件行为.例如,默认情况下点击一个<a>元素,页面会跳转到该元素href属性
  • MySQL 的 char 与 varchar bylijinnan mysql
    今天发现，create table 时，MySQL 4.1有时会把 char 自动转换成 varchar 测试举例： CREATE TABLE `varcharLessThan4` ( `lastName` varchar(3) ) ; mysql> desc varcharLessThan4; +----------+---------+------+-
  • Quartz——TriggerListener和JobListener eksliang TriggerListenerJobListenerquartz
    转载请出自出处：http://eksliang.iteye.com/blog/2208624 一.概述 listener是一个监听器对象，用于监听scheduler中发生的事件，然后执行相应的操作；你可能已经猜到了，TriggerListeners接受与trigger相关的事件，JobListeners接受与jobs相关的事件。   二.JobListener监听器  j
  • oracle层次查询 18289753290 oracle；层次查询；树查询
    .oracle层次查询(connect  by) oracle的emp表中包含了一列mgr指出谁是雇员的经理，由于经理也是雇员，所以经理的信息也存储在emp表中。这样emp表就是一个自引用表，表中的mgr列是一个自引用列，它指向emp表中的empno列，mgr表示一个员工的管理者， select   empno,mgr,ename,sal  from e
  • 通过反射把map中的属性赋值到实体类bean对象中 酷的飞上天空 javaee泛型类型转换
    使用过struts2后感觉最方便的就是这个框架能自动把表单的参数赋值到action里面的对象中 但现在主要使用Spring框架的MVC，虽然也有@ModelAttribute可以使用但是明显感觉不方便。 好吧，那就自己再造一个轮子吧。 原理都知道，就是利用反射进行字段的赋值，下面贴代码 主要类如下：   import java.lang.reflect.Field; imp
  • SAP HANA数据存储：传统硬盘的瓶颈问题 蓝儿唯美 HANA
    SAPHANA平台有各种各样的应用场景，这也意味着客户的实施方法有许多种选择，关键是如何挑选最适合他们需求的实施方案。 在 《Implementing SAP HANA》这本书中，介绍了SAP平台在现实场景中的运作原理，并给出了实施建议和成功案例供参考。本系列文章节选自《Implementing SAP HANA》，介绍了行存储和列存储的各自特点，以及SAP HANA的数据存储方式如何提升空间压
  • Java Socket 多线程实现文件传输 随便小屋 javasocket
            高级操作系统作业，让用Socket实现文件传输，有些代码也是在网上找的，写的不好，如果大家能用就用上。 客户端类：   package edu.logic.client; import java.io.BufferedInputStream; import java.io.Buffered
  • java初学者路径 aijuans java
    学习Java有没有什么捷径?要想学好Java，首先要知道Java的大致分类。自从Sun推出Java以来，就力图使之无所不包，所以Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE,这也就是Sun ONE(Open Net Environment)体系。J2SE就是Java2的标准版，主要用于桌面应用软件的编程；J2ME主要应用于嵌入是系统开发，如手机和PDA的编程；J2EE
  • APP推广 aoyouzi APP推广
    一，免费篇 1，APP推荐类网站自主推荐 最美应用、酷安网、DEMO8、木蚂蚁发现频道等,如果产品独特新颖，还能获取最美应用的评测推荐。PS：推荐简单。只要产品有趣好玩，用户会自主分享传播。例如足迹APP在最美应用推荐一次，几天用户暴增将服务器击垮。 2，各大应用商店首发合作 老实盯着排期，多给应用市场官方负责人献殷勤。 3，论坛贴吧推广 百度知道，百度贴吧，猫扑论坛，天涯社区，豆瓣（
  • JSP转发与重定向 百合不是茶 jspservletJava Webjsp转发
      在servlet和jsp中我们经常需要请求,这时就需要用到转发和重定向;   转发包括;forward和include     例子;forwrad转发;  将请求装法给reg.html页面   关键代码;    req.getRequestDispatcher("reg.html
  • web.xml之jsp-config bijian1013 javaweb.xmlservletjsp-config
    1.作用：主要用于设定JSP页面的相关配置。 2.常见定义： <jsp-config> <taglib> <taglib-uri>URI(定义TLD文件的URI,JSP页面的tablib命令可以经由此URI获取到TLD文件)</tablib-uri> <taglib-location> TLD文件所在的位置
  • JSF2.2 ViewScoped Using CDI sunjing CDIJSF 2.2ViewScoped
    JSF 2.0 introduced annotation @ViewScoped; A bean annotated with this scope maintained its state as long as the user stays on the same view(reloads or navigation - no intervening views). One problem w
  • 【分布式数据一致性二】Zookeeper数据读写一致性 bit1129 zookeeper
    很多文档说Zookeeper是强一致性保证，事实不然。关于一致性模型请参考http://bit1129.iteye.com/blog/2155336    Zookeeper的数据同步协议 Zookeeper采用称为Quorum Based Protocol的数据同步协议。假如Zookeeper集群有N台Zookeeper服务器(N通常取奇数，3台能够满足数据可靠性同时
  • Java开发笔记 白糖_ java开发
    1、Map<key,value>的remove方法只能识别相同类型的key值   Map<Integer,String> map = new HashMap<Integer,String>(); map.put(1,"a"); map.put(2,"b"); map.put(3,"c"
  • 图片黑色阴影 bozch 图片
     .event{ padding:0;    width:460px;    min-width: 460px;    border:0px solid #e4e4e4;    height: 350px;    min-heig
  • 编程之美-饮料供货-动态规划 bylijinnan 动态规划
    import java.util.Arrays; import java.util.Random; public class BeverageSupply { /** * 编程之美 饮料供货 * 设Opt（V’，i）表示从i到n-1种饮料中，总容量为V’的方案中，满意度之和的最大值。 * 那么递归式就应该是：Opt（V’，i）=max{ k * Hi+Op
  • ajax大参数（大数据）提交性能分析 chenbowen00 WebAjax框架浏览器prototype
    近期在项目中发现如下一个问题 项目中有个提交现场事件的功能，该功能主要是在web客户端保存现场数据（主要有截屏，终端日志等信息）然后提交到服务器上方便我们分析定位问题。客户在使用该功能的过程中反应点击提交后反应很慢，大概要等10到20秒的时间浏览器才能操作，期间页面不响应事件。 根据客户描述分析了下的代码流程，很简单，主要通过OCX控件截屏，在将前端的日志等文件使用OCX控件打包，在将之转换为
  • [宇宙与天文]在太空采矿,在太空建造 comsci
         我们在太空进行工业活动...但是不太可能把太空工业产品又运回到地面上进行加工,而一般是在哪里开采,就在哪里加工,太空的微重力环境,可能会使我们的工业产品的制造尺度非常巨大....      地球上制造的最大工业机器是超级油轮和航空母舰,再大些就会遇到困难了,但是在空间船坞中,制造的最大工业机器,可能就没
  • ORACLE中CONSTRAINT的四对属性 daizj oracleCONSTRAINT
    ORACLE中CONSTRAINT的四对属性 summary:在data migrate时,某些表的约束总是困扰着我们,让我们的migratet举步维艰,如何利用约束本身的属性来处理这些问题呢?本文详细介绍了约束的四对属性: Deferrable/not deferrable, Deferred/immediate, enalbe/disable, validate/novalidate,以及如
  • Gradle入门教程 dengkane gradle
    一、寻找gradle的历程 一开始的时候，我们只有一个工程，所有要用到的jar包都放到工程目录下面，时间长了，工程越来越大，使用到的jar包也越来越多，难以理解jar之间的依赖关系。再后来我们把旧的工程拆分到不同的工程里，靠ide来管理工程之间的依赖关系，各工程下的jar包依赖是杂乱的。一段时间后，我们发现用ide来管理项程很不方便，比如不方便脱离ide自动构建，于是我们写自己的ant脚本。再后
  • C语言简单循环示例 dcj3sjt126com c
    # include <stdio.h> int main(void) { int i; int count = 0; int sum = 0; float avg; for (i=1; i<=100; i++) { if (i%2==0) { count++; sum += i; } } avg
  • presentModalViewController 的动画效果 dcj3sjt126com controller
    系统自带(四种效果)： presentModalViewController模态的动画效果设置：     [cpp]  view plain copy   UIViewController *detailViewController = [[UIViewController al
  • java 二分查找 shuizhaosi888 二分查找java二分查找
    需求：在排好顺序的一串数字中，找到数字T   一般解法：从左到右扫描数据，其运行花费线性时间O(N)。然而这个算法并没有用到该表已经排序的事实。 /** * * @param array * 顺序数组 * @param t * 要查找对象 * @return */ public stati
  • Spring Security（07）——缓存UserDetails 234390216 ehcache缓存Spring Security
           Spring Security提供了一个实现了可以缓存UserDetails的UserDetailsService实现类，CachingUserDetailsService。该类的构造接收一个用于真正加载UserDetails的UserDetailsService实现类。当需要加载UserDetails时，其首先会从缓存中获取，如果缓存中没
  • Dozer 深层次复制 jayluns VOmavenpo
    最近在做项目上遇到了一些小问题，因为架构在做设计的时候web前段展示用到了vo层，而在后台进行与数据库层操作的时候用到的是Po层。这样在业务层返回vo到控制层，每一次都需要从po-->转化到vo层，用到BeanUtils.copyProperties(source, target)只能复制简单的属性，因为实体类都配置了hibernate那些关联关系，所以它满足不了现在的需求，但后发现还有个很
  • CSS规范整理（摘自懒人图库） a409435341 htmlUIcss浏览器
       刚没事闲着在网上瞎逛，找了一篇CSS规范整理，粗略看了一下后还蛮有一定的道理，并自问是否有这样的规范，这也是初入前端开发的人一个很好的规范吧。 一、文件规范 1、文件均归档至约定的目录中。 具体要求通过豆瓣的CSS规范进行讲解： 所有的CSS分为两大类：通用类和业务类。通用的CSS文件，放在如下目录中： 基本样式库 /css/core
  • C++动态链接库创建与使用 你不认识的休道人 C++dll
    一、创建动态链接库 1.新建工程test中选择”MFC [dll]”dll类型选择第二项"Regular DLL With MFC shared linked"，完成 2.在test.h中添加 extern “C” 返回类型 _declspec(dllexport)函数名(参数列表); 3.在test.cpp中最后写 extern “C” 返回类型 _decls
  • Android代码混淆之ProGuard rensanning ProGuard
    Android应用的Java代码，通过反编译apk文件（dex2jar、apktool）很容易得到源代码，所以在release版本的apk中一定要混淆一下一些关键的Java源码。 ProGuard是一个开源的Java代码混淆器（obfuscation）。ADT r8开始它被默认集成到了Android SDK中。 官网： http://proguard.sourceforge.net/
  • 程序员在编程中遇到的奇葩弱智问题 tomcat_oracle jquery编程ide
    　　现在收集一下：       　　排名不分先后，按照发言顺序来的。   1、Jquery插件一个通用函数一直报错，尤其是很明显是存在的函数，很有可能就是你没有引入jquery。。。或者版本不对 2、调试半天没变化：不在同一个文件中调试。这个很可怕，我们很多时候会备份好几个项目，改完发现改错了。有个群友说的好：   在汤匙
  • 解决maven-dependency-plugin (goals "copy-dependencies","unpack") is not supported xp9802 dependency
    解决办法：在plugins之前添加如下pluginManagement，二者前后顺序如下：   [html]  view plain copy   <build>           <pluginManagement
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他