จากภาพรวมคุณสามารถคิดว่าdequeเป็นdouble-ended queue
ข้อมูลในdequeจะถูกเก็บไว้โดย chuncks ของเวกเตอร์ขนาดคงที่ซึ่ง ได้แก่
ตัวชี้โดยmap(ซึ่งเป็นอันของเวกเตอร์ แต่ขนาดอาจเปลี่ยนแปลงได้)
รหัสชิ้นส่วนหลักของdeque iteratorดังต่อไปนี้:
/*
buff_size is the length of the chunk
*/
template <class T, size_t buff_size>
struct __deque_iterator{
typedef __deque_iterator<T, buff_size> iterator;
typedef T** map_pointer;
// pointer to the chunk
T* cur;
T* first; // the begin of the chunk
T* last; // the end of the chunk
//because the pointer may skip to other chunk
//so this pointer to the map
map_pointer node; // pointer to the map
}
รหัสชิ้นส่วนหลักของdequeดังต่อไปนี้:
/*
buff_size is the length of the chunk
*/
template<typename T, size_t buff_size = 0>
class deque{
public:
typedef T value_type;
typedef T& reference;
typedef T* pointer;
typedef __deque_iterator<T, buff_size> iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
protected:
typedef pointer* map_pointer;
// allocate memory for the chunk
typedef allocator<value_type> dataAllocator;
// allocate memory for map
typedef allocator<pointer> mapAllocator;
private:
//data members
iterator start;
iterator finish;
map_pointer map;
size_type map_size;
}
ด้านล่างฉันจะให้รหัสหลักของdequeส่วนใหญ่เกี่ยวกับสามส่วน:
iterator
วิธีการสร้าง deque
1. ตัววนซ้ำ ( __deque_iterator)
ปัญหาหลักของ iterator คือเมื่อ ++, - iterator มันอาจข้ามไปที่ chunk อื่น ๆ (ถ้ามันชี้ไปที่ edge of chunk) chunk 1ตัวอย่างเช่นมีสามชิ้นข้อมูล: chunk 2, chunk 3,
pointer1ตัวชี้ไปยังเริ่มต้นของchunk 2เมื่อผู้ประกอบการ--pointerก็จะชี้ไปยังจุดสิ้นสุดของการเพื่อให้เป็นไปchunk 1pointer2
ด้านล่างฉันจะให้ฟังก์ชั่นหลักของ__deque_iterator:
ประการแรกข้ามไปที่ก้อนใด ๆ :
void set_node(map_pointer new_node){
node = new_node;
first = *new_node;
last = first + chunk_size();
}
โปรดทราบว่าchunk_size()ฟังก์ชั่นที่คำนวณขนาดก้อนคุณสามารถคิดว่ามันคืนค่า 8 เพื่อทำให้ง่ายขึ้นที่นี่
operator* รับข้อมูลในกลุ่มข้อมูล
reference operator*()const{
return *cur;
}
operator++, --
// คำนำหน้ารูปแบบของการเพิ่มขึ้น
self& operator++(){
++cur;
if (cur == last){ //if it reach the end of the chunk
set_node(node + 1);//skip to the next chunk
cur = first;
}
return *this;
}
// postfix forms of increment
self operator++(int){
self tmp = *this;
++*this;//invoke prefix ++
return tmp;
}
self& operator--(){
if(cur == first){ // if it pointer to the begin of the chunk
set_node(node - 1);//skip to the prev chunk
cur = last;
}
--cur;
return *this;
}
self operator--(int){
self tmp = *this;
--*this;
return tmp;
}
ตัววนซ้ำข้ามขั้นตอน / การเข้าถึงแบบสุ่ม
self& operator+=(difference_type n){ // n can be postive or negative
difference_type offset = n + (cur - first);
if(offset >=0 && offset < difference_type(buffer_size())){
// in the same chunk
cur += n;
}else{//not in the same chunk
difference_type node_offset;
if (offset > 0){
node_offset = offset / difference_type(chunk_size());
}else{
node_offset = -((-offset - 1) / difference_type(chunk_size())) - 1 ;
}
// skip to the new chunk
set_node(node + node_offset);
// set new cur
cur = first + (offset - node_offset * chunk_size());
}
return *this;
}
// skip n steps
self operator+(difference_type n)const{
self tmp = *this;
return tmp+= n; //reuse operator +=
}
self& operator-=(difference_type n){
return *this += -n; //reuse operator +=
}
self operator-(difference_type n)const{
self tmp = *this;
return tmp -= n; //reuse operator +=
}
// random access (iterator can skip n steps)
// invoke operator + ,operator *
reference operator[](difference_type n)const{
return *(*this + n);
}
2. วิธีการสร้าง deque
ฟังก์ชั่นทั่วไปของ deque
iterator begin(){return start;}
iterator end(){return finish;}
reference front(){
//invoke __deque_iterator operator*
// return start's member *cur
return *start;
}
reference back(){
// cna't use *finish
iterator tmp = finish;
--tmp;
return *tmp; //return finish's *cur
}
reference operator[](size_type n){
//random access, use __deque_iterator operator[]
return start[n];
}
template<typename T, size_t buff_size>
deque<T, buff_size>::deque(size_t n, const value_type& value){
fill_initialize(n, value);
}
template<typename T, size_t buff_size>
void deque<T, buff_size>::fill_initialize(size_t n, const value_type& value){
// allocate memory for map and chunk
// initialize pointer
create_map_and_nodes(n);
// initialize value for the chunks
for (map_pointer cur = start.node; cur < finish.node; ++cur) {
initialized_fill_n(*cur, chunk_size(), value);
}
// the end chunk may have space node, which don't need have initialize value
initialized_fill_n(finish.first, finish.cur - finish.first, value);
}
template<typename T, size_t buff_size>
void deque<T, buff_size>::create_map_and_nodes(size_t num_elements){
// the needed map node = (elements nums / chunk length) + 1
size_type num_nodes = num_elements / chunk_size() + 1;
// map node num。min num is 8 ，max num is "needed size + 2"
map_size = std::max(8, num_nodes + 2);
// allocate map array
map = mapAllocator::allocate(map_size);
// tmp_start，tmp_finish poniters to the center range of map
map_pointer tmp_start = map + (map_size - num_nodes) / 2;
map_pointer tmp_finish = tmp_start + num_nodes - 1;
// allocate memory for the chunk pointered by map node
for (map_pointer cur = tmp_start; cur <= tmp_finish; ++cur) {
*cur = dataAllocator::allocate(chunk_size());
}
// set start and end iterator
start.set_node(tmp_start);
start.cur = start.first;
finish.set_node(tmp_finish);
finish.cur = finish.first + num_elements % chunk_size();
}
สมมติว่าi_dequeมี 20 องค์ประกอบ0~19ที่มีขนาดก้อนเป็น 8 และตอนนี้องค์ประกอบ push_back 3 (0, 1, 2) เพื่อi_deque:
i_deque.push_back(0);
i_deque.push_back(1);
i_deque.push_back(2);
มันเป็นโครงสร้างภายในเช่นด้านล่าง:
จากนั้น push_back อีกครั้งระบบจะเรียกใช้การจัดสรรก้อนใหม่:
push_back(3)
ถ้าเราpush_frontมันจะจัดสรรก้อนใหม่ก่อนหน้า prevstart
หมายเหตุเมื่อpush_backองค์ประกอบเข้า deque ถ้าทุกแผนที่และชิ้นจะเต็มไปก็จะทำให้เกิดการจัดสรรแผนที่ใหม่และปรับ chunks.But dequeโค้ดข้างต้นอาจจะเพียงพอสำหรับคุณที่จะเข้าใจ
