| Home | Libraries | People | FAQ | More

## Class template deque

boost::interprocess::deque

## Synopsis

    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(unspecified);
      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=(unspecified);
      ~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 swap(unspecified) ;
      void assign(size_type, const T &) ;
      template<typename InpIt> void assign(InpIt, InpIt) ;
      void push_back(const value_type &) ;
      void push_back(unspecified) ;
      void push_front(const value_type &) ;
      void push_front(unspecified) ;
      void pop_back() ;
      void pop_front() ;
      iterator insert(const_iterator, const value_type &) ;
      iterator insert(const_iterator, unspecified) ;
      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

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

2.     deque(const deque & x);

3.     deque(unspecified mx);

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

5.     deque(size_type n);

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

7.     deque& operator=(const deque & x);

8.     deque& operator=(unspecified mx);

9.     ~deque();

### `deque` public member functions

1.     allocator_type get_allocator() const;

2.     iterator begin() ;

3.     iterator end() ;

4.     const_iterator begin() const;

5.     const_iterator end() const;

6.     reverse_iterator rbegin() ;

7.     reverse_iterator rend() ;

8.     const_reverse_iterator rbegin() const;

9.     const_reverse_iterator rend() const;

10.     const_iterator cbegin() const;

11.     const_iterator cend() const;

12.     const_reverse_iterator crbegin() const;

13.     const_reverse_iterator crend() const;

14.     reference operator[](size_type n) ;

15.     const_reference operator[](size_type n) const;

16.     void priv_range_check(size_type n) const;

17.     reference at(size_type n) ;

18.     const_reference at(size_type n) const;

19.     reference front() ;

20.     reference back() ;

21.     const_reference front() const;

22.     const_reference back() const;

23.     size_type size() const;

24.     size_type max_size() const;

25.     bool empty() const;

26.     void swap(deque & x) ;

27.     void swap(unspecified mx) ;

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

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

30.     void push_back(const value_type & t) ;

31.     void push_back(unspecified mt) ;

32.     void push_front(const value_type & t) ;

33.     void push_front(unspecified mt) ;

34.     void pop_back() ;

35.     void pop_front() ;

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

37.     iterator insert(const_iterator position, unspecified m) ;

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

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

40.     void emplace_back() ;

41.     void emplace_front() ;

42.     iterator emplace(const_iterator p) ;

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

44.     void resize(size_type new_size) ;

45.     iterator erase(const_iterator pos) ;

46.     iterator erase(const_iterator first, const_iterator last) ;

47.     void clear() ;