STL 中类vector的成员函数

STL 中类vector的成员函数

向量是最简单的STL容器，其数据结构与数组相似，占据着一块连续的内存块。由于内存位置是连续的，所以向量中的元素可以随机访问，访问向量中任何一个元素的时间也是固定的。存储空间的管理是自动的，当将一个元素插入到已满的向量时，会为向量分配一个更大的内存块，将向量中的元素复制进新的内存块，然后释放旧的内存块。所以，向量是一个灵活的数组，能够动态改变自身大小。

表1-1： 按字母顺序列出类vector中的成员函数

成员函数	操 作
void assign(iterator first,iterator last)	删除向量中的所有元素，然后将迭代器first 和last 指示范围中的元素插入该向量中
void assign(size_type n,const T& el = T())	删除向量中的所有元素，然后将el的n个副本插入该向量
T& at(size_type n)	返回向量中位置为n的元素
const T& at(size_type n) const	返回向量中位置为n的元素
T& back()	返回向量的最后一个元素
const T& back() const	返回向量的最后一个元素
iterator begin()	返回一个迭代器，该迭代器引用向量的第一个元素
const_iterator begin() const	返回一个迭代器，该迭代器引用向量的第一个元素
size_type capacity() const	返回可以存储在向量中的元素项目
void clear()	清除向量中所有元素
bool empty() const	如果向量不包括元素，则返回true，否则返回false
iterator end()	返回一个迭代器，该迭代器位于向量的最后一个元素之后
const_iterator end() const	返回一个const 迭代器，该迭代器位于向量的最后一个元素之后
iterator erase(iterator i)	删除该迭代器i引用的元素，返回一个迭代器，引用被删除元素之后的元素
iterator erase(iterator first,iterator last)	删除迭代器first和last指示范围中的元素，返回一个迭代器，引用被删除的最后一个元素之后的元素
T& front()	返回向量的第一个元素
const T& front() const	返回向量的第一个元素
iterator insert(iterator i,const T& el = T())	在由迭代器i引用的元素之前插入el，并返回引用新插入元素的迭代器
void insert(iterator i,size_type n,const T& el)	在迭代器i引用的元素之前插入el的n个副本
void insert(iterator i,iterator first,iterator last)	在迭代器i引用的元素之前插入迭代器first 和 last 指示范围的元素
size_type max_size() const	返回向量的最大元素
T& operator[]	下标运算符
const T& operator[] const	下标运算符
void pop_back()	删除向量的最后一个元素
void push_back(cosnt T& el)	在向量的末尾插入el
reverse_iterator rbegin()	返回引用向量中最后一个元素的迭代器
const_reverse_iterator rbegin() const	返回引用向量中最后一个元素的迭代器
reverse_iterator rend()	返回位于向量中第一个元素之前的迭代器
const_reverse_iterator rend() const	返回位于向量中第一个元素之前的迭代器
void reverse(size_type n)	如果向量的容量小于n，该函数就为向量预留保存n项的足够空间
void resize(size_type n,const T&el = T())	使向量保存n个元素，方法是：通过元素el再添加 n-size()个位置,或者丢弃向量末尾溢出的size()-n 个位置
size_type size() const	返回向量中的元素数量
void swap(vetor<T>& v)	与另一个向量交换内容
vector()	创建空向量
vector(size_type n,const T& el = T())	向类型T的n个副本创建一个向量(如果没有提供el，则使用默认的构造函数T()
vector(iterator first,iterator last)	用迭代器first 和last 指示范围中的元素构造一个向量
vertor(const vector<T>& v)	复制构造函数

PS:

1. size_type：由string类类型和vector类类型定义的类型，用以保存任意string对象或vector对象的长度，标准库类型size_type定义为unsigned类型。
2. T 为模板（Template）

以下写出一个程序其中来用到vector中的函数 以及一些Algorithms

/**
 * 展示向量如何操作      <vector>
 * 
 * 
 */
 
 #include<iostream>
 #include<vector>
 #include<algorithm>
 #include<string>
 using namespace std;


template<class T>
void printVector(string s,const vector<T>& v)
{
    cout<< s <<"=(";
    if(v.size() == 0)
    {
        cout<<")\n";
        system("pause");
        return;
    }
    typename vector<T>::const_iterator i =v.begin();        //此处用typedef直接告诉编译器  vector<T>::const_iterator是一个类型

    for(;i!=v.end()-1;i++)
    {
        cout<<*i<<' ';
    }
    cout<<*i<<")\n";
}

bool f1(int n)
{
    return n<4;
}


 int main()
 {
     int a[] = {1,2,3,4,5};
     vector<int> v1;                //创建一个空向量  size = 0 , capacity = 0
     printVector("v1",v1);

     for(int j=1;j<=5;j++)
     {
         v1.push_back(j);                     //v1 = {1,2,3,4,5}  size = 5, capacity = 8
     }                      

     vector<int> v2(3,7);                    //v2 = {7,7,7}
     vector<int>::iterator i1 = v1.begin()+1;
     vector<int> v3(i1,i1+2);                // v3={2,3}    size =2 , capacity = 2
     vector<int> v4(v1);                    // v4 = {1,2,3,4,5}     size=5 , capacity =5
     vector<int> v5(5);                     //v5 = {0,0,0,0,0}
     v5[1] = v5.at(3) = 9;                  //v5 = {0,9,0,9,0}      返回向量中位置为n的元素
     v3.reserve(6);                         //v3={2,3}      size = 2 , capacity = 6
     v4.resize(7);                          //v4={1,2,3,4,5,0,0}       size = 7 , capacity = 10
     v4.resize(3);                          //v4={1,2,3}               size = 3 , capacity = 10
     v4.clear();                            //v4 is empty              size = 0 , capacity = 10 (!)
     v4.insert(v4.end(),v3[1]);             //v4 = {3}
     v3.insert(v4.end(),v3.at(3));          //v4 = {3,3}
     v4.insert(v4.end(),2,4);               //v4 = {3,3,4,4}
     v4.insert(v4.end(),v1.begin()+1,v1.end()-1);      //v4 = {3,3,4,4,2,3,4}
     v4.erase(v4.end()-2);                             //v4 = {3,3,4,4,2,4}
     v4.erase(v4.begin(),v4.begin()+4);                //v4 = {2,4}
     v4.assign(3,8);                                   //v4 = {8,8,8}
     v4.assign(a,a+3);                                 //v4 = {1,2,3}

     vector<int>::reverse_iterator i3 = v4.rbegin();
     for(;i3!=v4.rend();i3++)
     {
         cout<<*i3<<" ";                  //print : 3 2 1
     }
     cout<<endl;


     //algorithms
     v5[0] = 3;                                     // v5 = {3,9,0,9,0}
     replace_if(v5.begin(),v5.end(),f1,7);          // v5 = {7,9,7,9,7}
     
     v5[0] = 3;
     v5[2] =v5[4] = 0;                             //  v5 = {3,9,0,9,0}

     replace(v5.begin(),v5.end(),0,7);             //  v5 = {3,9,7,9,7}
     sort(v5.begin(),v5.end());                    //  v5 = {3,7,7,9,9}
     sort(v5.begin(),v5.end(),greater<int> ());    //  v5 = {9,9,7,7,3}      STL对great()函数进行了定义 重载了运算符 >
     v5.front() = 2;                               //  v5 = {2,9,7,7,3}
    system("pause");
    return 0;
 }

该程序中的greater<T>()使STL中定义的函数，函数为模板结构，函数重载了运算符 > .