C++ STL 序列性容器之 std::deque 容器

最新推荐文章于 2024-06-28 17:54:02 发布

l357630798

最新推荐文章于 2024-06-28 17:54:02 发布

阅读量980

点赞数

分类专栏： C++ STL

本文链接：https://blog.csdn.net/l357630798/article/details/53609765

版权

C++ STL 专栏收录该内容

4 篇文章 2 订阅

订阅专栏

deque 是 double-ended deque 的缩写。它是一种动态数组形式，可以向两端发展，因此不论在尾部或头部插入元素，都十分迅速。在中间部分插入元素则比较费时，因为必须移动其他元素。这是一种随机访问的数据类型，提供了在序列两端快速插入和删除操作的功能，它可以在需要的时候修改其自身大小。也就是说这是一种双端队列容器，完成了标准的C++数据结构中队列的所有功能。deque对象在序列的两端放置元素和删除元素是高效的，而 vector 容器只是在插入序列尾部时操作才是高效的。

请看定义：

template<class T, class A = allocator<T> >    
class deque 
{
public:
	//定义内存分配器类型 A 的别名
    typedef A allocator_type;

	//定义内存分配器 A 大小的别名, 可以代表容器的长度的类型, uint
	typedef A::size_type size_type;

	//代表两个不同的元素之前地址差异的类型, int
    typedef A::difference_type difference_type;

	//T 的引用类型
    typedef A::reference reference;

	//T 的常量引用类型
    typedef A::const_reference const_reference;

	//对象类型T, 存储在 deque 容器中
    typedef A::value_type value_type;

	//定义访问 deque 的迭代器类型
	typedef T0 iterator;

	//定义访问 deque 的常量迭代器类型
    typedef T1 const_iterator;

	//定义访问 deque 的反向迭代器类型
	typedef reverse_iterator<iterator, value_type, reference, A::pointer, difference_type> reverse_iterator;

	//定义访问 deque 的常量反向迭代器类型
    typedef reverse_iterator<const_iterator, value_type, const_reference, A::const_pointer, difference_type> const_reverse_iterator;

	//默认构造函数, A为内存分配器
	explicit deque(const A& al = A());

	//构造函数, 构造 n 个值为 v 的元素
    explicit deque(size_type n, const T& v = T(), const A& al = A());

	//拷贝构造函数
    deque(const deque& x);

	//构造函数, 范围为 [first, last)
	deque(const_iterator first, const_iterator last, const A& al = A());

	//返回 deque 的头指针
	iterator begin();

	//返回 deque 的常量头指针
    const_iterator begin() const;

	//返回 deque 的尾指针
	iterator end();

	//返回 deque 的尾指针
	iterator end() const;

	//返回反向迭代器引用, 它指向 deque 的尾部
    reverse_iterator rbegin();

	//返回反向迭代器常量引用, 它指向 deque 的尾部
	const_reverse_iterator rbegin() const;

	//返回反向迭代器引用, 它指向 deque 第一个元素
    reverse_iterator rend();

	//返回反向迭代器常量引用, 它指向 deque 第一个元素
	const_reverse_iterator rend() const;

	//重新设置元素个数为 n, 确保 size() 返回值为 n
    void resize(size_type n, T x = T());

	//返回 deque 元素数量
	size_type size() const;

	//返回最大可允许的 deque 元素数量值
    size_type max_size() const;

	//判断 deque 是否为空
	bool empty() const;

	//返回保护成员, 内存分配器
    A get_allocator() const;

	//返回位置在 pos 的元素的引用
	reference at(size_type pos);

	//返回位置在 pos 的元素的常量引用
    const_reference at(size_type pos) const;

	//重载 [], 返回位置在 pos 的元素的引用
    reference operator[](size_type pos);

	//重载 [], 返回位置在 pos 的元素的常量引用
    const_reference operator[](size_type pos);

	//返回第一个元素的引用
	reference front();

	//返回第一个元素的常量引用
    const_reference front() const;

	//返回最后一个元素的引用
	reference back();

	//返回最后一个元素的常量引用
    const_reference back() const;

	//在 deque 的头部插入一个元素 x
	void push_front(const T& x);

	//删除第一个元素
    void pop_front();

	//在 deque 的尾部插入一个元素 x
	void push_back(const T& x);

	//删除最后一个元素
	void pop_back();

	//清空 deque 以前的内容, 并重新将范围为 [first, last) 的元素赋值给容器
    void assign(const_iterator first, const_iterator last);

	//清空 vector 以前的内容, 并重新将 n 个 x 赋值给 deque
    void assign(size_type n, const T& x = T());

	//在位置 it 前插入 x
    iterator insert(iterator it, const T& x = T());

	//在位置 it 前插入 n 个 x
    void insert(iterator it, size_type n, const T& x);

	//在位置 it 前插入范围为 [first, last) 的元素
    void insert(iterator it, const_iterator first, const_iterator last);

	//删除位置在 it 的元素
    iterator erase(iterator it);

	//删除在 [first, last) 范围内的元素
    iterator erase(iterator first, iterator last);

	//删除所有元素
	void clear();

	//交换两个 vector 的元素
    void swap(deque x);
protected:
	//内存分配器, 允许你自定义一个内存分配器. 如果不自定义, 就用默认的  
	//对内存分配会有特别的要求, 这时候就要自定一个分配器
	A allocator; 
};

(1) deque 容器的初始化与赋值

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

int main()
{
	//构造函数, 开辟10个元素, 初值全部为0
	std::deque<int> deq(10, 0);
	//首部插入两个元素
	deq.push_front(1);
	deq.push_front(2);
	//首部弹出一个元素
	deq.pop_front();
	//尾部插入两个元素
	deq.push_back(1);
	deq.push_back(2);
	//尾部弹出一个元素
	deq.pop_back();
	//遍历元素
	std::deque<int>::iterator iter;
	for (iter = deq.begin(); iter != deq.end(); iter++)
	{
		std::cout << *iter << std::endl;
	}
	return 0;  
}

(2) deque容器size()、max_size()、capacity()方法的使用：

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

int main()
{
	std::deque<std::string> deq;  

	//压入一个元素  
	deq.push_back("Element 1");  
	//.size(): 当前元素的个数  
	std::cout << "size() = " << deq.size() << std::endl;         //Output:1  
	//.max_size: 序列可控对象的个数, 允许开辟元素最大数量  
	std::cout << "max_size() = " << deq.max_size() << std::endl; //Output:134217727  
	
	//当前 deque 容器不支持使用 capacity() 计算容器的容量  
	//当前 deque 容器不支持使用 reserve() 预留空间  
 
	std::cout << "size() = " << deq.size() << std::endl;         //Output:1  
	std::cout << "max_size() = " << deq.max_size() << std::endl; //Output:134217727    

	//重新调整元素数量; 它不仅开辟了内存, 而且放置了空的新元素  
	deq.resize(2000);  
	std::cout << "size() = " << deq.size() << std::endl;         //Output:2000  
	std::cout << "max_size() = " << deq.max_size() << std::endl; //Output:134217727  

	return 0;
}

(3) deque 容器是否为空：

	//判断容器是否为空
	deq.empty();

(4) deque 容器之元素访问：

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

int main()
{
	std::deque<std::string> deq;  
	//首部插入元素
	deq.push_front("Element 1");
	//尾部插入元素
	deq.push_back("Element 2");
	
	//使用 for 循环访问
	for (size_t index = 0; index < deq.size(); index++)
	{
		//获取位置为 index 的元素
		std::cout << deq.at(index) << " == "<< deq[index] << std::endl;
	}
	
	//使用迭代器访问
	std::deque<std::string>::reverse_iterator riter;
	//如果是反向迭代器, 要全部是否反向迭代器 rbegin/ rend, 不能使用正向迭代器
	for (riter = deq.rbegin(); riter != deq.rend(); riter++)
	{
		std::cout << *riter << std::endl;;
	}
	return 0;
}

(5) deque 容器重置

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

int main()
{
	std::deque<std::string> deq_a;  
	//首部插入元素
	deq_a.push_front("Element 1");
	//尾部插入元素
	deq_a.push_back("Element 2");
	
	std::deque<std::string> deq_b;
	//重置容器b
	deq_b.assign(deq_a.rbegin(), deq_a.rend());
	//重置容器b
	deq_b.assign(3, "Element 3");

	return 0;
}

(6) deque 容器内容交换

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

int main()
{
	std::deque<std::string> deq_a;  
	//首部插入元素
	deq_a.push_front("Element 1");
	//尾部插入元素
	deq_a.push_back("Element 2");
	
	std::deque<std::string> deq_b;
	//重置容器b
	deq_b.assign(3, "Element 3");

	//交换
	deq_a.swap(deq_b);
	//算法交换
	std::swap(deq_a, deq_b);

	return 0;
}

(7) deque 容器的插入和删除

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

void Output(char c)
{
	std::cout << c << std::endl;
}

int main()
{
	//容器初始化, 3个字符 'A'
	std::deque<char> deq_char(3, 'A');  
	//首部插入1个元素, 'S'
	deq_char.insert(deq_char.begin(), 'S');
	//尾部插入5个元素, 'J'
	deq_char.insert(deq_char.end(), 5, 'J');
	//定义另一容器
	std::deque<char> other_deq_char(5, 'P');
	//首部插入新定义的一个容器
	deq_char.insert(deq_char.begin(), other_deq_char.begin(), other_deq_char.end());
	//输出
	std::for_each(deq_char.begin(), deq_char.end(), Output);//Output: PPPPPSAAAJJJJJ

	//删除首部第一个元素
	deq_char.erase(deq_char.begin());
	//删除全部元素
	deq_char.erase(deq_char.begin(), deq_char.end());
	//重新插入元素
	deq_char.insert(deq_char.begin(), other_deq_char.begin(), other_deq_char.end());
	//删除全部元素, 等同于 erase(begin(), end())
	deq_char.clear();

	return 0;
}

(8) deque 容器的操作运算符

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

int main()
{
	//deque 容器初始化
	std::deque<int> deq_a(5, 0);
	std::deque<int>::iterator iter = deq_a.begin();
	for (int index = 0; index < 5; index++)
	{
		*iter = index;
		iter++;
	}

	int num = 0;
	//获取第3个元素, value = 2
	num = deq_a[2];
	//获取第4个元素, value = 3
	num = deq_a[3];

	bool result = false;
	//判断容器是否相等
	std::deque<int> deq_b(5, 0);
	// "==" 操作运算符, 判断容器的内容是否完全相等, result = false
	result = (deq_a == deq_b) ? true : false;
	// "!=" 操作运算符, 判断容器的内容是否不相等, result = true
	result = (deq_a != deq_b) ? true : false; 
	// "<" 操作运算符, 容器的内容比对大小, result = false
	result = (deq_a < deq_b) ? true : false;
	// ">" 操作运算符, 容器的内容比对大小, result = true
	result = (deq_a > deq_b) ? true : false;

	deq_b.assign(deq_a.begin(), deq_a.end());
	// "==" 操作运算符, 判断容器的内容是否完全相等, result = true
	result = (deq_a == deq_b) ? true : false;
	// ">=" 操作运算符, 容器的内容比对大小, result = true
	result = (deq_a >= deq_b) ? true : false;
	// "<=" 操作运算符, 容器的内容比对大小, result = true
	result = (deq_a <= deq_b) ? true : false;
	return 0;
}

至此，deque 容器就告一段落了，接下来将介绍List容器。