STL之deque

/*
//construct deque
deque (const allocator_type& alloc = allocator_type());
deque (size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type());
deque (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
deque (const deque& x);
*/

#include <iostream>
#include <deque>

int main()
{
    // constructors used in the same order as described above:
    std::deque<int> first;                                // empty deque of ints
    std::deque<int> second (4,100);                       // four ints with value 100
    std::deque<int> third (second.begin(),second.end());  // iterating through second
    std::deque<int> fourth (third);                       // a copy of third

    // the iterator constructor can be used to copy arrays:
    int myints[] = {16,2,77,29};
    std::deque<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );

    std::cout << "The contents of fifth are:";
    for (std::deque<int>::iterator it = fifth.begin(); it!=fifth.end(); ++it)
        std::cout << ‘ ‘ << *it;

    std::cout << ‘\n‘;

    system("pause");
    return 0;
}

/*
size_type size() const;
bool empty() const;
void clear();
void swap();

reference back();
reference front();
reference at(size_type n);
reference operator[](size_type n);
deque& operator(const deque& x);

void push_back(const value_type& val);
void pop_back();
void push_front(const value_type& val);
void pop_front();

iterator begin();
iterator end();
reverse_iterator rbegin();
reverse_iterator rend();
*/

#include <iostream>
#include <deque>

int main ()
{
    std::deque<unsigned> mydeque (10);   // 10 zero-initialized unsigneds

    // assign some values:
    for (unsigned i=0; i<mydeque.size(); i++)
        mydeque.at(i)=i;

    std::cout << "mydeque contains:";
    for (unsigned i=0; i<mydeque.size(); i++)
        std::cout << ‘ ‘ << mydeque.at(i);

    std::cout << ‘\n‘;

    system("pause");
    return 0;
}

/*
iterator insert (iterator position, const value_type& val);
void insert (iterator position, size_type n, const value_type& val);
void insert (iterator position, InputIterator first, InputIterator last);

Insert elements
The deque container is extended by inserting new elements before the element at the specified position.
[在position所指向的元素之前插入新元素]
This effectively increases the container size by the amount of elements inserted.
[该操作能够高效的增加容器的长度]
Double-ended queues are designed to be efficient performing insertions (and removals) from either the end or the beginning of the sequence. Insertions on other positions are usually less efficient than in list or forward_list containers.
[双端队列是为了在队列两端进行高效的插入和删除而设计的，在其他地方进行插入操作通常会比list低效]

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是一个指向元素的随机存储迭代器]
*/

#include <iostream>
#include <deque>
#include <vector>

int main ()
{
    std::deque<int> mydeque;

    // set some initial values:
    for (int i=1; i<6; i++) mydeque.push_back(i); // 1 2 3 4 5

    std::deque<int>::iterator it = mydeque.begin();
    ++it;

    it = mydeque.insert (it,10);                  // 1 10 2 3 4 5
    // "it" now points to the newly inserted 10

    mydeque.insert (it,2,20);                     // 1 20 20 10 2 3 4 5
    // "it" no longer valid!

    it = mydeque.begin()+2;

    std::vector<int> myvector (2,30);
    mydeque.insert (it,myvector.begin(),myvector.end());
    // 1 20 30 30 20 10 2 3 4 5

    std::cout << "mydeque contains:";
    for (it=mydeque.begin(); it!=mydeque.end(); ++it)
        std::cout << ‘ ‘ << *it;
    std::cout << ‘\n‘;

    system("pause");
    return 0;
}

/*
iterator erase (iterator position);
iterator erase (iterator first, iterator last);

Erase elements
Removes from the deque container 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的长度]
Double-ended queues are designed to be efficient removing (and inserting) elements at either the end or the beginning of the sequence. Removals on other positions are usually less efficient than in list or forward_list containers.
[双端队列是为了在队列两端进行高效的插入和删除而设计的，在其他地方进行插入操作通常会比list低效]

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]
*/

#include <iostream>
#include <deque>

int main ()
{
    std::deque<int> mydeque;

    // set some values (from 1 to 10)
    for (int i=1; i<=10; i++) mydeque.push_back(i);

    // erase the 6th element
    mydeque.erase (mydeque.begin()+5);

    // erase the first 3 elements:
    mydeque.erase (mydeque.begin(),mydeque.begin()+3);

    std::cout << "mydeque contains:";
    for (std::deque<int>::iterator it = mydeque.begin(); it!=mydeque.end(); ++it)
        std::cout << ‘ ‘ << *it;
    std::cout << ‘\n‘;

    system("pause");
    return 0;
}

/*
void assign (InputIterator first, InputIterator last);
void assign (size_type n, const value_type& val);

Assign container content
Assigns new contents to the deque container, replacing its current contents, and modifying its size accordingly.
[重新分配deque的元素并相应改变deque的长度]
Any elements held in the container before the call are destroyed and replaced by newly constructed elements (no assignments of elements take place).
[容器中原有元素均被销毁并替换为新元素]
*/

#include <iostream>
#include <deque>

int main ()
{
    std::deque<int> first;
    std::deque<int> second;
    std::deque<int> third;

    first.assign (7,100);             // 7 ints with a value of 100

    std::deque<int>::iterator it;
    it=first.begin()+1;

    second.assign (it,first.end()-1); // the 5 central values of first

    int myints[] = {1776,7,4};
    third.assign (myints,myints+3);   // assigning from array.

    std::cout << "Size of first: " << int (first.size()) << ‘\n‘;
    std::cout << "Size of second: " << int (second.size()) << ‘\n‘;
    std::cout << "Size of third: " << int (third.size()) << ‘\n‘;

    system("pause");
    return 0;
}

/*
void resize (size_type n, value_type val = value_type());
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大于当前容器的长度，则用指定元素填充剩下的元素；若没有指定填充元素，则用默认值填充]
*/

#include <iostream>
#include <deque>

int main ()
{
    std::deque<int> mydeque;
    std::deque<int>::iterator it;

    // set some initial content:
    for (int i=1; i<10; ++i) mydeque.push_back(i);

    mydeque.resize(5);
    mydeque.resize(8,100);
    mydeque.resize(12);

    std::cout << "mydeque contains:";
    for (std::deque<int>::iterator it = mydeque.begin(); it != mydeque.end(); ++it)
        std::cout << ‘ ‘ << *it;
    std::cout << ‘\n‘;

    system("pause");
    return 0;
}