Class template deque

boost::interprocess::deque

Synopsis

// In header: <boost/interprocess/containers/deque.hpp>

template<typename T, typename Alloc> 
class deque {
public:
  // types
  typedef Base::iterator                          iterator;              
  typedef Base::const_iterator                    const_iterator;        
  typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
  typedef std::reverse_iterator< iterator >       reverse_iterator;      

  // construct/copy/destruct
  deque(const allocator_type & = allocator_type());
  deque(const deque &);
  deque(deque &&);
  deque(size_type, const value_type &, 
        const allocator_type & = allocator_type());
  deque(size_type);
  template<typename InpIt> 
    deque(InpIt, InpIt, const allocator_type & = allocator_type());
  deque& operator=(const deque &);
  deque& operator=(deque &&);
  ~deque();

  // public member functions
  allocator_type get_allocator() const;
  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;
  const_iterator cbegin() const;
  const_iterator cend() const;
  const_reverse_iterator crbegin() const;
  const_reverse_iterator crend() const;
  reference operator[](size_type) ;
  const_reference operator[](size_type) const;
  void priv_range_check(size_type) const;
  reference at(size_type) ;
  const_reference at(size_type) const;
  reference front() ;
  reference back() ;
  const_reference front() const;
  const_reference back() const;
  size_type size() const;
  size_type max_size() const;
  bool empty() const;
  void swap(deque &&) ;
  void assign(size_type, const T &) ;
  template<typename InpIt> void assign(InpIt, InpIt) ;
  void push_back(const value_type &) ;
  void push_back(value_type &&) ;
  void push_front(const value_type &) ;
  void push_front(value_type &&) ;
  void pop_back() ;
  void pop_front() ;
  iterator insert(const_iterator, const value_type &) ;
  iterator insert(const_iterator, value_type &&) ;
  void insert(const_iterator, size_type, const value_type &) ;
  template<typename InpIt> void insert(const_iterator, InpIt, InpIt) ;
  void emplace_back() ;
  void emplace_front() ;
  iterator emplace(const_iterator) ;
  void resize(size_type, const value_type &) ;
  void resize(size_type) ;
  iterator erase(const_iterator) ;
  iterator erase(const_iterator, const_iterator) ;
  void clear() ;
};

Description

Deque class

`deque` public construct/copy/destruct

deque(const allocator_type & a = allocator_type());

```
deque(const deque & x);
```
```
deque(deque && x);
```

deque(size_type n, const value_type & value, 
      const allocator_type & a = allocator_type());

```
deque(size_type n);
```

template<typename InpIt> 
  deque(InpIt first, InpIt last, const allocator_type & a = allocator_type());

```
deque& operator=(const deque & x);
```
```
deque& operator=(deque && x);
```
```
~deque();
```

`deque` public member functions

```
allocator_type get_allocator() const;
```
```
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;
```
```
const_iterator cbegin() const;
```
```
const_iterator cend() const;
```
```
const_reverse_iterator crbegin() const;
```
```
const_reverse_iterator crend() const;
```
```
reference operator[](size_type n) ;
```

const_reference operator[](size_type n) const;

void priv_range_check(size_type n) const;

```
reference at(size_type n) ;
```
```
const_reference at(size_type n) const;
```
```
reference front() ;
```
```
reference back() ;
```
```
const_reference front() const;
```
```
const_reference back() const;
```
```
size_type size() const;
```
```
size_type max_size() const;
```
```
bool empty() const;
```
```
void swap(deque && x) ;
```

void assign(size_type n, const T & val) ;

template<typename InpIt> void assign(InpIt first, InpIt last) ;

```
void push_back(const value_type & t) ;
```
```
void push_back(value_type && t) ;
```
```
void push_front(const value_type & t) ;
```
```
void push_front(value_type && t) ;
```
```
void pop_back() ;
```
```
void pop_front() ;
```

iterator insert(const_iterator position, const value_type & x) ;

iterator insert(const_iterator position, value_type && mx) ;

void insert(const_iterator pos, size_type n, const value_type & x) ;

template<typename InpIt> 
  void insert(const_iterator pos, InpIt first, InpIt last) ;

```
void emplace_back() ;
```
```
void emplace_front() ;
```
```
iterator emplace(const_iterator p) ;
```

void resize(size_type new_size, const value_type & x) ;

```
void resize(size_type new_size) ;
```
```
iterator erase(const_iterator pos) ;
```

iterator erase(const_iterator first, const_iterator last) ;

```
void clear() ;
```

Boost C++ Libraries

Class template deque

Synopsis

Description

deque public construct/copy/destruct

deque public member functions

`deque` public construct/copy/destruct

`deque` public member functions