构造函数

std::deque<T,Allocator>::deque

deque();	(1)
explicit deque( const Allocator& alloc );	(2)
explicit deque( size_type count, const T& value = T(), const Allocator& alloc = Allocator());	(3)	(C++11 前)
deque( size_type count, const T& value, const Allocator& alloc = Allocator());	(3)	(C++11 起)
explicit deque( size_type count );	(4)	(C++11 起) (C++14 前)
explicit deque( size_type count, const Allocator& alloc = Allocator() );	(4)	(C++14 起)
template< class InputIt > deque( InputIt first, InputIt last, const Allocator& alloc = Allocator() );	(5)
deque( const deque& other );	(6)
deque( const deque& other, const Allocator& alloc );	(6)	(C++11 起)
deque( deque&& other );	(7)	(C++11 起)
deque( deque&& other, const Allocator& alloc );	(8)	(C++11 起)
deque( std::initializer_list<T> init, const Allocator& alloc = Allocator() );	(9)	(C++11 起)

从各种数据源构造新容器，可选地使用用户提供的分配器 alloc 。

1) 默认构造函数。构造拥有默认构造的分配器的空容器。

2) 构造拥有给定分配器 alloc 的空容器。

3) 构造拥有 count 个有值 value 的元素的容器。

4) 构造拥有个 count 默认插入的 T 实例的容器。不进行复制。

5) 构造拥有范围 [first, last) 内容的容器。

若 `InputIt` 是整数类型，则此构造函数拥有的效果同 deque(static_cast<size_type>(first), static_cast<value_type>(last), a) 。	(C++11 前)
此重载仅若`InputIt` 满足遗留输入迭代器 (LegacyInputIterator) 才参与重载决议，以避免和重载 (2) 的歧义。	(C++11 起)

6) 复制构造函数。构造拥有 other 内容的容器。若不提供 alloc ，则如同通过调用 std::allocator_traits<allocator_type>::select_on_container_copy_construction(other.get_allocator()) 获得分配器。

7) 移动构造函数。用移动语义构造拥有 other 内容的容器。分配器通过属于 other 的分配器移动构造获得。

8) 有分配器扩展的移动构造函数。以 alloc 为新容器的分配器，从 other 移动内容；若 alloc != other.get_allocator() ，则它导致逐元素移动。

9) 构造拥有 initializer_list init 内容的容器。

参数

alloc	-	用于此容器所有内存分配的分配器
count	-	容器的大小
value	-	以之初始化容器元素的值
first, last	-	复制元素的来源范围
other	-	用作初始化容器元素来源的另一容器
init	-	用作初始化元素来源的 initializer_list

复杂度

1-2) 常数

3-4) 与 count 成线性

5) 与 first 和 last 的距离成线性

6) 与 other 的大小成线性

7) 常数。

8) 若 alloc != other.get_allocator() 则为线性，否则为常数。

9) 与 init 的大小成线性。

异常

到 Allocator::allocate 的调用可能抛出。

注意

在容器移动构造（重载 (7) ）后，指向 other 的引用及迭代器（除了尾迭代器）保持合法，但指代现于 *this 中的元素。当前标准由 [container.requirements.general]/12 中的总括陈述作出此保证，而 LWG 2321 正在考虑更严格的保证。

析构函数

std::deque<T,Allocator>::~deque

~deque();

销毁容器。调用元素的析构函数，然后解分配所用的存储。注意，若元素是指针，则不销毁所指向的对象。

复杂度

与容器大小成线性。

调用示例

#include <iostream>
#include <deque>
#include <string>
#include <algorithm>
#include <iterator>

using namespace std;

int main()
{
    std::cout << std::boolalpha;

    {
        //1) 默认构造函数。构造拥有默认构造的分配器的空容器。
        std::deque<string> deque1;
        std::cout << "default structure: empty " << deque1.empty() << std::endl;
        std::cout << std::endl;
    }

    {
        //3) 构造拥有 count 个有值 value 的元素的容器。
        std::deque<string> deque2(10, "A");
        //打印容器
        std::copy(deque2.begin(), deque2.end(), std::ostream_iterator<string>(std::cout, " "));
        std::cout << std::endl;
        std::cout << std::endl;
    }

    {
        //4) 构造拥有个 count 默认插入的 T 实例的容器。不进行复制。
        std::deque<string> deque3(10);
        std::cout << "deque3 size: " << deque3.size() << std::endl;
        std::copy(deque3.begin(), deque3.end(), std::ostream_iterator<string>(std::cout, "-"));
        std::cout << std::endl;
        std::cout << std::endl;
    }

    {
        std::deque<string> deque1(10, "A");
        std::cout << "deque1:   ";
        std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<string>(std::cout, "-"));
        std::cout << std::endl;

        //5) 构造拥有范围 [first, last) 内容的容器。
        std::deque<string> deque2(deque1.begin(), deque1.end());
        std::cout << "deque2:   ";
        std::copy(deque2.begin(), deque2.end(), std::ostream_iterator<string>(std::cout, "-"));
        std::cout << std::endl;
        std::cout << std::endl;
    }

    {
        std::deque<string> deque1(10, "A");
        std::cout << "deque1:   ";
        std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<string>(std::cout, "-"));
        std::cout << std::endl;

        //6) 复制构造函数。构造拥有 other 内容的容器。
        std::deque<string> deque2(deque1);
        std::cout << "deque2:   ";
        std::copy(deque2.begin(), deque2.end(), std::ostream_iterator<string>(std::cout, "-"));
        std::cout << std::endl;
        std::cout << std::endl;
    }

    {
        std::deque<string> deque1(10, "A");
        std::cout << "deque1:   ";
        std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<string>(std::cout, "-"));
        std::cout << std::endl;

        //7) 移动构造函数。用移动语义构造拥有 other 内容的容器。分配器通过属于 other 的分配器移动构造获得。
        std::deque<string> deque2(std::move(deque1));
        std::cout << "deque1:   ";
        std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<string>(std::cout, "-"));
        std::cout << std::endl;

        std::cout << "deque2:   ";
        std::copy(deque2.begin(), deque2.end(), std::ostream_iterator<string>(std::cout, "-"));
        std::cout << std::endl;
        std::cout << std::endl;
    }

    {
        //9) 构造拥有 initializer_list init 内容的容器。
        std::deque<string> deque1({"A", "B", "C", "D", "E", "A", "B", "C", "E", "F"});
        std::cout << "deque1:   ";
        std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<string>(std::cout, "-"));
        std::cout << std::endl;

        std::deque<string> deque2{"A", "B", "C", "D", "E", "A", "B", "C", "E", "F"};
        std::cout << "deque2:   ";
        std::copy(deque2.begin(), deque2.end(), std::ostream_iterator<string>(std::cout, "-"));
        std::cout << std::endl;
    }

    return 0;
}