【C++序列式容器】deque

秋秋晗晗

已于 2024-02-14 15:15:09 修改

阅读量285

点赞数 1

分类专栏： C++容器文章标签： c++

于 2023-07-11 19:36:22 首次发布

本文链接：https://blog.csdn.net/Qiuhan_909/article/details/131666558

版权

C++容器专栏收录该内容

12 篇文章 3 订阅

订阅专栏

deque

1. Member functions

1.1 constructor、destructor、operator=

1.1.1 constructor

1.1.2 destructor

1.1.3 operator=

1.2 Iterators

1.3 Capacity

1.4 Element access

1.5 Modifiers

1.6 Allocator

2. Non-member function overloads

2.1 relational operators

deque

template < class T, class Alloc = allocator<T> > class deque;

deque（通常发音为 "deck"）是双端队列的不规则缩写。双端队列是具有动态大小的序列容器，可以在两端（前端或后端）扩展或收缩。

特定的库可能以不同的方式实现deque，通常是某种形式的动态数组。但无论如何，它们都允许通过随机访问迭代器直接访问单个元素，并根据需要通过扩展和收缩容器自动处理存储。

因此，它们提供了与vector类似的功能，但可以在序列的开头（而不仅仅是结尾）有效地插入和删除元素。但是，与vector不同，deque不能保证将所有元素存储在连续的存储位置：通过偏移指向另一个元素的指针来访问deque中的元素会导致未定义的行为。

vector和deque都提供了非常相似的接口，可以用于类似的目的，但两者的内部工作方式截然不同： vector使用的是单个数组，偶尔需要重新分配以满足增长的需要，而deque的元素可以分散在不同的存储块中，容器内部保留了必要的信息，可以在恒定时间内通过统一的顺序接口（通过迭代器）直接访问其中的任何元素。因此，deque的内部结构要比vector复杂一些，但这使得它们在某些情况下能够更有效地增长，特别是在序列很长的情况下，重新分配的代价会更高。

对于在开头或结尾以外的位置频繁插入或移除元素的操作，deque的性能比list和forward_list差，迭代器和引用也不一致。

deque定义在头文件deque和命名空间std中。

1. Member functions

1.1 constructor、destructor、operator=

1.1.1 constructor

// default (1)
explicit deque(const allocator_type & alloc = allocator_type());
// fill(2)
explicit deque(size_type n);
deque(size_type n, const value_type & val, const allocator_type & alloc = allocator_type());
// range (3)
template <class InputIterator> deque(InputIterator first, InputIterator last, const allocator_type & alloc = allocator_type());
// copy (4)
deque(const deque & x);
deque(const deque & x, const allocator_type & alloc);
// move (5)
deque(deque && x);
deque(deque && x, const allocator_type & alloc);
// initializer list (6)
deque(initializer_list<value_type> il, const allocator_type & alloc = allocator_type());

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

template<typename T>
void printDq(deque<T>& dq)
{
	for (auto& e : dq)
	{
		cout << e << " ";
	}
	cout << endl;
}

int main()
{
	deque<int> dq1; // default
	printDq(dq1);   // 空

	deque<int> dq2(5); // fill
	printDq(dq2);      // 0 0 0 0 0

	deque<int> dq3(10, 1); // fill
	printDq(dq3);          // 1 1 1 1 1 1 1 1 1 1

	string s("hello world");
	deque<char> dq4(s.begin() + 3, --s.end()); // range
	printDq(dq4);                              // l o   w o r l

	deque<char> dq5(dq4); // copy
	// 等价于deque<char> dq5 = dq4;
	printDq(dq5);        // l o   w o r l

	deque<char> dq6(std::move(dq5));  // move
	cout << "dq5: ";    printDq(dq5); // dq5: 
	cout << "dq6: ";    printDq(dq6); // dq6: l o   w o r l

	deque<string> dq7{ "happy","new","year" }; // initializer list
	// 等价于deque<string> dq7 = { "happy","new","year" };
	printDq(dq7);                              // happy new year

	return 0;
}

1.1.2 destructor

~deque();

1.1.3 operator=

// copy (1)
deque& operator=(const deque& x);
// move (2)
deque& operator=(deque&& x);
// initializer list (3)
deque& operator=(initializer_list<value_type> il);

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

template<typename T>
void printDq(deque<T>& dq)
{
	for (auto& e : dq)
	{
		cout << e << " ";
	}
	cout << endl;
}

int main()
{
	deque<int> dq(5, 2);
	printDq(dq); // 2 2 2 2 2

	deque<int> dq1;
	dq1 = dq;     // copy
	printDq(dq1); // 2 2 2 2 2

	deque<int> dq2;
	dq2 = std::move(dq1);             // move
	cout << "dq1: ";    printDq(dq1); // dq1: 
	cout << "dq2: ";    printDq(dq2); // dq2: 2 2 2 2 2

	deque<int> dq3;
	dq3 = { 1,2,3,4,5,6 }; // initializer list
	printDq(dq3);          // 1 2 3 4 5 6

	return 0;
}

1.2 Iterators

// begin
iterator begin() noexcept;
const_iterator begin() const noexcept;
// end
iterator end() noexcept;
const_iterator end() const noexcept;
// rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept;
// rend
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept;
// cbegin
const_iterator cbegin() const noexcept;
// cend
const_iterator cend() const noexcept;
// crbegin
const_reverse_iterator crbegin() const noexcept;
// crend
const_reverse_iterator crend() const noexcept;

函数	功能
begin & end	begin返回一个迭代器，指向deque对象的第一个元素 end返回一个迭代器，指向deque对象的最后一个元素的下一个位置
rbegin & rend	rbegin返回一个反向迭代器，指向deque对象的最后一个元素 rend返回一个反向迭代器，指向deque对象的第一个元素的上一个位置
cbegin & cend	cbegin返回一个const迭代器，指向deque对象的第一个元素 cend返回一个const迭代器，指向deque对象的最后一个元素的下一个位置
crbegin & crend	crbegin返回一个const反向迭代器，指向deque对象的最后一个元素 crend返回一个const反向迭代器，指向deque对象的第一个元素的上一个位置

函数

功能

begin

end

begin返回一个迭代器，指向deque对象的第一个元素

end返回一个迭代器，指向deque对象的最后一个元素的下一个位置

rbegin

rend

rbegin返回一个反向迭代器，指向deque对象的最后一个元素

rend返回一个反向迭代器，指向deque对象的第一个元素的上一个位置

cbegin

cend

cbegin返回一个const迭代器，指向deque对象的第一个元素

cend返回一个const迭代器，指向deque对象的最后一个元素的下一个位置

crbegin

crend

crbegin返回一个const反向迭代器，指向deque对象的最后一个元素

crend返回一个const反向迭代器，指向deque对象的第一个元素的上一个位置

begin&end和rbegin&rend返回的迭代器指向：

const_iterator是一个指向const内容的迭代器。迭代器本身可以修改，但是它不能被用来修改它所指向的内容。

begin&end/rbegin&rend和cbegin&cend/crbegin&crend的不同：

begin&end/rbegin&rend的返回类型由对象是否是常量来决定。如果不是常量，返回iterator；如果是常量，返回const_iterator。
cbegin&cend/crbegin&crend的返回类型是const_iterator，不管对象本身是否是常量。

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

int main()
{
	deque<int> dq{ 1,2,3,4 };

	deque<int>::iterator it = dq.begin();
	while (it != dq.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	// 1 2 3 4

	auto rit = dq.rbegin();
	// deque<int>::reverse_iterator rit = dq.rbegin();
	while (rit != dq.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
	// 4 3 2 1

	return 0;
}

1.3 Capacity