STL之vector

/*
//构造函数
vector<int> first             //创建一个空的向量容器
vector<int> first(4)          //创建一个向量容器first，容器中有4个int型元素，初始值为0
vector<int> first(4,2)        //创建一个向量容器first，容器中有4个int型元素，初始值为2
vector<int> first(const_iterator begin,const_iterator end)     //创建一个向量容器first，容器中的元素为指定元素，范围从[begin,end) 
vector<int> first(vector &x)  //创建一个向量容器first，容器元素为另一个容器x中的元素
*/
#include <iostream>
#include <vector>
using namespace std;

template<class T>
void show(vector<T> &one)
{
    cout<<"size()="<<one.size()<<"\t"<<"capacity="<<one.capacity()<<endl;
    for(int i=0;i<one.size();++i)
        cout<<one[i]<<" ";
    cout<<endl;
}

int main()
{    
    vector<int> one;
    show(one);

    vector<int> two(4);
    show(two);

    vector<int> three(4,3);
    show(three);

    vector<int> four(three.begin(),three.end());
    show(four);

    vector<int> five(four);
    show(five);

    int myints[]={2,4,5,6};
    vector<int> six(myints,myints+sizeof(myints)/sizeof(int));
    show(six);

    system("pause");
    return 0;
}

/*
//一些方法

size()             //返回向量容器中当前实际有多少个元素
capacity()         //返回向量容器中所能容纳的元素数量
empty()            //检测容器是否为空，是，返回true
clear()            //清空所有元素
swap(vector &x)    //交换两个vector 

front()                       //返回第一个元素的引用
back()                        //返回最后一个元素的引用 
at(size_type n)               //返回指定位置的元素的引用，若越界，则抛出out_of_range异常
operator[](size_type n)       //返回指定位置的元素的引用，若越界，则导致未定义的行为(undefined behavior)

push_back(value_type& val)    //向向量容器的尾部添加元素，若新vector的大小超过当前vector的容量，则再分配
pop_back()                    //移除最后一个元素 
注：若再分配，与容器相关的所有迭代器、指针及引用都无效；否则只有尾部的迭代器无效

begin()            //返回指向第一个元素的迭代器
end()              //返回指向最后一个元素的下一位(past-the-end)的迭代器

rbegin()           //返回指向最后一个元素的逆向迭代器

rend()             //返回指向第一个元素的前一位(preceding the first element)的逆向迭代器

*/

#include <iostream>
#include <vector>
#include <string>
using namespace std;

template<class T>
void show(vector<T> &one)
{
    cout<<"size()="<<one.size()<<"\t"<<"capacity="<<one.capacity()<<endl;
    for(int i=0;i<one.size();++i)
        cout<<one[i]<<" ";
    cout<<endl;
}

int main()
{
    vector<int> myvector(10);
    for(unsigned i=0; i<myvector.size(); i++)
        myvector.at(i) = i;
    show(myvector);

    system("pause");
    return 0;
}

/*
//inserting into the vector
iterator insert(iterator position, const value_type& val)
void insert(iterator position, size_type n, const value_type& val)
void insert(iterator position, const_iterator first, const_iterator last) 

Insert elements
The vector is extended by inserting new elements before the element at the specified position, effectively increasing the container size by the number of elements inserted.
[在position所指向的元素之前插入新元素]
This causes an automatic reallocation of the allocated storage space if -and only if- the new vector size surpasses the current vector capacity.
[如果新vector的大小超过当前vector的容量，则再分配]
Because vectors use an array as their underlying storage, inserting elements in positions other than the vector end causes the container to relocate all the elements that were after position to their new positions. This is generally an inefficient operation compared to the one performed for the same operation by other kinds of sequence containers (such as list or forward_list).
[因为vector内部是使用数组来存储元素，因此在尾部之外的地方插入元素会导致在position及position之后的元素被重新分配位置(即position及position之后的元素全部往后移，这个操作相较于其他顺序容器(比如列表和前向列表)而言通常是低效的)]

Return value

An iterator that points to the first of the newly inserted elements.
[返回值是指向第一个新插入元素的迭代器]
Member type iterator is a random access iterator type that points to elements.

[iterator是一个指向元素的随机存储迭代器]

Iterator validity
If a reallocation happens, all iterators, pointers and references related to the container are invalidated.
Otherwise, only those pointing to position and beyond are invalidated, with all iterators, pointers and references to elements before position guaranteed to keep referring to the same elements they were referring to before the call.
[如果发生再分配，所有的迭代器、指针和引用都会失效；否则只有指向position及position之后位置的迭代器、指针和引用才会失效，其他位置则保持不变]
*/

#include <iostream>
#include <vector>
using namespace std;

template<class T>
void show(vector<T> &r)
{
    cout<<"size="<<r.size()<<"\t"<<"capaticy="<<r.capacity()<<endl;
    for(int i=0;i<r.size();++i)
        cout<<r[i]<<" ";
    cout<<endl;
}

int main()
{
    vector<int> myvector(3, 100);
    show(myvector);
    
    vector<int>::iterator it = myvector.begin();
    

    it=myvector.insert(it, 200);  //增加一个元素后，myvector的capacity由3变为4，说明旧内存块被释放，因此迭代器it失效，需要重置 

    show(myvector);

    vector<int> another_vector(2, 400);
    myvector.insert(it+2, another_vector.begin(), another_vector.end());
    show(myvector);
    
    int myarray[]={501,502,503};
    myvector.insert(myvector.begin(),myarray,myarray+3);
    show(myvector);

    system("pause");
    return 0;
}

/*
//erasing from vector
iterator erase (iterator position);
iterator erase (iterator first, iterator last);

Erase elements
Removes from the vector either a single element (position) or a range of elements ([first,last)).
[从容器中删除一个元素(position处)或者一组元素(范围是[first, last])]
This effectively reduces the container size by the number of elements removed, which are destroyed.
[该操作会有效地缩小vector的长度]
Because vectors use an array as their underlying storage, erasing elements in positions other than the vector end causes the container to relocate all the elements after the segment erased to their new positions. This is generally an inefficient operation compared to the one performed for the same operation by other kinds of sequence containers (such as list or forward_list).
[因为vector内部使用数组存储元素，因此在尾部之外的地方删除元素会导致在被删除元素之后的所有元素被重新分配位置，这个操作相较于其他顺序容器，比如列表或者前向列表来说，通常是一个低效的操作]

Return value
An iterator pointing to the new location of the element that followed the last element erased by the function call. This is the container end if the operation erased the last element in the sequence.
[返回值是最后一个被删除元素的的下一个元素的迭代器，如果删除操作发生在尾部，则返回的是end]
Member type iterator is a random access iterator type that points to elements.
[iterator是一个指向元素的随机存储迭代器]

Iterator validity
Iterators, pointers and references pointing to position (or first) and beyond are invalidated, with all iterators, pointers and references to elements before position (or first) are guaranteed to keep referring to the same elements they were referring to before the call.
[指向position及position之后的迭代器、指针和引用都无效；其他都保持不变]
*/

#include <iostream>
#include <vector>
using namespace std;

template<class T>
void show(vector<T> &r)
{
    cout<<"size="<<r.size()<<"\t"<<"capaticy="<<r.capacity()<<endl;
    for(int i=0;i<r.size();++i)
        cout<<r[i]<<" ";
    cout<<endl;
}

int main()
{
    vector<int> myvector;
    for(int i=1;i<=10;i++)
        myvector.push_back(i);
    show(myvector);

    vector<int>::iterator it = myvector.begin();

    it = myvector.erase(myvector.begin());
    show(myvector);
    cout<<"*it = "<<*it<<endl;

    it = myvector.erase(myvector.begin()+1,myvector.begin()+4);
    show(myvector);
    cout<<"*it = "<<*it<<endl;

    system("pause");
    return 0;
}

/*
// vector assign
void assign(size_type n,const value_type& val)
void assign(const_iterator first,const_iterator last) 

Assign vector content
Assigns new contents to the vector, replacing its current contents, and modifying its size accordingly.
[重新分配vector的元素]
Any elements held in the container before the call are destroyed and replaced by newly constructed elements (no assignments of elements take place).This causes an automatic reallocation of the allocated storage space if -and only if- the new vector size surpasses the current vector capacity.
[容器中原有元素均被销毁并替换为新元素；如果新vector的大小超过当前vector的容量，则再分配]

Iterator validity

All iterators, pointers and references related to this container are invalidated.

[所有的迭代器、指针和引用都无效]*/

#include <iostream>
#include <vector>
using namespace std;

template<class T>
void show(vector<T> &r)
{
    cout<<"size="<<r.size()<<"\t"<<"capaticy="<<r.capacity()<<endl;
    for(int i=0;i<r.size();++i)
        cout<<r[i]<<" ";
    cout<<endl;
}

int main()
{
    vector<int> first(4,5);
    show(first);

    first.assign(2,4);
    show(first);
    
    first.assign(7,100);
    show(first);
    
    vector<int> second(10);
    for(int i=0; i<10; i++)
        second.at(i) = i;

    first.assign(second.begin(),second.end()-1);
    show(first);

    system("pause");
    return 0;
}

/*
//resizing vector
void resize (size_type n);
void resize (size_type n, const value_type& val);

Change size
Resizes the container so that it contains n elements.
[改变容器的大小使之长度为n]
If n is smaller than the current container size, the content is reduced to its first n elements, removing those beyond (and destroying them).
[如果n小于当前容器长度，则只保留前n个元素，其余元素销毁]
If n is greater than the current container size, the content is expanded by inserting at the end as many elements as needed to reach a size of n. If val is specified, the new elements are initialized as copies of val, otherwise, they are value-initialized.
[如果n大于当前容器的长度，则用指定元素填充剩下的元素；若没有指定填充元素，则用默认值填充]
If n is also greater than the current container capacity, an automatic reallocation of the allocated storage space takes place.
[如果n大于当前容器的容量，则再分配]
Notice that this function changes the actual content of the container by inserting or erasing elements from it.
[该函数使用插入和删除元素来改变容器的大小]

Iterator validity
In case the container shrinks, all iterators, pointers and references to elements that have not been removed remain valid after the resize and refer to the same elements they were referring to before the call.
[如果容器长度减小，则指向没有被移动的元素的迭代器、指针和引用保持不变]
If the container expands, the end iterator is invalidated and, if it has to reallocate storage, all iterators, pointers and references related to this container are also invalidated.
[如果容器长度增加，则指向尾部的迭代器失效；如果发生再分配，则所有迭代器、指针和引用均失效]
*/

#include <iostream>
#include <vector>
using namespace std;

template<class T>
void show(vector<T> &r)
{
    cout<<"size="<<r.size()<<"\t"<<"capaticy="<<r.capacity()<<endl;
    for(int i=0;i<r.size();++i)
        cout<<r[i]<<" ";
    cout<<endl;
}

int main()
{
    vector<int> myvector;
    for(int i=1;i<=10;i++)
        myvector.push_back(i);
    show(myvector);
    
    myvector.resize(5);
    show(myvector);
    
    myvector.resize(8,100);
    show(myvector);
    
    myvector.resize(12);
    show(myvector); 

    system("pause");
    return 0;
}

/*
//vector::reserve
void reserve (size_type n);

Request a change in capacity
Requests that the vector capacity be at least enough to contain n elements.
[请求，使得容器容量至少能够容纳n个元素]
If n is greater than the current vector capacity, the function causes the container to reallocate its storage increasing its capacity to n (or greater).
[如果n比当前容器容量大，则该函数会导致再分配，使得容器容量增加至n]
In all other cases, the function call does not cause a reallocation and the vector capacity is not affected.
[其余情况下，该函数不会产生任何影响，既不会导致再分配，也不会改变当前容器容量]
This function has no effect on the vector size and cannot alter its elements.
[该函数不会影响当前容器的大小及其元素]

Iterator validity
If a reallocation happens, all iterators, pointers and references related to the container are invalidated.Otherwise, they all keep referring to the same elements they were referring to before the call.
[如果发生再分配，则所有迭代器、指针和引用都失效；其他情况下保持不变]
*/

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int>::size_type sz;

    vector<int> foo;
    sz = foo.capacity();
    cout<<"making foo grow:\n";
    for(int i=0; i<20; i++)
    {
        foo.push_back(i);
        if(sz != foo.capacity())
        {
            sz = foo.capacity();
            cout<<"capacity changed: "<<sz<<"\n";
        }
    }

    vector<int> bar;
    sz = bar.capacity();
    bar.reserve(20);        // this is the only difference with foo above
    cout<<"making bar grow:\n";
    for(int i=0; i<20; i++)
    {
        bar.push_back(i);
        if(sz != bar.capacity())
        {
            sz = bar.capacity();
            cout<<"capacity changed: "<<sz<<"\n";
        }
    }

    system("pause");
    return 0;
}