YLC_慕类

C++ vector用法（详解！！函数，实现）

１，简述一下vector的基本操作，它的size，capacity（）clear，reverse，reserve，

　　push_back等！！！

２，说说，vector的存储特性，是顺序存储还是如同链表般，如果是顺序存储的话，那么是如何执行

　　ｅｒａｓｅ，ｉｎｓｅｒｔ等函数，？？？（假如后面的空间不够的话，我们需要合理的算法来重新找出一块

　　相应的空间吗？？？拷贝，回收吗？？？是不是特别麻烦），如果是链式存储的话，那么它又是如何做到快速

　　的访问的（通过下标来的）！！！

1 基本操作

(1)头文件#include.

(2)创建vector对象，vector vec;

(3)尾部插入数字：vec.push_back(a);

(4)使用下标访问元素，cout<

(5)使用迭代器访问元素.


 
   
   
   
   
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     "font-size:18px;">
     
       
       
       
       vector<
     
       
       
       
       int>::iterator it;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       for(it=vec.begin();it!=vec.end();it++)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
          
     
       
       
       
       cout<<*it<<
     
       
       
       
       endl;

(6)插入元素： vec.insert(vec.begin()+i,a);在第i个元素后面插入a;

(7)删除元素： vec.erase(vec.begin()+2);删除第3个元素

　　　　　　　 vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始

(8)向量大小:vec.size();

(9)清空:vec.clear()　　　//清空之后，vec.size()为０

一个简单的程序：


 
   
   
   
   
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     "font-size:18px;">#include
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     #include<
     
       
       
       
       vector>
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     #include
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       using 
     
       
       
       
       namespace 
     
       
       
       
       std;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       int main()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       int i=
     
       
       
       
       0;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       vector<
     
       
       
       
       int> vec;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       for(i=
     
       
       
       
       0; i<
     
       
       
       
       10; i++)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
                     vec.push_back(i);　　　
     
       
       
       
       //10个元素依次进入，结果为10
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       for(
     
       
       
       
       unsigned 
     
       
       
       
       int i=
     
       
       
       
       0; i
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       cout<<
     
       
       
       
       "初始化遍历："<endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       //结果为：０，１，２，３，４，５，６，７，８，９
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       vector<
     
       
       
       
       int>::iterator it;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       for(it = vec.begin(); it!=vec.end(); it++)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       cout<<
     
       
       
       
       "迭代遍历："<<*it<<
     
       
       
       
       endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     　　
     
       
       
       
       //结果为：０，１，２，３，４，５，６，７，８，９
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     　　 vec.insert(vec.begin()+
     
       
       
       
       4,
     
       
       
       
       0);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     　　
     
       
       
       
       //结果为:11
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       for(
     
       
       
       
       unsigned 
     
       
       
       
       int i=
     
       
       
       
       0; i
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       cout<<
     
       
       
       
       "插入遍历："<endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       //结果为：０，１，２，３，０，４，５，６，７，８，９
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             vec.erase(vec.begin()+
     
       
       
       
       2);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       for(
     
       
       
       
       unsigned 
     
       
       
       
       int i=
     
       
       
       
       0; i
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       cout<<
     
       
       
       
       "擦除遍历："<endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     　　
     
       
       
       
       //结果为：０，１，３，０，４，５，６，７，８，９
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             vec.erase(vec.begin()+
     
       
       
       
       3,vec.begin()+
     
       
       
       
       5);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     　　
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       for(
     
       
       
       
       vector<
     
       
       
       
       int>::iterator it = vec.begin(); it!=vec.end(); it++)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       cout<<
     
       
       
       
       "迭代遍历："<<*it<<
     
       
       
       
       endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       return 
     
       
       
       
       0;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     }

vector的元素不仅仅可以使int,double,string,还可以是结构体，但是要注意：结构体要定义为全局的，否则会出错。下面是一段简短的程序代码：


 
   
   
   
   
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     "font-size:18px;">#include
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     #include
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     #include<
     
       
       
       
       vector>
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     #include
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       using 
     
       
       
       
       namespace 
     
       
       
       
       std;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       typedef 
     
       
       
       
       struct rect
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
          
     
       
       
       
       int id;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
          
     
       
       
       
       int length;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
          
     
       
       
       
       int width;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     　　
     
       
       
       
       //对于向量元素是结构体的，可在结构体内部定义比较函数，下面按照id,length,width升序排序。
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     　　
     
       
       
       
       bool 
     
       
       
       
       operator< (
     
       
       
       
       const rect &a)  
     
       
       
       
       const
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       if(id!=a.id)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
                  
     
       
       
       
       return id
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       else
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
                  
     
       
       
       
       if(length!=a.length)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
                      
     
       
       
       
       return length
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
                  
     
       
       
       
       else
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
                      
     
       
       
       
       return width
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     }Rect;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       int main()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
          
     
       
       
       
       vector vec;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         Rect rect;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         rect.id=
     
       
       
       
       1;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         rect.length=
     
       
       
       
       2;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         rect.width=
     
       
       
       
       3;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         vec.push_back(rect);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
          
     
       
       
       
       vector::iterator it=vec.begin();
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
          
     
       
       
       
       cout<<(*it).id<<
     
       
       
       
       ' '<<(*it).length<<
     
       
       
       
       ' '<<(*it).width<<
     
       
       
       
       endl;    
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       return 
     
       
       
       
       0;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     }

3 算法

(1) 使用reverse将元素翻转：需要头文件#include

reverse(vec.begin(),vec.end());将元素翻转(在vector中，如果一个函数中需要两个迭代器，

一般后一个都不包含.)

(2)使用sort排序：需要头文件#include，

sort(vec.begin(),vec.end());(默认是按升序排列,即从小到大).

可以通过重写排序比较函数按照降序比较，如下：

定义排序比较函数：

bool Comp(const int &a,const int &b)
{
return a>b;
}
调用时:sort(vec.begin(),vec.end(),Comp)，这样就降序排序。

vector ： C++ STL中的顺序容器，封装数组

1. vector容器的内存自增长

与其他容器不同，其内存空间只会增长，不会减小。先来看看"C++ Primer"中怎么说：为了支持快速的随机访

问，vector容器的元素以连续方式存放，每一个元素都紧挨着前一个元素存储。设想一下，当vector添加一个元素时，

为了满足连续存放这个特性，都需要重新分配空间、拷贝元素、撤销旧空间，这样性能难以接受。因此STL实现者在对

vector进行内存分配时，其实际分配的容量要比当前所需的空间多一些。就是说，vector容器预留了一些额外的存储

区，用于存放新添加的元素，这样就不必为每个新元素重新分配整个容器的内存空间。

关于vector的内存空间，有两个函数需要注意：size()成员指当前拥有的元素个数；capacity()成员指当前(容器必须分

配新存储空间之前)可以存储的元素个数。reserve()成员可以用来控制容器的预留空间。vector另外一个特性在于它的

内存空间会自增长，每当vector容器不得不分配新的存储空间时，会以加倍当前容量的分配策略实现重新分配。例如，

当前capacity为50，当添加第51个元素时，预留空间不够用了，vector容器会重新分配大小为100的内存空间，作为新

连续存储的位置。


 
   
   
   
   
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     "font-size:18px;">#include 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       using 
     
       
       
       
       namespace 
     
       
       
       
       std;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       #include 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       int main()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       vector<
     
       
       
       
       int> arry;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       //arry.reserve(10);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       cout << arry.capacity() <<
     
       
       
       
       endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             arry.push_back(
     
       
       
       
       1);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       cout<endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             arry.push_back(
     
       
       
       
       2);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       cout<endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             arry.push_back(
     
       
       
       
       3);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       cout<endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     }

运行结果：

当我们将上面的那句注释去掉之后：

2. vector内存释放

由于vector的内存占用空间只增不减，比如你首先分配了10,000个字节，然后erase掉后面9,999个，留下一个有效元素，但是内存占

用仍为10,000个。所有内存空间是在vector析构时候才能被系统回收。empty()用来检测容器是否为空的，clear()可以清空所有元素。

但是即使clear()，vector所占用的内存空间依然如故，无法保证内存的回收。

如果需要空间动态缩小，可以考虑使用deque。如果非vector不可，可以用swap()来帮助你释放内存。具体方法如下：


 
   
   
   
   
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     "font-size:18px;">
     
       
       
       
       vector<
     
       
       
       
       int> nums; 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     nums.push_back(
     
       
       
       
       1);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     nums.push_back(
     
       
       
       
       1);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     nums.push_back(
     
       
       
       
       2);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     nums.push_back(
     
       
       
       
       2); 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       vector<
     
       
       
       
       int>().swap(nums); 
     
       
       
       
       //或者nums.swap(vector ())

或者如下所示，使用一对大括号，意思一样的：


 
   
   
   
   
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     "font-size:18px;">
     
       
       
       
       //加一对大括号是可以让tmp退出{}的时候自动析构
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     { 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
          
     
       
       
       
       std::
     
       
       
       
       vector<
     
       
       
       
       int> tmp =   nums;  
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         nums.swap(tmp); 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     }

swap()是交换函数，使vector离开其自身的作用域，从而强制释放vector所占的内存空间，总而言之，释放vector内存最简单的方法是vector.swap(nums)。当时如果nums是一个类的成员，不能把vector.swap(nums)写进类的析构函数中，否则会导致double free or corruption (fasttop)的错误，原因可能是重复释放内存。标准解决方法如下：


 
   
   
   
   
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     "font-size:18px;">
     
       
       
       
       template < class T >
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       void ClearVector( 
     
       
       
       
       vector< T >& vt ) 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
          
     
       
       
       
       vector< T > vtTemp; 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         veTemp.swap( vt );
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     }

3. 利用vector释放指针

如果vector中存放的是指针，那么当vector销毁时，这些指针指向的对象不会被销毁，那么内存就不会被释放。如下面这种情况，vector中的元素时由new操作动态申请出来的对象指针：


 
   
   
   
   
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     "font-size:18px;">#include <
     
       
       
       
       vector> 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       using 
     
       
       
       
       namespace 
     
       
       
       
       std; 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       vector<
     
       
       
       
       void *> v;

每次new之后调用v.push_back()该指针，在程序退出或者根据需要，用以下代码进行内存的释放：


 
   
   
   
   
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     "font-size:18px;">
     
       
       
       
       for (
     
       
       
       
       vector<
     
       
       
       
       void *>::iterator it = v.begin(); it != v.end(); it ++) 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
          
     
       
       
       
       if (
     
       
       
       
       NULL != *it) 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
              
     
       
       
       
       delete *it; 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             *it = 
     
       
       
       
       NULL;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     v.clear();

３，

vector是线性容器,它的元素严格的按照线性序列排序,和动态数组很相似,和数组一样,它的元素存储在一块连续的存储空间中,这也意味着我们不仅可以使用迭代器(iterator)访问元素,还可以使用指针的偏移方式访问,和常规数组不一样的是,vector能够自动存储元素,可以自动增长或缩小存储空间,

vector的优点:

1. 可以使用下标访问个别的元素

2. 迭代器可以按照不同的方式遍历容器

3. 可以在容器的末尾增加或删除元素

和数组相比,虽然容器在自动处理容量的大小时会消耗更多的内存,但是容器能提供和数组一样的性能,而且能很好的调整存储空间大小

和其他标准的顺序容器相比(deques or lists),能更有效访问容器内的元素和在末尾添加和删除元素,在其他位置添加和删除元素,vector则不及其他顺序容器,在迭代器和引用也不比lists支持的好

容器的大小和容器的容量是有区别的,大小是指元素的个数,容量是分配的内存大小,容量一般等于或大于容器的大小,vector::size()返回容器的大小,vector::capacity()返回容量值,容量多于容器大小的部分用于以防容器的增加使用,每次重新分配内存都会很影响程序的性能,所以一般分配的容量大于容器的大小,若要自己指定分配的容量的大小,则可以使用vector::reserve(),但是规定的值要大于size()值,

1.构造和复制构造函数

explicit vector ( const Allocator& = Allocator() );

explicit vector ( size_type n, const T& value= T(), const Allocator& = Allocator() );

template

vector ( InputIterator first, InputIterator last, const Allocator& = Allocator() );

vector ( const vector& x );

explicit:是防止隐式转换, Allocator是一种内存分配模式,一般是使用默认的

vector A; //创建一个空的的容器

vector B(10,100); //创建一个个元素,每个元素值为

vector C(B.begin(),B.end()); //使用迭代器,可以取部分元素创建一个新的容器

vector D(C); //复制构造函数,创建一个完全一样的容器

2.析构函数

~vector()

销毁容器对象并回收了所有分配的内存

3.重载了=符号

vector E;

E = B; //使用=符号

B = vector(); //将B置为空容器

4. vector::begin() 返回第一个元素的迭代器

函数原型：

iterator begin (); //返回一个可变迭代器

const_iterator begin () const; //返回一个常量的迭代器，不可变

5.vector::end() 返回的是越界后的第一个位置，也就是最后一个元素的下一个位置

iterator end ();

const_iterator end () const;

6.vector::rbegin() 反序的第一个元素，也就是正序最后一个元素

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

7.vector::rend() 反序的最后一个元素下一个位置，也相当于正序的第一个元素前一个位置

reverse_iterator rend();

const_reverse_iterator rend() const;

和vector::end()原理一样

8.vector::size() 返回容器中元素个数

size_type size() const;

注意与vector::capacity()的区别

9.vector::max_size()

size_type max_size () const;

返回容器的最大可以存储的元素个数，这是个极限，当容器扩展到这个最大值时就不能再自动增大

10. vector::resize()

void resize ( size_type sz, T c = T() );

重新分配容器的元素个数，这个还可以改容器的容量，如果重新分配的元素个数比原来的小，将截断序列，后面的部分丢弃，如果大于原来的个数，后面的值是c的值，默认为0

11. vector::capacity()

size_type capacity () const;

返回vector的实际存储空间的大小，这个一般大于或等于vector元素个数，注意与size()函数的区别

12. vector::empty()

bool empty () const;

当元素个数为0时返回true，否则为false，根据的是元素个数而不是容器的存储空间的大小

13. vector::reserve()

void reserve ( size_type n );

重新分配空间的大小，不过这个n值要比原来的capacity()返回的值大，不然存储空间保持不变，n值要比原来的实际存储空间大才能重新分配空间，但是最大值不可以大于max_size的值，否则会抛出异常

14. vector::operator[] //重载了[]符号

reference operator[] ( size_type n );

const_reference operator[] ( size_type n ) const;

实现了下标访问元素

15. vector::at()

const_reference at ( size_type n ) const;

reference at ( size_type n );

在函数的操作方面和下标访问元素一样，不同的是当这个函数越界时会抛出一个异常out_of_range

16. vector::front()

reference front ( );

const_reference front ( ) const;

返回第一个元素的值，与begin()函数有区别，begin()函数返回的是第一个元素的迭代器

17. vector::back()

reference back ( );

const_reference back ( ) const;

同样，返回最后一个元素的值，注意与end()函数的区别

18. vector::assign()

template void assign ( InputIterator first, InputIterator last );

void assign ( size_type n, const T& u );

将丢弃原来的元素然后重新分配元素，第一个函数是使用迭代器，第二个函数是使用n个元素，每个元素的值为u。

19. vector::push_back()

void push_back ( const T& x );

在容器的最后一个位置插入元素x,如果size值大于capacity值，则将重新分配空间

20. vector::pop_back()

void pop_back ( );

删除最后一个元素

21. vector::insert()

iterator insert ( iterator position, const T& x );

void insert ( iterator position, size_type n, const T& x );

template

void insert ( iterator position, InputIterator first, InputIterator last );

插入新的元素，

第一个函数，在迭代器指定的位置前插入值为x的元素

第二个函数，在迭代器指定的位置前插入n个值为x的元素

第三个函数，在迭代器指定的位置前插入另外一个容器的一段序列迭代器first到last

若插入新的元素后总得元素个数大于capacity，则重新分配空间

22. vector::erase()

iterator erase ( iterator position );

iterator erase ( iterator first, iterator last );

删除元素或一段序列

23. vector::swap()

void swap ( vector& vec );

交换这两个容器的内容，这涉及到存储空间的重新分配

24. vector::clear()

void clear ( );

将容器里的内容清空，size值为0，但是存储空间没有改变


 
   
   
   
   
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     "font-size:18px;">#include <
     
       
       
       
       vector>
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     #include 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       using 
     
       
       
       
       namespace 
     
       
       
       
       std;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
       int _tmain(
     
       
       
       
       int argc, _TCHAR* argv[])
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       //构造函数,复制构造函数(元素类型要一致),
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int> A;  
     
       
       
       
       //创建一个空的的容器
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int> B(
     
       
       
       
       10,
     
       
       
       
       100); 
     
       
       
       
       //创建一个10个元素,每个元素值为100
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int> C(B.begin(),B.end()); 
     
       
       
       
       //使用迭代器,可以取部分元素创建一个新的容器
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int> D(C); 
     
       
       
       
       //复制构造函数,创建一个完全一样的容器
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
               
     
       
       
       
       //重载=
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int> E;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         E = B;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
      
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::begin()，返回的是迭代器
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
        
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int> F(
     
       
       
       
       10); 
     
       
       
       
       //创建一个有10个元素的容器
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
                
     
       
       
       
       for (
     
       
       
       
       int i = 
     
       
       
       
       0; i < 
     
       
       
       
       10; i++)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
               {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             F[i] = i;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
               }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       /*
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
           vector F; //创建一个空容器
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
           for (int i = 0; i < 10; i++)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
           {
        
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
               F.push_back(i);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
           } 
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
     
       
       
       
               */
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int>::iterator BeginIter = F.begin();
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << *BeginIter << 
     
       
       
       
       endl; 
     
       
       
       
       //输出0
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::end() 返回迭代器
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int>::iterator EndIter = F.end();
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         EndIter--; 
     
       
       
       
       //向后移一个位置
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << *EndIter << 
     
       
       
       
       endl; 
     
       
       
       
       //输出9
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
      
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::rbegin() 返回倒序的第一个元素，相当于最后一个元素
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int>::reverse_iterator ReverBeIter = F.rbegin();
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << *ReverBeIter << 
     
       
       
       
       endl; 
     
       
       
       
       //输出9
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::rend() 反序的最后一个元素下一个位置，也相当于正序的第一个元素前一个位置
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int>::reverse_iterator ReverEnIter = F.rend();
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         ReverEnIter--;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << *ReverEnIter << 
     
       
       
       
       endl; 
     
       
       
       
       //输出0
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::size() 返回元素的个数
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << F.size() << 
     
       
       
       
       endl; 
     
       
       
       
       //输出10
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::max_size()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << F.max_size() << 
     
       
       
       
       endl; 
     
       
       
       
       //输出1073741823，这个是极限元素个数
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::resize()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << F.size() << 
     
       
       
       
       endl; 
     
       
       
       
       //输出10
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         F.resize(
     
       
       
       
       5);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       for(
     
       
       
       
       int k = 
     
       
       
       
       0; k < F.size(); k++)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       cout << F[k] << 
     
       
       
       
       "  "; 
     
       
       
       
       //输出 0 1 2 3 4
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
              
     
       
       
       
       cout << 
     
       
       
       
       endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::capacity()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << F.size() << 
     
       
       
       
       endl; 
     
       
       
       
       //5
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << F.capacity() << 
     
       
       
       
       endl; 
     
       
       
       
       //10
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::empty()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
              B.resize(
     
       
       
       
       0);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << B.size() << 
     
       
       
       
       endl; 
     
       
       
       
       //0
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << B.capacity() << 
     
       
       
       
       endl; 
     
       
       
       
       //10
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << B.empty() << 
     
       
       
       
       endl; 
     
       
       
       
       //true
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::reserve() //重新分配存储空间大小
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
                
     
       
       
       
       cout << C.capacity() << 
     
       
       
       
       endl; 
     
       
       
       
       //10
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         C.reserve(
     
       
       
       
       4);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << C.capacity() << 
     
       
       
       
       endl; 
     
       
       
       
       //10
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         C.reserve(
     
       
       
       
       14);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << C.capacity() << 
     
       
       
       
       endl; 
     
       
       
       
       //14
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::operator []
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << F[
     
       
       
       
       0] << 
     
       
       
       
       endl; 
     
       
       
       
       //第一个元素是0
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::at()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       try
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         {
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
           
     
       
       
       
       cout << 
     
       
       
       
       "F.size = " << F.size() << 
     
       
       
       
       endl; 
     
       
       
       
       //5
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
                
     
       
       
       
       cout << F.at(
     
       
       
       
       6) << 
     
       
       
       
       endl; 
     
       
       
       
       //抛出异常
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       catch(out_of_range)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         {    
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
            
     
       
       
       
       cout << 
     
       
       
       
       "at()访问越界" << 
     
       
       
       
       endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         }
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::front() 返回第一个元素的值
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
                
     
       
       
       
       cout << F.front() << 
     
       
       
       
       endl; 
     
       
       
       
       //0
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::back()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << F.back() << 
     
       
       
       
       endl; 
     
       
       
       
       //4
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::assign()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << A.size() << 
     
       
       
       
       endl; 
     
       
       
       
       //0
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int>::iterator First = C.begin();
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       vector<
     
       
       
       
       int>::iterator End = C.end()
     
       
       
       
       -2;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         A.assign(First,End);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << A.size() << 
     
       
       
       
       endl; 
     
       
       
       
       //8
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << A.capacity() << 
     
       
       
       
       endl; 
     
       
       
       
       //8
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         A.assign(
     
       
       
       
       5,
     
       
       
       
       3); 
     
       
       
       
       //将丢弃原来的所有元素然后重新赋值
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << A.size() << 
     
       
       
       
       endl; 
     
       
       
       
       //5
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << A.capacity() << 
     
       
       
       
       endl; 
     
       
       
       
       //8
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::push_back()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << *(F.end()
     
       
       
       
       -1) << 
     
       
       
       
       endl; 
     
       
       
       
       //4
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         F.push_back(
     
       
       
       
       100);
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << *(F.end()
     
       
       
       
       -1) << 
     
       
       
       
       endl; 
     
       
       
       
       //100
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::pop_back()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << *(F.end()
     
       
       
       
       -1) << 
     
       
       
       
       endl; 
     
       
       
       
       //100
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         F.pop_back();
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << *(F.end()
     
       
       
       
       -1) << 
     
       
       
       
       endl; 
     
       
       
       
       //4
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::swap()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         F.swap(D); 
     
       
       
       
       //交换这两个容器的内容
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       for(
     
       
       
       
       int f = 
     
       
       
       
       0; f < F.size(); f++)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       cout << F[f] << 
     
       
       
       
       " ";
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << 
     
       
       
       
       endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       for (
     
       
       
       
       int d = 
     
       
       
       
       0; d < D.size(); d++)
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
             
     
       
       
       
       cout << D[d] << 
     
       
       
       
       " ";
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
              
     
       
       
       
       cout << 
     
       
       
       
       endl;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       //vector::clear()
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         F.clear();
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << F.size() << 
     
       
       
       
       endl;     
     
       
       
       
       //0
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       cout << F.capacity() << 
     
       
       
       
       endl; 
     
       
       
       
       //10
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
       
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
         
     
       
       
       
       return 
     
       
       
       
       0;
    
      
      
      
      
   
     
     
     
     
    
    
    
    
   
     
     
     
     
    
      
      
      
      
   
     
     
     
     
   
     
     
     
     
    
      
      
      
      
       
       
       
       
     }

本文借鉴与：http://www.cnblogs.com/wang7/archive/2012/04/27/2474138.html

http://blog.csdn.net/bizhu12/article/details/6769976

　　　　　　http://www.cnblogs.com/summerRQ/articles/2407974.html

你可能感兴趣的:(C++深度剖析,vector)

c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
C++菜鸟教程 - 从入门到精通第二节 DreamByte c++
一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
C++ lambda闭包消除类成员变量 barbyQAQ c++c++java 算法
原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题（第三大题：完善程序代码） mmz1207 c++csp
最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
《 C++ 修炼全景指南：九》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南 c++算法 stl
摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
20个新手学习c++必会的程序输出*三角形、杨辉三角等（附代码） X_StarX c++学习算法大学生开发语言数据结构
示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】汉子萌萌哒 CCF noi 算法数据结构 c++
一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
《 C++ 修炼全景指南：十》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南 c++数据结构 stl
摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
c++ opencv4.3 sift匹配图像处理大大大大大牛啊图像处理 opencv实战代码讲解 opencv sift c++opencv4 特征点
c++opencv4.3sift匹配main.cppintmain(){vectorkeypoints1,keypoints2;Matimg1,img2,descriptors1,descriptors2;intnumF
《 C++ 修炼全景指南：四》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南 C++修炼全景指南 c++list 链表 stl
本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
c++ 内存处理函数 heeheeai c++开发语言
在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
【c++基础概念深度理解——堆和栈的区别，并实现堆溢出和栈溢出】 XWWW668899 C++基本概念 c++c语言开发语言青少年编程
文章目录概要技术名词解释栈溢出和堆溢出小结概要学习C++语言，避免不了要好好理解一下堆（Heap）和栈（Stack），有助于更好地管理内存，以及如何写出一段程序“成功实现”堆溢出和栈溢出。技术名词解释理解东西最快的方式是根据自己目前能理解的词语去关联新的概念，不断的纠正，向正确的深度理解靠近，当无限接近的时候也就理解了想要理解的概念。我们经常说堆栈，把这两个名词放到一起。其实，堆是堆，栈是栈，两种
C++常见知识掌握 nfgo c++开发语言
1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
metaRTC5.0 API编程指南(一) metaRTC metaRTC c++c语言 webrtc
概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
sublime个人设置 bawangtianzun sublime text 编辑器
如何拥有jiangly蒋老师同款编译器(sublimec++配置竞赛向）_哔哩哔哩_bilibiliSublimeText4的安装教程（新手竞赛向）-知乎(zhihu.com)创建文件自动保存为c++打开SublimeText软件。转到"Tools"（工具）>"Developer"（开发者）>"NewPlugin"（新建插件）。在打开的新文件中，粘贴以下代码：importsublimeimport
leetcode 11. 盛最多水的容器 Source_Chang
leetcode核心思想：双指针，数字小的那个指针移动classSolution{public:intmaxArea(vector&height){intleft=0;intright=height.size()-1;intmaxArea=0;while(left
Rust是否会取代C/C++？Rust与C/C++的较量 AI与编程之窗源码编译与开发 rust c语言 c++内存安全并发编程代码安全性能优化
目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
滑动窗口+动态规划 wniuniu_ 算法动态规划算法
前言：分析这个题目的时候，就知道要这两个线段要分开，但是要保证得到最优解，那么我们在选取第二根线段的时候，要保证我们第一根线段是左边最优解并且我们选的两根线段的右端点一定是我们的数组的点（贪心思想）classSolution{public:intmaximizeWin(vector&prizePositions,intk){intn=prizePositions.size();vectormx(n
python可以制作大型游戏_python能做游戏吗-python能开发游戏吗靖dede python可以制作大型游戏
python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
Python开发游戏？也太好用了吧七步编程工具 Github python python 游戏开发语言
程序员宝藏库：https://gitee.com/sharetech_lee/CS-Books-Store当然可以啦！现在日常能够用到和想到的场景，绝大多数都可以用Python实现。效果怎么样暂且不提，但是得益于丰富的第三方工具包，的确让Python能够很容易处理各种各样的场景。对于游戏开发也是这样，如果真的要想商业化，Python在游戏开发方面肯定没办法和C++相提并论，但是如果用于日常学习和自
Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
svg图片兼容性和用法优缺点独行侠_ef93
svg图片的使用方法第一次来认认真真的研究了下svg图片，之前只是在网上见过，但都是一晃而过也没当回事，最近网站改版看到同事有用到svg格式的图片，想想自己干了几年的重构也没用过，这些细节的知识是应该好好研究研究了。暂时还没研究得完全透切，先记下目前为止所看到的吧不然又给忘了。svg可缩放矢量图形（ScalableVectorGraphics），顾名思义就是任意改变其大小也不会变形，是基于可扩展标
java工厂模式 3213213333332132 java 抽象工厂
工厂模式有 1、工厂方法 2、抽象工厂方法。下面我的实现是抽象工厂方法, 给所有具体的产品类定一个通用的接口。 package 工厂模式; /** * 航天飞行接口 * * @Description * @author FuJianyong * 2015-7-14下午02:42:05 */ public interface SpaceF
nginx频率限制+python测试 ronin47 nginx 频率 python
部分内容参考：http://www.abc3210.com/2013/web_04/82.shtml 首先说一下遇到这个问题是因为网站被攻击，阿里云报警，想到要限制一下访问频率，而不是限制ip（限制ip的方案稍后给出）。nginx连接资源被吃空返回状态码是502，添加本方案限制后返回599，与正常状态码区别开。步骤如下：
java线程和线程池的使用 dyy_gusi ThreadPool thread Runnable timer
java线程和线程池一、创建多线程的方式 java多线程很常见，如何使用多线程，如何创建线程，java中有两种方式，第一种是让自己的类实现Runnable接口，第二种是让自己的类继承Thread类。其实Thread类自己也是实现了Runnable接口。具体使用实例如下： 1、通过实现Runnable接口方式 1 2
Linux 171815164 linux
ubuntu kernel http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.1.2-unstable/ 安卓sdk代理 mirrors.neusoft.edu.cn 80 输入法和jdk sudo apt-get install fcitx su
Tomcat JDBC Connection Pool g21121 Connection
Tomcat7 抛弃了以往的DBCP 采用了新的Tomcat Jdbc Pool 作为数据库连接组件，事实上DBCP已经被Hibernate 所抛弃，因为他存在很多问题，诸如：更新缓慢，bug较多，编译问题，代码复杂等等。 Tomcat Jdbc P
敲代码的一点想法永夜-极光 java 随笔感想
入门学习java编程已经半年了,一路敲代码下来,现在也才1w+行代码量,也就菜鸟水准吧,但是在整个学习过程中,我一直在想,为什么很多培训老师,网上的文章都是要我们背一些代码?比如学习Arraylist的时候,教师就让我们先参考源代码写一遍,然
jvm指令集程序员是怎么炼成的 jvm 指令集
转自：http://blog.csdn.net/hudashi/article/details/7062675#comments 将值推送至栈顶时 const ldc push load指令 const系列该系列命令主要负责把简单的数值类型送到栈顶。(从常量池或者局部变量push到栈顶时均使用) 0x02 &nbs
Oracle字符集的查看查询和Oracle字符集的设置修改 aijuans oracle
本文主要讨论以下几个部分：如何查看查询oracle字符集、修改设置字符集以及常见的oracle utf8字符集和oracle exp 字符集问题。一、什么是Oracle字符集 Oracle字符集是一个字节数据的解释的符号集合,有大小之分,有相互的包容关系。ORACLE 支持国家语言的体系结构允许你使用本地化语言来存储，处理，检索数据。它使数据库工具，错误消息，排序次序，日期，时间，货
png在Ie6下透明度处理方法 antonyup_2006 css 浏览器 Firebug IE
由于之前到深圳现场支撑上线，当时为了解决个控件下载，我机器上的IE8老报个错，不得以把ie8卸载掉，换个Ie6,问题解决了，今天出差回来，用ie6登入另一个正在开发的系统，遇到了Png图片的问题，当然升级到ie8(ie8自带的开发人员工具调试前端页面JS之类的还是比较方便的，和FireBug一样，呵呵)，这个问题就解决了，但稍微做了下这个问题的处理。我们知道PNG是图像文件存储格式，查询资
表查询常用命令高级查询方法(二) 百合不是茶 oracle 分页查询分组查询联合查询
----------------------------------------------------分组查询 group by having --平均工资和最高工资 select avg(sal)平均工资,max(sal) from emp ; --每个部门的平均工资和最高工资
uploadify3.1版本参数使用详解 bijian1013 JavaScript uploadify3.1
使用：绑定的界面元素<input id='gallery'type='file'/>$("#gallery").uploadify({设置参数，参数如下}); 设置的属性： id: jQuery(this).attr('id'),//绑定的input的ID langFile: 'http://ww
精通Oracle10编程SQL(17)使用ORACLE系统包 bijian1013 oracle 数据库 plsql
/* *使用ORACLE系统包 */ --1.DBMS_OUTPUT --ENABLE:用于激活过程PUT,PUT_LINE,NEW_LINE,GET_LINE和GET_LINES的调用 --语法：DBMS_OUTPUT.enable(buffer_size in integer default 20000); --DISABLE:用于禁止对过程PUT,PUT_LINE,NEW
【JVM一】JVM垃圾回收日志 bit1129 垃圾回收
将JVM垃圾回收的日志记录下来，对于分析垃圾回收的运行状态，进而调整内存分配(年轻代，老年代，永久代的内存分配)等是很有意义的。JVM与垃圾回收日志相关的参数包括： -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -Xloggc -XX:+PrintGC 通
Toast使用白糖_ toast
Android中的Toast是一种简易的消息提示框，toast提示框不能被用户点击，toast会根据用户设置的显示时间后自动消失。创建Toast 两个方法创建Toast makeText(Context context, int resId, int duration) 参数：context是toast显示在
angular.identity boyitech AngularJS AngularJS API
angular.identiy 描述: 返回它第一参数的函数. 此函数多用于函数是编程. 使用方法: angular.identity(value); 参数详解: Param Type Details value * to be returned. 返回值: 传入的value 实例代码: <!DOCTYPE HTML>
java-两整数相除，求循环节 bylijinnan java
import java.util.ArrayList; import java.util.List; public class CircleDigitsInDivision { /** * 题目：求循环节，若整除则返回NULL，否则返回char*指向循环节。先写思路。函数原型：char*get_circle_digits(unsigned k,unsigned j)
Java 日期周年 Chen.H java C++c C#
/** * java日期操作(月末、周末等的日期操作) * * @author * */ public class DateUtil { /** */ /** * 取得某天相加(减)後的那一天 * * @param date * @param num *
[高考与专业]欢迎广大高中毕业生加入自动控制与计算机应用专业 comsci 计算机
不知道现在的高校还设置这个宽口径专业没有,自动控制与计算机应用专业,我就是这个专业毕业的,这个专业的课程非常多,既要学习自动控制方面的课程,也要学习计算机专业的课程,对数学也要求比较高.....如果有这个专业,欢迎大家报考...毕业出来之后,就业的途径非常广..... 以后
分层查询（Hierarchical Queries） daizj oracle 递归查询层次查询
Hierarchical Queries If a table contains hierarchical data, then you can select rows in a hierarchical order using the hierarchical query clause: hierarchical_query_clause::= start with condi
数据迁移 daysinsun 数据迁移
最近公司在重构一个医疗系统，原来的系统是两个.Net系统，现需要重构到java中。数据库分别为SQL Server和Mysql，现需要将数据库统一为Hana数据库，发现了几个问题，但最后通过努力都解决了。 1、原本通过Hana的数据迁移工具把数据是可以迁移过去的，在MySQl里面的字段为TEXT类型的到Hana里面就存储不了了，最后不得不更改为clob。 2、在数据插入的时候有些字段特别长
C语言学习二进制的表示示例 dcj3sjt126com c basic
进制的表示示例 # include <stdio.h> int main(void) { int i = 0x32C; printf("i = %d\n", i); /* printf的用法 %d表示以十进制输出 %x或%X表示以十六进制的输出 %o表示以八进制输出 */ return 0; }
NsTimer 和 UITableViewCell 之间的控制 dcj3sjt126com ios
情况是这样的: 一个UITableView, 每个Cell的内容是我自定义的 viewA viewA上面有很多的动画, 我需要添加NSTimer来做动画, 由于TableView的复用机制, 我添加的动画会不断开启, 没有停止, 动画会执行越来越多. 解决办法: 在配置cell的时候开始动画, 然后在cell结束显示的时候停止动画查找cell结束显示的代理
MySql中case when then 的使用 fanxiaolong casewhenthenend
select "主键", "项目编号", "项目名称","项目创建时间", "项目状态","部门名称","创建人" union (select pp.id as "主键", pp.project_number as &
Ehcache（01）——简介、基本操作 234390216 cache ehcache 简介 CacheManager crud
Ehcache简介目录 1 CacheManager 1.1 构造方法构建 1.2 静态方法构建 2 Cache 2.1&
最容易懂的javascript闭包学习入门 jackyrong JavaScript
http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html 闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。下面就是我的学习笔记，对于Javascript初学者应该是很有用的。一、变量的作用域要理解闭包，首先必须理解Javascript特殊
提升网站转化率的四步优化方案 php教程分享数据结构 PHP 数据挖掘 Google 活动
网站开发完成后,我们在进行网站优化最关键的问题就是如何提高整体的转化率，这也是营销策略里最最重要的方面之一，并且也是网站综合运营实例的结果。文中分享了四大优化策略：调查、研究、优化、评估，这四大策略可以很好地帮助用户设计出高效的优化方案。 PHP开发的网站优化一个网站最关键和棘手的是，如何提高整体的转化率，这是任何营销策略里最重要的方面之一，而提升网站转化率是网站综合运营实力的结果。今天，我就分
web开发里什么是HTML5的WebSocket？ naruto1990 Web html5 浏览器 socket
当前火起来的HTML5语言里面，很多学者们都还没有完全了解这语言的效果情况，我最喜欢的Web开发技术就是正迅速变得流行的 WebSocket API。WebSocket 提供了一个受欢迎的技术，以替代我们过去几年一直在用的Ajax技术。这个新的API提供了一个方法，从客户端使用简单的语法有效地推动消息到服务器。让我们看一看6个HTML5教程介绍里的 WebSocket API：它可用于客户端、服
Socket初步编程——简单实现群聊 Everyday都不同 socket 网络编程初步认识
初次接触到socket网络编程，也参考了网络上众前辈的文章。尝试自己也写了一下，记录下过程吧：服务端：（接收客户端消息并把它们打印出来） public class SocketServer { private List<Socket> socketList = new ArrayList<Socket>(); public s
面试：Hashtable与HashMap的区别（结合线程） toknowme
昨天去了某钱公司面试，面试过程中被问道 Hashtable与HashMap的区别？当时就是回答了一点，Hashtable是线程安全的，HashMap是线程不安全的，说白了，就是Hashtable是的同步的，HashMap不是同步的，需要额外的处理一下。今天就动手写了一个例子，直接看代码吧 package com.learn.lesson001; import java
MVC设计模式的总结 xp9802 设计模式 mvc 框架 IOC
随着Web应用的商业逻辑包含逐渐复杂的公式分析计算、决策支持等，使客户机越来越不堪重负，因此将系统的商业分离出来。单独形成一部分，这样三层结构产生了。其中‘层’是逻辑上的划分。三层体系结构是将整个系统划分为如图2.1所示的结构[3] （1）表现层（Presentation layer）：包含表示代码、用户交互GUI、数据验证。该层用于向客户端用户提供GUI交互，它允许用户