namespace boost {

template <class T, class Alloc>
class circular_buffer
{
public:
 typedef typename Alloc::value_type value_type;
 typedef typename Alloc::pointer pointer;
 typedef typename Alloc::const_pointer const_pointer;
 typedef typename Alloc::reference reference;
 typedef typename Alloc::const_reference const_reference;
 typedef typename Alloc::difference_type difference_type;
 typedef typename Alloc::size_type size_type;
 typedef Alloc allocator_type;
 typedef implementation-defined const_iterator;
 typedef implementation-defined iterator;
 typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
 typedef boost::reverse_iterator<iterator> reverse_iterator;
 typedef std::pair<pointer, size_type> array_range;
 typedef std::pair<const_pointer, size_type> const_array_range;
 typedef size_type capacity_type;

 explicit circular_buffer(const allocator_type& alloc = allocator_type());
 explicit circular_buffer(capacity_type capacity, const allocator_type& alloc = allocator_type());
 circular_buffer(size_type n, const_reference item, const allocator_type& alloc = allocator_type());
 circular_buffer(capacity_type capacity, size_type n, const_reference item, const allocator_type& alloc = allocator_type());
 circular_buffer(const circular_buffer<T, Alloc>& cb);
 template <class InputIterator>
 circular_buffer(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
 template <class InputIterator>
 circular_buffer(capacity_type capacity, InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
 ~circular_buffer();

 allocator_type get_allocator() const;
 allocator_type& get_allocator();
 iterator begin();
 iterator end();
 const_iterator begin() const;
 const_iterator end() const;
 reverse_iterator rbegin();
 reverse_iterator rend();
 const_reverse_iterator rbegin() const;
 const_reverse_iterator rend() const;
 reference operator[](size_type index);
 const_reference operator[](size_type index) const;
 reference at(size_type index);
 const_reference at(size_type index) const;
 reference front();
 reference back();
 const_reference front() const;
 const_reference back() const;
 array_range array_one();
 array_range array_two();
 const_array_range array_one() const;
 const_array_range array_two() const;
 pointer linearize();
 bool is_linearized() const; 
 void rotate(const_iterator new_begin);   
 size_type size() const;
 size_type max_size() const;
 bool empty() const;
 bool full() const;
 size_type reserve() const;
 capacity_type capacity() const;
 void set_capacity(capacity_type new_capacity);
 void resize(size_type new_size, const_reference item = value_type());
 void rset_capacity(capacity_type new_capacity);
 void rresize(size_type new_size, const_reference item = value_type());
 circular_buffer<T, Alloc>& operator=(const circular_buffer<T, Alloc>& cb);
 void assign(size_type n, const_reference item);
 void assign(capacity_type capacity, size_type n, const_reference item);
 template <class InputIterator>
 void assign(InputIterator first, InputIterator last);
 template <class InputIterator>
 void assign(capacity_type capacity, InputIterator first, InputIterator last);
 void swap(circular_buffer<T, Alloc>& cb);
 void push_back(const_reference item = value_type());
 void push_front(const_reference item = value_type());
 void pop_back();
 void pop_front();
 iterator insert(iterator pos, const_reference item = value_type());
 void insert(iterator pos, size_type n, const_reference item);
 template <class InputIterator>
 void insert(iterator pos, InputIterator first, InputIterator last);
 iterator rinsert(iterator pos, const_reference item = value_type());
 void rinsert(iterator pos, size_type n, const_reference item);
 template <class InputIterator>
 void rinsert(iterator pos, InputIterator first, InputIterator last);
 iterator erase(iterator pos);
 iterator erase(iterator first, iterator last);
 iterator rerase(iterator pos);
 iterator rerase(iterator first, iterator last);
 void clear();
};

template <class T, class Alloc>
 bool operator==(const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs);
template <class T, class Alloc>
 bool operator<(const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs);
template <class T, class Alloc>
 bool operator!=(const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs);
template <class T, class Alloc>
 bool operator>(const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs);
template <class T, class Alloc>
 bool operator<=(const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs);
template <class T, class Alloc>
 bool operator>=(const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs);
template <class T, class Alloc>
 void swap(circular_buffer<T, Alloc>& lhs, circular_buffer<T, Alloc>& rhs);

} // namespace boost

作用：

capacity() == max_size() && size() == 0

參數：

alloc

分配器。

拋出：

如果內存耗盡則拋出一個分配錯誤(如果使用標準分配器則為 std::bad_alloc)。

複雜度：

常數。

警告：

該構造函數只是為了與STL容器的定義兼容而定義的。應避免使用它，因為它會分配很大的內存空間(取決於分配器的 max_size())。

作用：

capacity() == capacity && size() == 0

參數：

capacity

可以保存在 circular_buffer 中的元素最大數量。

alloc

分配器。

拋出：

如果內存耗盡則拋出一個分配錯誤(如果使用標準分配器則為 std::bad_alloc)。

複雜度：

常數。

作用：

capacity() == n && full() && (*this)[0] == item && (*this)[1] == item && ... && (*this)[n - 1] == item

參數：

n

要填入到被創建 circular_buffer 中的元素數量。

item

要填入到被創建 circular_buffer 中的元素。

alloc

分配器。

拋出：

如果內存耗盡則拋出一個分配錯誤(如果使用標準分配器則為 std::bad_alloc)。

T::T(const T&) 拋出的任何異常。

複雜度：

線性(與 n 相關)。

前提條件：

capacity >= n

作用：

capacity() == capacity && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this)[n - 1] == item

參數：

capacity

被創建 circular_buffer 的容量。

n

要填入到被創建 circular_buffer 中的元素數量。

item

要填入到被創建 circular_buffer 中的元素。

alloc

分配器。

拋出：

如果內存耗盡則拋出一個分配錯誤(如果使用標準分配器則為 std::bad_alloc)。

T::T(const T&) 拋出的任何異常。

複雜度：

線性(與 n 相關)。

創建指定 circular_buffer 的一個拷貝。

作用：

*this == cb

參數：

cb

被複製的 circular_buffer.

拋出：

如果內存耗盡則拋出一個分配錯誤(如果使用標準分配器則為 std::bad_alloc)。

T::T(const T&) 拋出的任何異常。

複雜度：

線性(與 cb 的大小相關)。

前提條件：

有效區間 [first, last).
first 和 last 必須符合 輸 入迭代器InputIterator 的要求。

作用：

capacity() == std::distance(first, last) && full() && (*this)[0]== *first && (*this)[1] == *(first + 1) && ... && (*this)[std::distance(first, last) - 1] == *(last - 1)

參數：

first

被複製的區間的開始。

last

被複製的區間的結束。

alloc

分配器。

拋出：

如果內存耗盡則拋出一個分配錯誤(如果使用標準分配器則為 std::bad_alloc)。

T::T(const T&) 拋出的任何異常。

複雜度：

線性(與 std::distance(first, last)& nbsp;相關)。

前提條件：

有效區間 [first, last).
first 和 last 必須符合 輸 入迭代器InputIterator 的要求。

作用：

capacity() == capacity && size() <= std::distance(first, last) && (*this)[0]== *(last - capacity) && (*this)[1] == *(last - capacity + 1) && ... && (*this)[capacity - 1] == *(last - 1)

如果被複製的區間 [first, last) 中的元素數量大於指定的容量，則只有區間 [last - capacity, last) 中的元素被複製。

參數：

capacity

被創建的 circular_buffer 的容量。

first

被複製的區間的開始。

last

被複製的區間的結束。

alloc

分配器。

拋出：

如果內存耗盡則拋出一個分配錯誤(如果使用標準分配器則為 std::bad_alloc)。

T::T(const T&) 拋出的任何異常。

複雜度：

線性(與 std::distance(first, last) 相關; 如果 InputIterator 為 隨 機訪問迭代器RandomAccessIterator 則與 min[capacity, std::distance(first, last)] 相關)。

銷毀 circular_buffer.

拋出：

無。

迭代器失效：

所有指向 circular_buffer 的迭代器(包括等於 end() 的迭代器)均失效。

複雜度：

線性(與 circular_buffer 的大小相關)。

參見：

clear()

返回：

分配器。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

 獲取分配器引用的 get_allocator()。

返回：

分配器的一個引用。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

說明：

加入這一方法是為了優化帶狀態分配器的獲取，雖然使用帶狀態分配器在STL中是不好的。

參見：

get_allocator() const

返回：

一個隨機訪問迭代器，指向 circular_buffer 的第一個元素。如果 circular_buffer 為空則返回一個等於 end() 的迭代器。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

end(), rbegin(), rend()

返回：

一個隨機訪問迭代器，指向 circular_buffer 最後一個元素的下一個位置。如果 circular_buffer 為空則返回一個等於 begin() 的迭代器。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

begin(), rbegin(), rend()

返回：

一個常量隨機訪問迭代器，指向 circular_buffer 的第一個元素。如果 circular_buffer 為空則返回一個等於 end() const  的迭代器。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

end() const, rbegin() const, rend() const

返回：

一個常量隨機訪問迭代器，指向 circular_buffer 最後一個元素的下一個位置。如果 circular_buffer 為空則返回一個等於 begin() const 的迭代器。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

begin() const, rbegin() const, rend() const

返回：

一個反向隨機訪問迭代器，指向 circular_buffer 的最後一個元素。如果 circular_buffer 為空則返回一個等於 rend() 的迭代器。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

rend(), begin(), end()

返回：

一個反向隨機訪問迭代器，指向 circular_buffer 第一個元素的前一個位置。如果 circular_buffer 為空則返回一個等於 rbegin() 的迭代器。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

rbegin(), begin(), end()

返回：

一個常量反向隨機訪問迭代器，指向 circular_buffer 的最後一個元素。如果 circular_buffer 為空則返回一個等於 rend() const 的迭代器。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

rend() const, begin() const, end() const

返回：

一個常量反向隨機訪問迭代器，指向 circular_buffer 第一個元素的前一個位置。如果 circular_buffer 為空則返回一個等於 rbegin() const 的迭代器。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

rbegin() const, begin() const, end() const

前提條件：

0 <= index && index < size()

參數：

index

元素的位置。

返回：

位於 index 位置上的元素的引用。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

at()

前提條件：

0 <= index && index < size()

參數：

index

元素的位置。

返回：

位於 index 位置的元素的常量引用。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

at() const

參數：

index

元素的位置。

返回：

位於 index 位置的元素的引用。

拋出：

std::out_of_range 當 index 無效(若 index >= size())。

異常安全性：

強。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

operator[]

參數

index

元素的位置。

返回：

位於 index 位置的元素的常量引用。

拋出：

std::out_of_range 當 index 無效(若 index >= size())。

異常安全性：

強。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

operator[] const

前提條件：

!empty()

返回：

circular_buffer 的第一個元素的引用。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

back()

前提條件：

!empty()

返回：

circular_buffer 最後一個元素的引用。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

front()

前提條件：

!empty()

返回：

circular_buffer 第一個元素的常量引用。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

back() const

前提條件：

!empty()

返回：

circular_buffer 最後一個元素的常量引用。

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

front() const

該方法與 array_two() 結合可用於將所存數據以數組方式傳遞給傳統的 C API。假設有一個容量為10的 circular_buffer， 包含7個字符 'a', 'b', ..., 'g'，其中 buff[0] == 'a', buff[1] == 'b', ... buff[6] == 'g':

circular_buffer<char> buff(10);

其內部的表示通常不是線性的，內部緩衝區的狀態可能如下：

|e|f|g| | | |a|b|c|d|
end ---^
begin -------^

其中 |a|b|c|d| 表示"數組一"，|e|f|g| 表示"數組二"，而 | | | | 為空閒空間。
現在考慮一個典型的C風格函數，它寫入數據到一個文件中：

int write(int file_desc, char* buff, int num_bytes);

有兩種方法將 circular_buffer 中的內容寫到一個文件中。要麼使用 array_one() 和 array_two() 方法並調用 write 函數兩次：

array_range ar = buff.array_one();
write(file_desc, ar.first, ar.second);
ar = buff.array_two();
write(file_desc, ar.first, ar.second);

或者使用 linearize() 方法：

write(file_desc, buff.linearize(), buff.size());

由於 array_one() 和 array_two() 方法的複雜度為常數，所以當 write 方法較為"廉價"時第一個選擇更適合。另一方面，當調用 write 方法較為"昂貴"時第二個選擇更為適合，linearize() 方法的調用是線性複雜度的。

返回：

內部緩衝區首個連續數組的數組區間。當 circular_buffer 為空時，返回數組的大小為 0.

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

警告：

通常，調用任何修改 circular_buffer 內部狀態的方法都可能會破壞內部緩衝區的線性，並令得由 array_one() 和 array_two()& nbsp;(以及它們的常量版本)所返回的數組區間失效。

說明：

當內部緩衝區為線性時，如 |a|b|c|d|e|f|g| | | | ，"數組一"代表 |a|b|c|d|e|f|g| 而"數組二"不存在(array_two() 方法返回一個大小為 0 的數組)。

參見：

array_two(), linearize()

該方法與 array_one() 結合可用於將所存數據以數組方式傳遞給傳統的 C API。

返回：

內部緩衝區的第二個連續數組的數組區間。當內部緩衝區為線性時或 circular_buffer 為空時，返回數組的大小為 0.

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

array_one()

該方法與 array_two() const 結合可用於將所存數據以數組方式傳遞給傳統的 C API。

返回：

內部緩衝區的首個連續數組的數組區間。當 circular_buffer 為空時，返回數組的大小為 0.

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

array_two() const; array_one() 詳細說明了如何傳遞數據給傳統的 C API.

該方法與 array_one() const 結合可用於將所存數據以數組方式傳遞給傳統的 C API。

返回：

內部緩衝區的第二個連續數組的數組區間。當內部緩衝區為線性時或 circular_buffer 為空時，返回數組的大小為 0.

拋出：

無。

異常安全性：

無拋出。

迭代器失效：

不會令任何迭代器失效。

複雜度：

常數(與 circular_buffer 的大小相關)。

參見：

array_one() const

該方法用於將所存數據以數組方式傳遞給傳統的 C API。

作用:

&(*this)[0] < &(*this)[1] < ... < &(*this)[size() - 1]

返回:

指向數組起始的指針，或者如果為空則返回 0.

拋出:

T::T(const T&) 拋出的任何異常。

T::operator = (const T&) 拋出的任何異常。

異常安全性:

基本；如果在拋出一節中所列的操作不拋出的話則沒有異常拋出。

迭代器失效:

所有指向 circular_buffer 的迭代器均失效(除了等於 end() 的迭代器)；如果後續條件(見作用)在調用之前已滿足則不會令任何迭代器失效。

複雜度:

線性(與 circular_buffer 的大小相關)；如果後續條件(見作用)已滿足則為常數複雜度。

警告:

通常，調用任何會修改 circular_buffer 內部狀態的方法都可能會破壞內部緩衝區的線性，並令得返回的指針失效。

參見:

array_one() 和 array_two() 給出了另一個方法來傳遞數據給傳統的 C API；is_linearized(), rotate(const_iterator)

返回:

如果內部緩衝區被線性化到一個連續數組(即 circular_buffer 符合條件 &(*this)[0] < &(*this)[1] < ... < &(*this)[size() - 1])則返回 true；否則返回 false。

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

不會令任何迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。 

參見:

linearize(), array_one(), array_two()

一個比 std::rotate 更為高效的實現。

先驗條件:

new_begin 是一個指向 circular_buffer 除末尾以外地方的有效迭代器。

作用:

假設在調用該方法之前有：

m == std::distance(new_begin, end())
n == std::distance(begin(), new_begin)
val_0 == *new_begin, val_1 == *(new_begin + 1), ... val_m == *(new_begin + m)
val_r1 == *(new_begin - 1), val_r2 == *(new_begin - 2), ... val_rn == *(new_begin - n)

則在調用之後有：

val_0 == (*this)[0] && val_1 == (*this)[1] && ... && val_m == (*this)[m - 1] && val_r1 == (*this)[m + n - 1] && val_r2 == (*this)[m + n - 2] && ... && val_rn == (*this)[m]

參數:

new_begin

新的起始點。

拋出:

T::T(const T&) 拋出的任何異常。

T::operator = (const T&) 拋出的任何異常。

異常安全性:

基本；如果 circular_buffer 為滿或 new_begin 指向 begin() 或在拋出一節中給出的操作沒有拋出，則不拋出。

迭代器失效:

如果 m < n，則指向最後 m 個元素的迭代器失效(包括 new_begin，但不包括等於 end() 的迭代器)，否則指向頭 n 個元素的迭代器失效；如果 circular_buffer 為滿則沒有迭代器失效。

複雜度:

線懷(與 std::min(m, n) 相關)；如果 circular_buffer 為滿則為常數。

參見:

std::rotate

返回:

保存在 circular_buffer 中的元素數量。

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

不會令任何迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

capacity(), max_size(), reserve(), resize(size_type, const_reference)

返回:

可以設置的 circular_buffer 的最大大小/容量。

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

不會令任何迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

size(), capacity(), reserve()

返回:

true 如果 circular_buffer 中沒有元素；否則返回 false.

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

不會令任何迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

full()

返回:

true 如果保存在 circular_buffer 中的元素數量等於 circular_buffer 的容量；否則返回 false.

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

不會令任何迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

empty()

返回:

capacity() - size()

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

不會令任何迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

capacity(), size(), max_size()

返回:

可以保存在 circular_buffer 的最大元素數量。

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

不會令任何迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

reserve(), size(), max_size(), set_capacity(capacity_type)

作用:

capacity() == new_capacity && size() <= new_capacity

如果當前保存在 circular_buffer 中的元素數量大於希望設置的新容量，則 [size() - new_capacity] 個最後的元素將被刪除，新的 size 將等於 new_capacity.

參數：

new_capacity

新的容量。

拋出:

如果內存耗盡則拋出一個內存分配錯誤(std::bad_alloc 如果使用標準分配器)。

T::T(const T&) 拋出的任何異常。

異常安全性:

強。

迭代器失效:

指向 circular_buffer 的所有迭代器均失效(除了等於 end() 的迭代器)，如果新的容量與原有容量不同。

複雜度:

線性(與 min[size(), new_capacity] 相關)。

參見:

rset_capacity(capacity_type), resize(size_type, const_reference)

作用:

size() == new_size && capacity() >= new_size

如果新的大小大於當前大小，則 item 的多個拷貝被插入到 circular_buffer 的後端以達到希望的大小。如 果最終的大小超出當前的容量，則將容量設置為 new_size.
如果當前保存在 circular_buffer 中的元素數量大於希望的新大小，則最後 [size() - new_size] 個元素將被刪除。(容量保持不變)

參數：

new_size

新的大小。

item

用於填充 circular_buffer 的元素，以達到所要求的大小(見作用)。

拋出:

如果內存耗盡則拋出一個內存分配錯誤(std::bad_alloc 如果使用標準分配器)。

T::T(const T&) 拋出的任何異常。

異常安全性:

基本。

迭代器失效:

指向 circular_buffer 的所有迭代器均失效(除了等於 end() 的迭代器)，如果新的大小大於當前容量。如果新的大小小於當前大小則指向被刪除元素的迭代器失效。否則沒有迭代器失效。

複雜度:

線性(與 circular_buffer 的新大小相關)。

參見:

rresize(size_type, const_reference), set_capacity(capacity_type)

作用:

capacity() == new_capacity && size() <= new_capacity

如果當前保存在 circular_buffer 中的元素數量大於所希望的新容量，則頭 [size() - new_capacity] 個元素被刪除，新的大小等於 new_capacity.

Parameter(s):

new_capacity

新的容量。

拋出:

如果內存耗盡則拋出一個內存分配錯誤(std::bad_alloc 如果使用標準分配器)。

T::T(const T&) 拋出的任何異常。

異常安全性:

強。

迭代器失效:

如果新的容量不同於原有容量，則指向 circular_buffer 的所有迭代器均失效(除了等於 end() 的迭代器)。

複雜度:

線性(與 min[size(), new_capacity] 相關)。

參見:

set_capacity(capacity_type), rresize(size_type, const_reference)

作用:

size() == new_size && capacity() >= new_size

如果新的大小大於當前大小，則 item 的多份拷貝將被插入到 circular_buffer 的前端以達到所希望的大小。 如果所得的大小超過當前的容量，則容量被設置為 new_size.
如果當前保存在 circular_buffer 中的元素數量大於所希望的新大小，則頭 [size() - new_size] 個元素將被刪除。(容量保持不變)

參數：

new_size

新的大小。

item

被填充到 circular_buffer 中的元素，以達到所要求的大小。(見作用)

拋出:

如果內存耗盡則拋出一個內存分配錯誤(std::bad_alloc 如果使用標準分配器)。

T::T(const T&) 拋出的任何異常。

異常安全性:

基本。

迭代器失效:

如果新的大小大於當前容量，則指向 circular_buffer 的所有迭代器均失效(除了等於 end() 的迭代器)。如果新的大小小於原有大小，則指向被刪除元素的迭代器失效。否則沒有迭代器失效。

複雜度:

線性(與 circular_buffer 的新大小相關)。

參見:

resize(size_type, const_reference), rset_capacity(capacity_type)

使得 circular_buffer 成為給定 circular_buffer 的一個拷貝。

作用:

*this == cb

參數：

cb

被複製的 circular_buffer.

拋出:

如果內存耗盡則拋出一個內存分配錯誤(std::bad_alloc 如果使用標準分配器)。

T::T(const T&) 拋出的任何異常。

異常安全性:

強。

迭代器失效:

所有指向 circular_buffer 的迭代器均失效(除了等於 end() 的迭代器)。

複雜度:

線性(與 cb 的大小相關)。

參見:

assign(size_type, const_reference), assign(capacity_type, size_type, const_reference), assign(InputIterator, InputIterator), assign(capacity_type, InputIterator, InputIterator)

circular_buffer 中的原有內容將被刪除並替換為 item 的 n 個拷貝。

作用:

capacity() == n && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this) [n - 1] == item

參數：

n

被填充到 circular_buffer 中的元素數量。

item

被填充到 circular_buffer 中的元素。

拋出:

如果內存耗盡則拋出一個內存分配錯誤(std::bad_alloc 如果使用標準分配器)。

T::T(const T&) 拋出的任何異常。

異常安全性:

基本。

迭代器失效:

指向 circular_buffer 的所有迭代器均失效(除了等於 end() 的迭代器)。

複雜度:

線性(與 n 相關)。

參見:

operator=, assign(capacity_type, size_type, const_reference), assign(InputIterator, InputIterator), assign(capacity_type, InputIterator, InputIterator)

circular_buffer 的容量將被設置為給定值，circular_buffer 中的內容被刪除並替換為 item 的 n 份拷貝。

前提條件：

capacity >= n

作用:

capacity() == capacity && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this) [n - 1] == item

參數：

capacity

新的容量。

n

被填充到 circular_buffer 中的元素數量。

item

被填充到 circular_buffer 中的元素。

拋出:

如果內存耗盡則拋出一個內存分配錯誤(std::bad_alloc 如果使用標準分配器)。

T::T(const T&) 拋出的任何異常。

異常安全性:

基本。

迭代器失效:

指向 circular_buffer 的所有迭代器均失效(除了等於 end() 的迭代器)。

複雜度:

線性(與 n 相關)。

參見:

operator=, assign(size_type, const_reference), assign(InputIterator, InputIterator), assign(capacity_type, InputIterator, InputIterator)

circular_buffer 的內容被刪除並替換為來自給定區間的元素的拷貝。

前提條件：

有效區間 [first, last).
first 和 last 必須符合 輸 入迭代器InputIterator 的要求。

作用:

capacity() == std::distance(first, last) && size() == std::distance(first, last) && (*this)[0]== *first && (*this)[1] == *(first + 1) && ... && (*this)[std::distance(first, last) - 1] == *(last - 1)

參數

first

被複製區間的開始。

last

被複製區間的結束。

拋出:

如果內存耗盡則拋出一個內存分配錯誤(std::bad_alloc 如果使用標準分配器)。

T::T(const T&) 拋出的任何異常。

異常安全性:

基本。

迭代器失效:

指向 circular_buffer 的所有迭代器均失效(除了等於 end() 的迭代器)。

複雜度:

線性(與 std::distance(first, last) 相關)。

參見:

operator=, assign(size_type, const_reference), assign(capacity_type, size_type, const_reference), assign(capacity_type, InputIterator, InputIterator)

circular_buffer 的容量將被設置為指定值，circular_buffer 的內容被刪除並替換為來自給定區間的元素的拷貝。

前提條件：

有效區間 [first, last).
first 和 last 必須符合 輸 入迭代器InputIterator 的要求。

作用:

capacity() == capacity && size() <= std::distance(first, last) && (*this)[0]== *(last - capacity) && (*this)[1] == *(last - capacity + 1) && ... && (*this)[capacity - 1] == *(last - 1)

如果被複製的來自 range [first, last) 的元素數量大於給定的 capacity， 則只有區間 [last - capacity, last) 中的元素被複製。

參數：

capacity

新的容量。

first

被複製區間的開始。

last

被複製區間的結束。

拋出:

如果內存耗盡則拋出一個內存分配錯誤(std::bad_alloc 如果使用標準分配器)。

T::T(const T&) 拋出的任何異常。

異常安全性:

基本。

迭代器失效:

指向 circular_buffer 的所有迭代器均失效(除了等於 end() 的迭代器)。

複雜度:

線性(與 std::distance(first, last) 相關；如果 InputIterator 為 隨 機訪問迭代器RandomAccessIterator 則與 min[capacity, std::distance(first, last)] 相關)。

參見:

operator=, assign(size_type, const_reference), assign(capacity_type, size_type, const_reference), assign(InputIterator, InputIterator)

作用:

this 包含 cb 中的元素，反之亦然；this 的容量等於 cb 的容量，反之亦然。

參數：

cb

被交換的 circular_buffer.

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

兩個 circular_buffers 的所有迭代器均失效。(另一方面，這些迭代器仍舊指向同一個元素但卻是不同的容器。如果你想使用這一特性，則必須關閉 對調試的支持，否則在使用這些失效迭代器時就會報告一個斷言。)

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

swap(circular_buffer<T, Alloc>&, circular_buffer<T, Alloc>&)

作用:

如果 capacity() > 0 則 back() == item
如果 circular_buffer 已滿，則刪除第一個元素。如果容量為 0, 則不插入。

參數：

item

被插入的元素。

拋出:

T::T(const T&) 拋出的任何異常。

異常安全性:

基本；如果在拋出一節中列出的操作沒有拋出的話則無拋出。

迭代器失效:

除了指向被覆寫元素的迭代器外，沒有迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

push_front(const_reference), pop_back(), pop_front()

作用:

如果 capacity() > 0 則 front() == item
如果 circular_buffer 已滿，則最後一個元素被刪除。如果容量為 0, 則不插入。

參數：

item

被插入的元素。

拋出:

T::T(const T&) 拋出的任何異常。

異常安全性:

基本；如果在拋出一節中列出的操作沒有拋出的話則無拋出。

迭代器失效:

除了指向被覆寫元素的迭代器外，沒有迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

push_back(const_reference), pop_back(), pop_front()

前提條件：

!empty()

作用:

從 circular_buffer 中刪除最後一個元素。

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

只有指向被刪元素的迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

pop_front(), push_back(const_reference), push_front(const_reference)

前提條件：

!empty()

作用:

circular_buffer 中的第一個元素被刪除。

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

只有指向被刪元素的迭代器失效。

複雜度:

常數(與 circular_buffer 的大小相關)。

參見:

pop_back(), push_back(const_reference), push_front(const_reference)

前提條件：

pos 是一個指向 circular_buffer 或其尾部的有效迭代器。

作用:

item 被插入到位置 pos.
如果 circular_buffer 是滿的，則第一個元素被覆寫。如果 circular_buffer 是滿的且 pos 指向 begin(), 則該元素不會被插入。如果容量為 0, 則不插入。

參數：

pos

指定 item 插入的位置的迭代器。

item

被插入的元素。

返回:

指向插入後元素的迭代器，如果 item 未插入則返回 begin()。(見作 用)

拋出:

T::T(const T&) 拋出的任何異常。

T::operator = (const T&) 拋出的任何異常。

異常安全性:

基本；如果拋出一節中列出的操作沒有拋出則不拋出異常。

迭代器失效:

指向插入點(包括 pos)及插入點之後的迭代器(直至未 尾；除了等於 end() 的迭代器)均失效。指向被覆寫元素的迭代器也失效。

複雜度:

線性(與 std::distance(pos, end()) 相關)。

參見:

insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator), rinsert(iterator, value_type), rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator)

前提條件：

pos 為指向 circular_buffer 或其尾部的有效迭代器。

作用:

min[n, (pos - begin()) + reserve()] 個元素將被插入到位置 pos.
circular_buffer 頭部的 min[pos - begin(), max[0, n - reserve()]] 個元素將被覆寫。
(詳細解釋請見例子)

參數：

pos

指定 items 插入位置的迭代器。

n

被插入的 items 數量。

item

被插入的元素。

拋出:

T::T(const T&)  拋出的任何異常。

T::operator = (const T&)& nbsp;拋出的任何異常。

異常安全性:

基本；如果拋出一節中列出的操作沒有拋出則不拋出異常。

迭代器失效:

指向插入點(包括 pos)及插入點之後的迭代器(直至未 尾；除了等於 end() 的迭代器)均失效。指向被覆寫元素的迭代器也失效。

複雜度:

線性(與 min[capacity(), std::distance(pos, end()) + n] 相關)。

例子：

考慮一個容量為6而大小為4的 circular_buffer。 其內部緩衝區可能如下：

|1|2|3|4| | |
p ---^

在位置 p 插入5個元素後：

insert(p, (size_t)5, 0);

實際上只有4個元素被插入而元素 1 和 2 則被覆寫。這是由於插入操作要保持容量不變。插入後的內部緩衝區如下：

|0|0|0|0|3|4|

作為比較，如果容量無需保持，則內部緩衝區會是這樣：|1|2|0|0|0|0|0|3|4|.

參見:

insert(iterator, value_type), insert(iterator, InputIterator, InputIterator), rinsert(iterator, value_type), rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator)

前提條件：

pos 為指向 circular_buffer 或其尾部的有效迭代器。 
有效區間 [first, last) 其中 first 和 last 符合 輸入迭代器 InputIterator 的要求。

作用:

區間 [first + max[0, distance(first, last) - (pos - begin()) - reserve()], last) 中的元素被插入到位置 pos.
circular_buffer 頭部的 min[pos - begin(), max[0, distance(first, last) - reserve()]] 個元素被覆寫。
(詳細解釋請見例子)

參數：

pos

指定區間插入位置的迭代器。

first

被插入區間的開始。

last

被插入區間的結束。

拋出:

T::T(const T&)  拋出的任何異常。

T::operator = (const T&)& nbsp;拋出的任何異常。

異常安全性:

基本；如果拋出一節中列出的操作沒有拋出則不拋出異常。

迭代器失效:

指向插入點(包括 pos)及插入點之後的迭代器(直至未 尾；除了等於 end() 的迭代器)均失效。指向被覆寫元素的迭代器也失效。

複雜度:

線性(與 [std::distance(pos, end()) + std::distance(first, last)] 相關；如果 InputIterator 為 隨 機訪問迭代器RandomAccessIterator 則與 min[capacity(), std::distance(pos, end()) + std::distance(first, last)] 相關)。

例子：

考慮一個容量為6而大小為4的 circular_buffer。 其內部緩衝區可能如下：

|1|2|3|4| | |
p ---^

在位置 p 插入一個區間的元素後：

int array[] = { 5, 6, 7, 8, 9 };
insert(p, array, array + 5);

實際上只有指定區間中的元素 6, 7, 8 和 9 被插入，而元素 1 和 2 被覆寫。這是由於插入操作要保持容量不變。插入後的內部緩衝區如下：

|6|7|8|9|3|4|

作為比較，如果容量無需保持，則內部緩衝區會是這樣：|1|2|5|6|7|8|9|3|4|.

參見:

insert(iterator, value_type), insert(iterator, size_type, value_type), rinsert(iterator, value_type), rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator)

前提條件：

pos 是一個指向 circular_buffer 或其尾部的有效迭代器。 

作用:

item 被插入到位置& nbsp; pos 之前。
如果 circular_buffer 已滿，則最後一個元素被覆寫。如果 circular_buffer 已滿且 pos 指向 end(), 則 item 不會被插入。如果容量為 0, 也不插入。

參數：

pos

指定 item 插入的位置之前的迭代器。

item

被插入的元素。 

返回:

指向插入後元素的迭代器，如果 item 未插入則返回 end()。(見作 用)

拋出:

T::T(const T&)  拋出的任何異常。

T::operator = (const T&)& nbsp;拋出的任何異常。

異常安全性:

基本；如果拋出一節中列出的操作沒有拋出則不拋出異常。

迭代器失效:

指向插入點之前的迭代器(直至開始，除了 pos)均失效。 指向被覆寫元素的迭代器也失效。

複雜度:

線性(與 std::distance(begin(), pos) 相關)。

參見:

rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator), insert(iterator, value_type), insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator)

前提條件：

pos 為指向 circular_buffer 或其尾部的有效迭代器。

作用:

min[n, (end() - pos) + reserve()]& nbsp;個元素將被插入到位置 pos 之前。
circular_buffer 尾部的 min[end() - pos, max[0, n - reserve()]] 個元素將被覆寫。
(詳細解釋請見例子) 

參數：

pos

指定 items 插入位置的迭代器。

n

被插入的 items 數量。 

item

被插入的元素。

拋出:

T::T(const T&)  拋出的任何異常。

T::operator = (const T&)& nbsp;拋出的任何異常。

異常安全性:

基本；如果拋出一節中列出的操作沒有拋出則不拋出異常。

迭代器失效:

指向插入點之前的迭代器(直至開始，除了 pos)均失效。 指向被覆寫元素的迭代器也失效。 

複雜度:

線性(與 min[capacity(), std::distance(begin(), pos) + n] 相關)。

例子：

考慮一個容量為6而大小為4的 circular_buffer。 其內部緩衝區可能如下：

|1|2|3|4| | |
p ---^

在位置 p 之前插入5個元素後:

rinsert(p, (size_t)5, 0);

實際上只有4個元素被插入，而元素 3 和 4 被覆寫。這是由於插入操作要保持容量不變。插入後的內部緩衝區如下：

|1|2|0|0|0|0|

作為比較，如果容量無需保持，則內部緩衝區會是這樣: |1|2|0|0|0|0|0|3|4|.

參見:

rinsert(iterator, value_type), rinsert(iterator, InputIterator, InputIterator), insert(iterator, value_type), insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator)

前提條件：

pos 為指向 circular_buffer 或其尾部的有效迭代器。 
有效區間 [first, last) 其中 first 和 last 符合 輸入迭代器 InputIterator 的要求。

作用:

區間 [first, last - max[0, distance(first, last) - (end() - pos) - reserve()]) 中的元素被插入到位置 pos 之前。
circular_buffer 尾部的 min[end() - pos, max[0, distance(first, last) - reserve()]] 個元素被覆寫。
(詳細解釋請見例子)

參數：

pos

指定區間插入位置的迭代器。

first

被插入區間的開始。

last

被插入區間的結束。

拋出:

T::T(const T&)  拋出的任何異常。

T::operator = (const T&)& nbsp;拋出的任何異常。

異常安全性:

基本；如果拋出一節中列出的操作沒有拋出則不拋出異常。

迭代器失效:

指向插入點之前的迭代器(直至開始，除了 pos)均失效。 指向被覆寫元素的迭代器也失效。 

複雜度:

線性(與 [std::distance(begin(), pos) + std::distance(first, last)] 相關；如果 InputIterator 為 隨 機訪問迭代器RandomAccessIterator 則與 min[capacity(), std::distance(begin(), pos) + std::distance(first, last)] 相關)。

例子：

考慮一個容量為6而大小為4的 circular_buffer。 其內部緩衝區可能如下：

|1|2|3|4| | |
p ---^

在位置 p 之前插入一個區間的元素後：

int array[] = { 5, 6, 7, 8, 9 };
insert(p, array, array + 5);

實際上只有指定區間中的元素 5, 6, 7 和 8 被插入，而元素 3 和 4 被覆寫。這是由於插入操作要保持容量不變。插入後的內部緩衝區如下：

|1|2|5|6|7|8|

作為比較，如果容量無需保持，則內部緩衝區會是這樣：|1|2|5|6|7|8|9|3|4|.

參見:

rinsert(iterator, value_type), rinsert(iterator, size_type, value_type), insert(iterator, value_type), insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator)

前提條件：

pos 是一個指向 circular_buffer& nbsp;的有效迭代器(但不是 end())。

作用:

位置 pos 的元素被刪除。

參數：

pos

指向被刪除元素的迭代器。

返回:

指向被刪除元素之後第一個元素的迭代器，如果不存在這樣的元素則返回 end().

拋出:

T::operator = (const T&)& nbsp;拋出的任何異常。

異常安全性:

基本；如果拋出一節中列出的操作沒有拋出則不拋出異常。

迭代器失效:

指向被刪除元素及其之後的元素的迭代器(直至未尾；除了等於 end() 的迭代器)均失效。

複雜度:

線性(與 std::distance(pos, end()) 相關)。

參見:

erase(iterator, iterator), rerase(iterator), rerase(iterator, iterator), clear()

前提條件：

有效區間 [first, last).

作用:

區間 [first, last) 中的元素被刪除。(如果 first == last 則沒有刪除)

參數：

first

被刪除區間的開始。

last

被刪除區間的結束。

返回:

指向被刪除元素之後第一個元素的迭代器，如果不存在這樣的元素則返回 end().

拋出:

T::operator = (const T&)& nbsp;拋出的任何異常。

異常安全性:

基本；如果拋出一節中列出的操作沒有拋出則不拋出異常。

迭代器失效:

指向被刪除元素及其之後的元素的迭代器(直至未尾；除了等於 end() 的迭代器)均失效。

複雜度:

線性(與 std::distance(first, end()) 相關)。

參見:

erase(iterator), rerase(iterator), rerase(iterator, iterator), clear()

前提條件：

pos 是一個指向 circular_buffer& nbsp;的有效迭代器(但不是 end())。  

作用:

位置 pos 的元素被刪除。

參數：

pos

指向被刪除元素的迭代器。

返回:

指向被刪除元素之前第一個元素的迭代器，如果不存在這樣的元素則返回 begin().

拋出:

T::operator = (const T&)& nbsp;拋出的任何異常。

異常安全性:

基本；如果拋出一節中列出的操作沒有拋出則不拋出異常。

迭代器失效:

指向被刪除元素及其之前的元素的迭代器(直至開始)均失效。

複雜度:

線性(與 std::distance(begin(), pos) 相關)。

說明：

該方法與 erase(iterator) 方法對稱，且如果迭代器 pos 靠近 circular_buffer 的頭部則比 erase(iterator) 更高效。(請見複雜度)

參見:

erase(iterator), erase(iterator, iterator), rerase(iterator, iterator), clear()

前提條件：

有效區間 [first, last).

作用:

區間 [first, last) 中的元素被刪除。(如果 first == last 則沒有刪除)

參數：

first

被刪除區間的開始。

last

被刪除區間的結束。

返回:

指向被刪除元素之前第一個元素的迭代器，如果不存在這樣的元素則返回 begin().

拋出:

T::operator = (const T&)& nbsp;拋出的任何異常。

異常安全性:

基本；如果拋出一節中列出的操作沒有拋出則不拋出異常。

迭代器失效:

指向被刪除元素及其之前的元素的迭代器(直至開始)均失效。

複雜度:

線性(與 std::distance(begin(), last) 相關)。

說明：

該方法與 erase(iterator, iterator) 方法對稱，且如果 std::distance(begin(), first) 小於 std::distance(last, end()) 則比 erase(iterator, iterator) 更高效。

參見:

erase(iterator), erase(iterator, iterator), rerase(iterator), clear()

作用:

size() == 0

拋出:

無。

異常安全性:

無拋出。

迭代器失效:

指向 circular_buffer 的所有迭代器(除了等於 end() 的迭代器)均失效。

複雜度:

線性(與 circular_buffer 的大小相關)。

參見:

~circular_buffer(), erase(iterator), erase(iterator, iterator), rerase(iterator), rerase(iterator, iterator)

參數：

lhs

用於比較的 circular_buffer.

rhs

用於比較的 circular_buffer.

返回:

lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin())

拋出:

無。

複雜度:

線性(與 circular_buffers 的大小相關)。

迭代器失效:

不會令任何迭代器失效。

參數

lhs

用於比較的 circular_buffer.

rhs

用於比較的 circular_buffer.

返回:

std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end())

拋出:

無。

複雜度:

線性(與 circular_buffers 的大小相關)。

迭代器失效:

不會令任何迭代器失效。

參數：

lhs

用於比較的 circular_buffer.

rhs

用於比較的 circular_buffer.

返回:

!(lhs == rhs)

拋出:

無。

複雜度:

線性(與 circular_buffers 的大小相關)。

迭代器失效:

不會令任何迭代器失效。

參見:

operator==(const circular_buffer<T,Alloc>&, const circular_buffer<T,Alloc>&)

參數：

lhs

用於比較的 circular_buffer.

rhs

用於比較的 circular_buffer.

返回:

rhs < lhs

拋出:

無。

複雜度:

線性(與 circular_buffers 的大小相關)。

迭代器失效:

不會令任何迭代器失效。

參見:

operator<(const circular_buffer<T,Alloc>&, const circular_buffer<T,Alloc>&)

參數：

lhs

用於比較的 circular_buffer.

rhs

用於比較的 circular_buffer.

返回:

!(rhs < lhs)

拋出:

無。

複雜度:

線性(與 circular_buffers 的大小相關)。

迭代器失效:

不會令任何迭代器失效。

參見:

operator<(const circular_buffer<T,Alloc>&, const circular_buffer<T,Alloc>&)

參數：

lhs

用於比較的 circular_buffer.

rhs

用於比較的 circular_buffer.

返回:

!(lhs < rhs)

拋出:

無。

複雜度:

線性(與 circular_buffers 的大小相關)。

迭代器失效:

不會令任何迭代器失效。

參見:

operator<(const circular_buffer<T,Alloc>&, const circular_buffer<T,Alloc>&)

作用:

lhs 包含原 rhs 的元素，反之亦然。

參數：

lhs

與 rhs 交換內容的 circular_buffer.

rhs

與 lhs 交換內容的 circular_buffer.

拋出:

無。

複雜度:

常數(與 circular_buffers 的大小相關)。

迭代器失效:

兩個 circular_buffers 的所有迭代器均失效。(另一方面，這些迭代器仍舊指向同一個元素但卻是不同的容器。如果你想使用這一特性，則必須關閉 對調試的支持，否則在使用這些失效迭代器時就會報告一個斷言。)

參見:

swap(circular_buffer<T, Alloc>&)