STD DEQUE

最新推荐文章于 2024-02-18 12:16:46 发布
最新推荐文章于 2024-02-18 12:16:46 发布
阅读量841 收藏 1
点赞数
分类专栏： C++ semantic

Deque

std::deque（双端队列）时一种支持索引的序列容器，在双端允许快速插入和删除。另外，在双端的插入和删除不会使剩余元素的指针和引用非法。

相较于std::vector，deque的元素不是连续存储的：典型的实现使用单独分配的固定大小的数组序列，用额外的记录记录数组单元的序列。这意味着deque的索引访问必须执行两次指针解引用。

deque 的存储空间会自动依据需求去拓展和收缩。deque的拓展较vector更加的cheaper，因为不会将存在的元素进行拷贝到一个新的存储空间。另一方面，deque通常有很大的最小内存成本；仅有一个元素的deque对象需要分配整个内在数组。

deque上的常规操作的复杂度（效率）如下：

  • 随机访问-constant O(1)
  • 首位插入和删除-constant O(1)
  • 元素的插入和删除-线性 O(n)

std::deque 满足 Container， AllocatorAwareContainer, SequeuceContainer 和 ReversibleContainer

指导思想

典型实现用单独分配的固定大小数组的序列。

关于buffer

inline size_t __deque_buf_size(size_t __size) {
	return __size < 512 ? size_t(512 / __size) : size_t(1);
}
  • 固定大小(512字节)的buffer能容纳的最大目标类型数量。
  • buffer即为典型实现用单独分配的固定大小数组。

迭代器

  • 迭代器类型为随机访问迭代器，实现[n]、+n
template <class _Tp, class _Ref, class _Ptr>
struct _Deque_iterator {
	typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
	typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
	static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }
	
	typedef random_access_iterator_tag iterator_category;
	typedef _Tp value_type;
	typedef _Ptr pointer;
	typedef _Ref reference;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	typedef _Tp** _Map_pointer;
	
	typedef _Deque_iterator _Self;

	_Tp* _M_cur;		// 当前指向的元素
	_Tp* _M_first;		// 本数组的第一个元素
	_Tp* _M_last;		// 本数组的最后一个元素
	_Map_point _M_node; // 代表本数组在双端队列中的结点

	_Deque_iterator(_Tp* __x, _Map_pointer __y) 
		: _M_cur(__x), _M_first(*__y), _M_last(*__y + _S_buffer_size()), _M_node(__y) {}
	——Deque_iterator() :_M_cur(0), _M_cur(0), _M_frist(0), _M_last(0). _M_node(0) {}

	_Deque_iterator(const iterator& __x) 
		: _M_cur(__x._M_cur),_M_first(__x._M_first), _M_last(__x._M_last), _M_node(__x._M_node) {}
}

reference operator* const {return *_M_cur; }
pointer operator->() const { return _M_cur; }

difference_type operator-(const Self& __x) const {
	return difference_type(S_buffer_size()) * (_M_node - _x._M_node - 1) + 
	(_M_cur - _M_first) + (__x._M_last - __x.M_cur);
}

_Self& operator++() {
	++_M_cur;
	if(_M_cur == _M_last) {
		_M_set_node(_M_node + 1);
		_M_cur = _M_first;
	}
	return *this;
}

_Self operator++(int) {
	_Self __tmp = *this;
	++*this;
	return __tmp;
}

_Self& operator--() {
	if(_M_cur == _M_start) {
		_M_set_node(_M_node -1)
		_M_cur = _M_last;
	}
	--_M_cur;
	return *this;
}

_Self operator--(int) {
	_Self __tmp = *this;
	--*this;
	return __tmp;
}

_Self& operator+=(difference_type __n) {
	difference_type __offset = __n + (_M_cur - _M_first);
	if(__offset >= 0 && __offset < diffence_type(_S_buffer_size()))
		_N_cur += __n;
	else
		difference_type __node_offset = 
			__offset > 0 ? __offset / difference_type(_S_buffer_size())
			                   : -difference_type((-__offset - 1) / _S_buffer_size())-1;
      _M_set_node(_M_node + __node_offset);
      _M_cur = _M_first + 
        (__offset - __node_offset * difference_type(_S_buffer_size()));
    }
    return *this;
}
}

分配器

template <class _Tp, class _Alloc, bool __is_static>
class _Deque_alloc_base {
public:
	typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;
	// 节点分配器处理的类型为_Tp
	allocator_type get_allocator() const { return _M_node_allocator; }
	_Deque_alloc_base(const allocator_type& __a)
		: _M_node_allocator(__a), _M_map_allocator(__a), _M_map(0), _M_map_size(0) {
	}
protected:
	typedef typename _Alloc_traits<_Tp*, _Alloc>::allocator_type _Map_allocator_type;
	// 映射分配器处理的类型为_Tp*
	allocator_type _M_node_allocator;
	_Map_allocator_type _M_map_allocator;
	
	// 分配__deque_buf_size(sizeof(_Tp))个Tp的内存， 并返回起始地址
	_Tp* _M_allocate_node() {
		return _M_node_allocator.allocate(__deque_buf_size(sizeof(_Tp)));
	}
	// 释放__deque_buf_size(sizeof(_Tp))个Tp的内存， 起始地址为__p
	void _M_deallocate_node(_Tp* __p) {
		_M_node_allocator.dellocate(__p, __deque_buf_size(sizeof(_Tp)))
	}
	// 分配n个字节的内存空间以存储_Tp*，返回起始地址_Tp**
	_Tp** _M_allocate_map(size_t __n) {
		return _M_map_allocator.allocate(__n);
	}	
	// 释放n个Tp*的内存， 起始地址为__p
	void _M_deallocate_map(_Tp** __p, size_t __n) {
		_M_map_allocator.deallocate(__p, __n);
	}
	
	_Tp** _M_map;			// 映射表起始地址
	size_t _M_map_size;		// 映射表大小
};

静态版本，使用静态函数实现内存分配和回收。

template <class _Tp, class _Alloc>
class _Deque_alloc_base<_Tp, _Alloc, true> {
public:
	typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;
	allocator_type get_allocator() const { return allocator_type(); }
	
	_Deque_alloc_base(const allocator_type&) : _M_map(0), _M_map_size(0) {}
protected:
	typedef typename _Alloc_traits<_Tp, _Alloc>::_Alloc_type _Node_alloc_type;
	typedef typename _Alloc_traits<_Tp*, _Alloc>::_Alloc_type _Map_alloc_type;

		// 分配__deque_buf_size(sizeof(_Tp))个Tp的内存， 并返回起始地址
	_Tp* _M_allocate_node() {
		return _Node_alloc_type::allocate(__deque_buf_size(sizeof(_Tp)));
	}
	// 释放__deque_buf_size(sizeof(_Tp))个Tp的内存， 起始地址为__p
	void _M_deallocate_node(_Tp* __p) {
		_Node_alloc_type::dellocate(__p, __deque_buf_size(sizeof(_Tp)))
	}
	// 分配n个字节的内存空间以存储_Tp*，返回起始地址_Tp**
	_Tp** _M_allocate_map(size_t __n) {
		return _Map_alloc_type::allocate(__n);
	}	
	// 释放n个Tp*的内存， 起始地址为__p
	void _M_deallocate_map(_Tp** __p, size_t __n) {
		_Map_alloc_type::deallocate(__p, __n);
	}  
}

Deque

template <class _Tp, class _Alloc>
class _Deque_base : public _Deque_alloc_base<_Tp, _Alloc, 
											_Alloc_traits<_Tp, _Alloc>::_S_instanceless> {
public:
	typedef _Deque_alloc_base<_Tp, _Alloc, 
							_Alloc_traits<_Tp, _Alloc>::_S_instanceless> 
			_Base;
	typedef typename _Base::allocator_type allocator_type;
	typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
	typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
	
	_Deque_base(const allocator_type& __a, size_t __num_elements)
		: _Base(__a), _M_start(), _M_finish() {
		_M_initialize_map(__num_elements);
	}
	_Deque_base(const allocator_type& __a) : _Base(__a), _M_start(), _M_finish() {
	
	}
	~_Deque_base();
protected:
	void _M_initialize_map(size_t);
	void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
	void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
	enum { _S_initial_map_size = 8 };
protected:
	iterator _M_start;
	iterator _M_finish;
}

定义

template class<class _Tp, class _Alloc>
_Deque_base<_Tp, _Alloc>::~Deque_base() {
	if(_M_map) {
		// 释放所有迭代器指向的节点(buffer)
		_M_destroy_nodes(_M_start._M_node, _M_finish._M_node + 1);
		// 释放映射表所占据的连续内存(数组)
		_M_deallocate_map(_M_map, _M_map_size);
	}
}

template<class _Tp, class _Alloc>
void _Deque_base<_Tp, _Alloc>::_M_initialize_map(size_t __num_elements) {
	size_t __num_nodes = 
		__num_elements / __deque_buf_size(sizeof(_Tp)) + 1;
	_M_map_size = max((size_t)_S_initial_map_size, __num_nodes + 2);
	_M_map = _M_allocate_map(_M_map_size);
	// 映射首尾至少各留出一个节点指针用于未来的增长，没有分配元素
	_Tp** _nstart = _M_map + (_M_map + (_M_map_size - __num_nodes))/2
	_Tp** __nfinish = __nstart + __num_nodes;
	__STL_TRY {
		_M_create_nodes(__nstart, __nfinish);
	}
	__STL_UNWIND((_M_Deallocate_map(_M_map, _M_map_size), 
				  _M_map = 0, _M_mmap_size = 0));
	// 迭代器绑定节点
	_M_start._M_set_node(__nstart);
	_M_finish._M_set_node(_nfinish-1);
	_M_start._M_cur = _M_start._M_first;
	_M_finish._M_cur = _M_finish._M_first + __num_elements 
		% __deque_buf_size(sizeof(_Tp)); 
}

template <class _Tp, class _Alloc>
void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
{
 	_Tp** __cur;
	__STL_TRY {
    	for (__cur = __nstart; __cur < __nfinish; ++__cur)
      		*__cur = _M_allocate_node();
  	}
  	__STL_UNWIND(_M_destroy_nodes(__nstart, __cur));
}

template <class _Tp, class _Alloc>
void _Deque_base<_Tp, _Alloc>::_M_destory_nodes(_Tp** __nstart, _Tp** __nfinish) {
	for(_Tp** __n = __nstart; __n < __nfinish; ++__n) {
		_M_deallocate_node(*__n);
	}
}

template <class _Tp, class _Alloc>
class deque : protected _Deque_base<_Tp, _Alloc> {
	typedef _Deque_base<_Tp, _Alloc> _Base;
public:
	typedef _Tp value_type;
	typedef value_type* pointer;
	typedef const value_type* const_pointer;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;

	typedef typename _Base::allocator_type allocator_type;
	allocator_type get_allocator() const { return _Base::get_allocator(); }

public:
	typedef typename _Base::iterator iterator;
	typedef typename _Base::const_iterator const_iterator;
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
	typedef reverse_iterator<const_iterator> const_reverse_iterator;
	typedef reverse_iterator<iterator> reverse_iterator;
#else
	typedef reverse_iterator<const_iterator, value_type, 
							const_reference, difference_type>
			const_reverse_iterator;
	typedef reverse_iterator<iterator, value_type,
							reference, difference_type>
			reverse_iterator;
#endif

protected:
	typedef pointer* _Map_pointer; // value_type**
	static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); } // 一个buffer(节点)能存储多少个对象(元素)。
protected:
#ifdef __STL_USE_NAMESPACES
	using _Base::_M_initialize_map;  // 初始化Map需要的内存，为Map元素添加指向的节点
	using _Base::_M_create_nodes; // 为范围内节点分配内存
	using _Base::_M_destroy_nodes; // 释放范围内节点内存
	using _Base::_M_allocate_node; // 为单个节点分配内存
	using _Base::_M_deallocate_node; // 为单个节点释放内存
	using _Base::_M_allocate_map; // 为Map分配内存
	using _Base::_M_deallocate_map; // 释放Map内存

	using _Base::_M_map;
	using _Base::_M_map_size;
	using _Base::_M_start;
	using _Base::_M_finish;
#endif

public:
	iterator begin() { return _M_start; }
	iterator end() { return _M_finish; }
	const_iterator begin() const { return _M_start; }
	const_iterator end() const { return _M_finish; }
	
	reverse_iterator rbegin() { return reverse_iterator(_M_finish); }
	reverse_iterator rend() { return reverse_iterator(_M_start); }
	
	const_reverse_iterator rbegin() const { return const_reverse_iterator(_M_finish); }
	const_reverse_iterator rend() const { return const_reverse_iterator(_M_start); }
	
	reference operator[](size_type __n) 
		{ return _M_start[difference_type(__n)]; }
	
	const_reference operator[](size_type __n) const
		{ return _M_start[difference_type(__n)]; }

#ifdef __STL_THROW_RANGE_ERRORS
	void _M_range_check(size_type __n) const {
		if(__n >= this->size())
			__stl_throw_range_error("deque");
	}
	
	reference at(size_type __n) 
	{ _M_range_check(__n); return (*this)[__n]; }
	const_reference at(size_type __n) const
	{ _M_range_check(__n); return (*this)[__n]; }
#endif

reference front() { return *_M_start; }
reference back() {
	iterator __tmp = _M_finish;
	--__tmp;
	return *__tmp;
}

size_type size() const { return _M_finish - _M_start; }
size_type max_size() const { return size_type(-1); }
bool empty() const { return _M_finish == _M_start; }

public：
explicit deque(const allocator_type& __a = allocator_type())
	: _Base(__a, 0) {}

deque(const deque& __x) : _Base(_x.get_allocator(), __x.size()) {
	uninitialized_copy(__x.begin(), __x.end(), _M_start);
}

deque(size_type __n, const value_type& __value, 
	  const allocator_type& __a = allocator_type()) : _Base(__a, __n) 
	  { _M_fill_initialize(__value); }
explicit deque(size_type __n) : _Base(allocator_type(), __n) {
	_M_fill_initialize(value_type());
}

#ifdef __STL_MEMBER_TEMPLATES
template <class _InputIterator>
deque(_InputIterator __first, _InputIterator __last, 
	  const allocator_type& __a = allocator_type()) : Base(__a) {
	typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
	_M_initialize_dispatch(__first, __last, _Integral());
}

template <class _Integer>
void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) {
	_M_initialize_map(__n);
	_M_fill_initialize(__x);
}

template <class _InputIter>
void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, __false_type) { _M_range_initialize(__first, __last, __ITERATOR_CATEGORY(__first)); }

#else

deque(const value_type* __first, const value_type* __last, 
		const allocator_type& __a = allocator_type())
		: _Base(__a, __last - __first) {
	uninitialize_copy(__first, __last, _M_start);
}

deque(const_iterator __first, const_iterator __last,
	const allocator_type& __a = allocator_type()) 
    : _Base(__a, __last - __first)
{ uninitialized_copy(__first, __last, _M_start); }

#endif

~deque() { destory(_M_start, _M_finish); } // 存储元素主动调用析构函数

deque& operator=(const deque& __x) {
	const size_type __len = size();
	if(&__x != this) {
		if(_len >= __x.size())
			erase(copy(__x.begin(), __x.end(), _M_start), _M_finish);
		else {
			const_iterator __mid = __x.begin() + difference_type(__len);
			copy(__x.begin(). __mid, _M_start);
			insert(_M_finish, __mid, __x.end());
		}
	}
	return *this;
}

void swap(deque& __x) {
	__STD::swap(_M_start, __x._M_start);
	__STD::swap(_M_finish, __x._M_finish);
	__STD::swap(_M_map, __x._M_map);
	__STD::swap(_M_map_size, __x._M_map_size);
}
}

public:
	void assign(size_type __n, const _Tp& __val) {
		_M_fill_assign(__n, __val);
	}
	
	void _M_fill_assign(size_tyoe __n, const _Tp& __val) {
		if(__n > size()) {
			fill(begin(), end(), __val);
			insert(end(), __n - size(), __val);
		}
		else {
			erase(begin() + n, end());
			fill(begin(), end(), __val);
		}
	}

push_back

public:
	// _M_finish._M_last 本buffer结束标记，不能赋值。
	void push_back(const value_type& __t) {
		if(_M_finish._M_cur != _M_finish._M_last - 1) {
			construct(_M_finish._M_cur, __t);
			++_M_finish._M_cur;
		}
		else
			_M_push_back_aux(__t);
	}
	
	void _M_push_back_aux(const value_type& __t) {
		value_type __t_copy = __t;
		_M_reserve_map_at_back();
		*(_M_finish._M_node + 1) = _M_allocate_node(); // 分配尾部新节点
		_STL_TRY {
			// 将原来的超尾迭代器，重新构造赋值
			construct(_M_finish._M_cur, __t_copy); 
			// 重设超尾迭代器关联节点和指向超尾元素
			_M_finish._M_set_node(_M_finish._M_node + 1);
			_M_finish._M_cur = _M_finish._M_first;
		}	
		__STL_UNWIND(_M_deallocate_node(*(_M_finish._M_node + 1)));
	}
	
	void _M_reserve_map_at_back(size_type __nodes_to_add = 1) {
		if(__nodes_to_add + 1 > _M_map_size - (_M_finish._M_node - _M_map)) {
			_M_reallocate_map(__nodes_to_add, false);
		}
	}

	void _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front) {
		size_type __old_num_nodes = _M_finish._M_node - _M_start._M_node + 1;
		size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
		
		_Map_pointer __new_nstart;
		if(_M_map_size > 2*__new_num_nodes) {
			__new_nstart = _M_map + (_M_map_size - __new_num_nodes) / 2 
							+ (__add_at_front ? __nodes_to_add : 0);
			if(__new_nstart < _M_start._M_node)
				copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);
			else
				copy_backward(_M_start._M_node, _M_finish._M_node + 1,
							  __new_nstart + __old_num_nodes);
		}
		else {
			size_type __new_map_size = 
				_M_map_size + max(_M_map_size, __nodes_to_add) + 2;
			
			_Map_pointer __new_map = _M_allocate_map(__new_map_size);
			__new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
							+ (__add_at_front ? __nodes_to_add : 0);
			copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);
			_M_deallocate_map(_M_map, _M_map_size);
			
			_M_map = __new_map;
			_M_map_size = __new_map_size;
		}
		
		_M_start._M_set_node(__new_nstart);
		_M_finish._M_set_node(__new_nstart + old_num_nodes - 1);
	}

	void push_back() {
		if(_M_finish._M_cur != _M_finish._M_last - 1) {
			construct(_M_start._M_cur);
			++_M_start._M_cur;
		}
		else
			_M_push_back_aux(__t);
	}

push_front

void push_front(const value_type& __t) {
	if(_M_start._M_cur != _M_start._M_first) { //
		construct(_M_start._M_cur - 1, __t);
		--_M_start._M_cur;
	}
	else
		_M_push_front_aux(__t);
}

void _M_push_front_aux(const value_type& __t) {
	value_type __t_copy = __t;
	_M_reserve_map_at_front();
	*(_M_start._M_node - 1) = _M_allocate_node();
	_STL_TRY {
		_M_start._M_set_node(_M_start._M_node - 1);
		_M_start._M_cur = _M_start._M_last - 1;
		construct(_M_start._M_cur, __t_copy);
	}
	__STL_UNWIND(++_M_start, _M_deallocate_node(*(_M_start._M_node - 1)));
}

void push_front() {
	if(_M_start._M_cur != _M_start.first) {
		construct(_M_start._M_cur - 1);
		--_M_start._M_cur;
	}
	else 
		_M_push_front_aux();
}

pop_back

void pop_back() {
	if(_M_finish._M_cur != _M_finish._M_first) {
		--_M_finish._M_cur;
		destory(_M_finish._M_cur);
	}
	else 
		_M_pop_back_aux();
}

void _M_pop_back_aux() {
	_M_deallocate_node(_M_finish._M_first);
	_M_finish._M_set_node(_M_finish._M_mode - 1);
	_M_finish._M_cur = _M_finish._M_last - 1;
	destroy(_M_finish._M_cur);
}

pop_front

void pop_front() {
	if(_M_start._M_cur != _M_start._M_last - 1) {
		destory(_M_start._M_cur);
		--_M_start._M_cur--;
	}
	else
		_M_pop_front_aux();
}

void _M_pop_front_aux() {
	destroy(_M_start._M_cur);
	_M_deallocate_node(_M_start._M_first);
	_M_start._M_set_node(_M_start._M_node + 1);
	_M_start._M_cur = _M_start._M_first;
}

Insert

iterator insert(iterator position, const value_type& __x) {
	if(position._M_cur == _M_start._M_cur) {
		push_front(__x);
		return _M_start;
	}
	else if(position._M_cur == _M_finish._M_cur) {
		push_back(__x);
		iterator __tmp = _M_finish;
		--__tmp;
		return __tmp;
	}
	else {
		return _M_insert_aux(position, __x);
	}
}

iterator _M_insert_aux(iterator position, const value_type& __x) {
	difference_type __index = pos - _M_start;
	value_type __x_copy = __x;
	if(size_type(__index) < this->size()/2) {
		push_front(front());
		iterator __front1 = _M_start;
		++__front1;
		iterator __front2 = __front1;
		++front2;
		__pos = _M_start + __index;
		iterator __pos1 = pos;;
		++__pos1;
		copy(front2, pos1, front1);
	}
	else {
		push_back(back());
		iterator __back1 = _M_finish;
		--__back1;
		iterator __back2 = __back1;
		--__back2;
		__pos = _M_start + __index;
		copybackward(pos, __back2, __back1);
	}
	*__pos = __x_copy;
	return __pos;
}
Linkkk丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入研究 C++中的 STL Deque 容器
08-03
本文深入地研究了std::deque 容器。本文将讨论在一些情况下使用deque> 比vector更好。读完这篇文章后读者应该能够理解在容量增长的过程中deque 与vector在内存分配和性能的不同表现。由于deque> 和vector的用法很相似，读者可以参考vector 文档中介绍如何使用STL容器。
C++ STL入门教程(3) deque双向队列使用方法
08-29
主要为大家详细介绍了C++ STL入门教程第三篇，deque双向队列的使用方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++ STL：deque使用及源码剖析
最新发布
暮色年华的博客
02-18 1065
include // deque属于std命名域的，因此需要通过命名限定// 定义一个int类型的双端队列a// 定义一个int类型的双端队列a，并设置初始大小为10// 定义一个int类型的双端队列a，并设置初始大小为10且初始值都为1// 定义并用双端队列a初始化双端队列b// 将双端队列a中从第0个到第2个(共3个)作为双端队列b的初始值// 将n[1]、n[2]、n[3]作为双端队列a的初值。
fuser:仅标头的库，用于将C ++类型自动（反）序列化为JSON
03-13
热熔器 1个文件的仅标头库，用于将C ++类型自动（反）序列化为JSON。 怎么运行的 该库为常见类型提供了一组预定义的（反）序列化器： std::nullptr_t bool 所有标准整数（ std::int*_t ， std::uint*_t ）和浮点数（ float ， double ， long double ）数值类型（检查该值是否适合目标类型） char没有明确实现，但是很可能会属于固定宽度整数类型之一 char8_t ， char16_t和char32_t未实现 void*和void const* （转换为std::uintptr_t ） std::string std::array<T> （检查数组大小是否匹配） std::vector<T> std::deque<T> std::unique_ptr<T> （无值时输出null ） std::op
C++/C++11中std::deque的使用
热门推荐
网络资源是无限的
05-25 4万+
C++/C++11中std::deque的使用
STL之deque解析
weixin_53344209的博客
04-30 330
1、deque和vector比较 vector是单向开口的连续线性空间，而deque是双向开口的连续线性空间，也就是说可以在头尾两端做插入删除操作。虽说vector也可以在头部增加元素比如使用insert(begin(),1),但是效率很低涉及到移动元素以及一些移动的细节。 deque和vector最大差异在于两点： 1、deque可以实现常数复杂度的头部插入删除操作； 2.deque没有所谓的容量概念，因为它是动态地以分段连续空间组合而成。随时可以增加一段空间并组合起来。所以不会出现vector那样空间
C++ std::deque
肥猫王德福的博客
02-02 3985
重点： 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.
std::deque
TimerSea的博客
03-30 2321
std::deque应用记录
C++ -- 学习系列 std::deque 的原理与使用
qq_33775774的博客
09-30 792
std::deque 是 c++ 一种序列式容器，其与 vector 类似，其底层内存都是连续的，不同的地方在于， vector 是一端开口，在一端放入数据与扩充空间，而 deque 是双端均开口，都可以放入数据与扩充空间。
std::Deque使用总结
大山喵写博客的地方
10-12 1万+
Deque
C/C++编程：STL双端队列deque的使用
OceanStar的博客
08-03 1128
头文件：#include&lt;queue&gt; 实例化： queue&lt;类型[, 存储容器]&gt;QueueName 成员函数： boolempty(); 队列为空返回 true否则返回false. voidpop(); 删除队列的一个元素。 voidpush( constTY...
深入研究std_deque.doc
10-16
双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列双队列
浅谈C++|STL之deque篇
m0_73731708的博客
09-13 510
deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据中控器维护的是每个缓冲区的地址，使得使用deque时像—片连续的内存空间. deque容器的迭代器也是支持随机访问的. deque可以看成链表+vector。
C++双端队列deque的用法
simonchow11的博客
04-09 2645
1. 基础 deque容器为一个给定类型的元素进行线性处理，像向量一样，它能够快速地随机访问任一个元素，并且能够高效地插入和删除容器的尾部元素。但它又与vector不同，deque支持高效插入和删除容器的头部元素，因此也叫做双端队列。deque类常用的函数如下。 需要引用: #include <deque> 2. 申明 std::cout << " ---------- init deque -----------" << std::endl; // 方式一: 创建一个空
STL deque用法
QiaoLiu___lq的博客
02-20 500
STL deque用法详解，含示例
STL容器—deque使用技巧
木牛的博客
07-12 119
因此，通过以上的分析，在存储大量数据时，我认为使用。接口，因此也可以利用此接口去手动释放内存，在尾部和首部插入和删除的时间复杂度都为。,虽然栈只涉及一端数据的插入和删除。中的内存，在c++ 11之后，的，对于少量数据则尽量用。有趣的是，标准库中栈()的实现默认就是使用了。，当然实际是要略慢于。的优先级应该是要高于。
STL中的deque
稚与的博客
07-07 858
STL中的deque 文章目录STL中的dequedeque 双端队列程序演示 deque 双端队列 deque是双向队列容器，由一段一段的定量连续空间构成，可以向两端发展，因此在头尾安插元素十分方便、迅速。 在中间部分安插元素则比较费时，因为必须移动其它元素。 头文件 #include<deque> 常用api deque<type>obj 声明deque deque<int> obj; //声明int类型双端队列 deque<int
std::deque的使用
u010169607的博客
10-11 460
目录[-] 1、deque、list、vector区别 •deque与vector在存储上的不同：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值