C++ STL标准库：std::deque 获取位置迭代器 begin() end() rbegin() rend() front() back() assign()的使用_std 队列迭代-

std::deque::begin

函数原型：
      iterator begin() noexcept;
const_iterator begin() const noexcept;
返回容器开头的迭代器 
返回一个迭代器，该迭代器指向双端队列容器中的第一个元素。 
注意，与成员deque :: front不同，该成员返回对第一个元素的引用，该函数返回指向它的随机访问迭代器。 
如果容器为空，则不应取消对返回的迭代器值的引用。 
参数：
 无 
返回值：
 序列容器开头的迭代器。 
如果双端队列对象是const限定的，则该函数返回const_iterator。 否则，它返回一个迭代器。 
成员类型迭代器和const_iterator是随机访问迭代器类型（分别指向元素和const元素）。 
std::deque::end
 
函数原型： 
      iterator end() noexcept;
const_iterator end() const noexcept;
返回迭代器到结束 
返回一个迭代器，该迭代器引用双端队列容器中的past-the-end元素。 
过去的元素是理论上的元素，该元素将跟随双端队列容器中的最后一个元素。 它没有指向任何元素，因此不应取消引用。 
由于标准库函数使用的范围不包括其闭合迭代器指向的元素，因此该函数通常与deque :: begin结合使用以指定包含容器中所有元素的范围。 
如果容器为空，则此函数返回与deque :: begin相同的结果。 
参数：
 无 
返回值：
 序列结束后元素的迭代器。 
如果双端队列对象是const限定的，则该函数返回const_iterator。 否则，它返回一个迭代器。 
成员类型迭代器和const_iterator是随机访问迭代器类型（分别指向元素和const元素）。 
std::deque::rbegin
 
函数原型： 
	  reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept;
将反向迭代器返回到反向开始处 
返回指向容器中最后一个元素的反向迭代器（即其反向开始处）。 
反向迭代器向后迭代：增加迭代器会将其移向容器的开头。 
rbegin指向成员结尾所指向元素之前的元素。 
请注意，与成员deque :: back不同，该成员返回对该相同元素的引用，该函数返回反向随机访问迭代器。 
参数：
 无 
返回值：
 反向迭代器，用于序列容器的反向开始。 
如果双端队列对象是const限定的，则该函数将返回const_reverse_iterator。 否则，它返回一个reverse_iterator。 
成员类型reverse_iterator和const_reverse_iterator是反向随机访问迭代器类型（分别指向元素和const元素）。 请参阅双端队列成员类型。 
std::deque::rend
 
函数原型： 
      reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept;
将反向迭代器返回到反向端 
返回一个反向迭代器，该反向迭代器指向双端队列容器中第一个元素之前的理论元素（被视为其反向端）。 
deque :: rbegin和deque :: rend之间的范围包含deque容器的所有元素（顺序相反）。 
参数：
 无 
返回值：
 序列容器反向端的反向迭代器。 
如果双端队列对象是const限定的，则该函数将返回const_reverse_iterator。 否则，它返回一个reverse_iterator。 
成员类型reverse_iterator和const_reverse_iterator是反向随机访问迭代器类型（分别指向元素和const元素）。 请参阅双端队列成员类型。 
std::deque::cbegin (c++11)
 
函数原型： 
const_iterator cbegin() const noexcept;
返回const_iterator到开头 
返回一个const_iterator指向容器中的第一个元素。 
const_iterator是指向const内容的迭代器。 可以增加和减少此迭代器（除非它本身也是const的），就像deque :: begin返回的迭代器一样，但是即使deque对象本身不是const，也不能用来修改它指向的内容。 
如果容器为空，则不应取消对返回的迭代器值的引用。 
参数：
 无 
返回值：
 序列开头的const_iterator。 
成员类型const_iterator是指向const元素的随机访问迭代器类型。 
std::deque::cend(c++11)
 
函数原型： 
const_iterator cend() const noexcept;
返回const_iterator至end 
返回一个const_iterator，该const_iterator指向容器中的past-the-end元素。 
const_iterator是指向const内容的迭代器。 可以增加和减少此迭代器（除非它本身也是const），就像deque :: end返回的迭代器一样，但是即使deque对象本身不是const，也不能用来修改它指向的内容。 
如果容器为空，则此函数返回与deque :: cbegin相同的结果。 
返回的值不得取消引用。 
参数：
 无 
返回值：
 序列结束后元素的const_iterator。 
成员类型const_iterator是指向const元素的随机访问迭代器类型。 
std::deque::crbegin (c++11)
 
函数原型： 
const_reverse_iterator crbegin() const noexcept;
返回const_reverse_iterator以反向开始 
返回const_reverse_iterator指向容器中的最后一个元素（即其反向开始）。 
参数：
 无 
返回值：
 一个const_reverse_iterator到序列的反向开始。 
成员类型const_reverse_iterator是指向const元素的反向随机访问迭代器类型（请参见双端队列成员类型）。 
std::deque::crend(c++11)
 
函数原型： 
const_reverse_iterator crend() const noexcept;
返回const_reverse_iterator到crend 
返回const_reverse_iterator指向容器中第一个元素之前的理论元素（被视为其反向端）。 
参数：
 无 
返回值：
 序列相反端的const_reverse_iterator。 
成员类型const_reverse_iterator是指向const元素的反向随机访问迭代器类型（请参见双端队列成员类型）。 
#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;
void Out(double& Ele)
{	cout.width(5);
	cout.precision(1);
	cout<<std::fixed<<Ele<<" ";
void main()
	deque<double>::iterator Iter;
	deque<double>::reverse_iterator rIter;
	deque<double> D1,D2,D3;
	for(int i=0;i<10;i++)
		D1.push_front(90+i/10.0);
	cout<<"All the element of 双端序列 D1:" <<endl;
	for_each(D1.begin(),D1.end(),Out);
	cout<<endl;
	Iter=D1.begin();
	double begin=*Iter;
	Iter=D1.end();
	double end=*(--Iter);
	rIter=D1.rbegin();
	double rbegin=*(rIter);
	rIter=D1.rend();
	double rend=*(--rIter);
	//Iter=D1.front();
	double front=D1.front();
	//Iter=D1.back();
	double back=D1.back();
	cout<<" begin :"<<begin<<","<<" end :"<<end<<","<<" front :"<<front<<","<<" back :"<<back<<endl;
	cout<<" reverse begin :"<<rbegin<<" reverse end :"<<rend<<","<<endl;
	if(D1.empty())
		cout<<"双端序列为空."<<endl;
		int size=D1.size();
		cout<<"双短序列中包含"<<size<<"个元素."<<endl;
	double five=D1.at(5);
	cout<<"第五个元素是"<<five<<"."<<endl;
	/*初始D2,D3*/
	D2.assign(6,0);
	cout<<"All the element of 双端序列 D2:" <<endl;
	for_each(D2.begin(),D2.end(),Out);
	cout<<endl;
	D3.assign(D1.begin(), D1.end());
	cout<<"All the element of 双端序列 D3:" <<endl;
	for_each(D3.begin(),D3.end(),Out);
	cout<<endl;
                                    我们在前面说stack的时候已经说过了什么叫容器适配器，如果有不了解的，可以去前面看一看。
这里呢，我们主要讲下queue，作为生活里面我们司空见惯了的现像，应该是不叫好理解的。
1、queue容器的定义
和 stack 栈容器适配器不同，queue 是一种先进先出（FIFO）的数据结构，queue 容器适配器有 2 个开口，其中一个开口专门用来输入数据，另一个专门用来输出数据。但是queue元素的加入和取出是固定的，比如加入只能在队尾加入，取出只能在队前，其他地方都不能进行元素的操作。简单的说，queue
deque: double-end queue，双端队列
std::deque  不像 vector 把所有的对象保存在一块连续的内存块，而是采用多个连续的存储块，在一个映射结构中对这些内存块及顺序进行跟踪。
优点快速地随机访问，支持[ ]操作符和at()。首尾两端进行快速的push、pop操作O(1)，支持其他位置插入和删除操作O(n) 。
缺点:内存占用较多。
 1. deque、构造函数1.1 deque简介
1. deque、构造函数
1.1 deque简介
  std::dequ.
                                    1. 基础
deque容器为一个给定类型的元素进行线性处理，像向量一样，它能够快速地随机访问任一个元素，并且能够高效地插入和删除容器的尾部元素。但它又与vector不同，deque支持高效插入和删除容器的头部元素，因此也叫做双端队列。deque类常用的函数如下。
需要引用:
#include <deque>
2. 申明
std::cout << " ---------- init deque -----------" << std::endl;
// 方式一: 创建一个空
                                    c++ vector begin(),end(),rbegin(),rend()问题
置顶 小白的进阶 2016-06-02 15:38:33  15517  收藏 9
C++ primer （中文版第四版）第273页
9.3.2 begin和end成员
begin和end操作产生指向容器内第一个元素和最后一个元素的下一个位置的迭代器。这两个迭代器通常用于标记包含容...
迭代器（iterator）有时又称游标（cursor）是程序设计的软件设计模式，可在容器（container，例如链表或阵列）上遍访的接口，设计人员无需关心容器的内容。
简单来说，迭代器就相当于一个指针，通过这个指针我们可以对一些容器进行遍历。解决了容器底层空间遍历时不连续的问题。
正向迭代器
容器类名::iterator 迭代器名;
//正向遍历的思想
int array[]={1,2,3,4,5,6,7,8,9,0};
for(int i = 0;i<sizeof(array)/siz
str.begin()；指向字符串的第一个字符的位置
str.end();指向字符串的最后一个字符的后一个位置；
str.rbegin();指向字符串的最后一个字符的位置；
str.rend();指向第一个字符串的前一个位置；
str.begin()++；向后面的位置移动（从首字符向尾字符移动）；
str.rbegin()++；向前面的位置移动（从尾字符向首字符移动）；
void test()
	string str = "1234";
	cout << *str
deque(发音类似“deck”)，是双端队列不规则的首字母缩写，双端队列是动态大小的序列式容器，其可
以像两端进行伸缩。
特定的库可以以不同的方式实现deque，但通常都是一种动态数组。不论在何种情况下，它都允许通过
随机访问迭代器直接访问单个元素，可以根据需要动态的伸缩。
因此，deque提供了一些与vector相似的功能，但deque在头部和尾部进行数据插入和删除操作更...
  使用下标访问对象的成员的最基本方法有三种：string对象的字符访问，vector对象的元素访问，迭代器。
  迭代器类似于指针类型，也提供了对对象的间接访问。使用迭代器可以访问某个元素，也能从一个元素移动到另外一个元素。迭代器分为有效和无效，有效的迭代器或者指向某个元素，或者指向容器中尾元素的下一个位置，其他所有情况都属于无效。
2. 使用迭代器
  有迭代器的类型都拥有名为begin和end的成员，其中begin成员负责返回指...