| Home | Libraries | People | FAQ | More

## Boost.Container Header Reference

### Header <boost/container/allocator_traits.hpp>

    template<typename Alloc> struct allocator_traits;

### Header <boost/container/container_fwd.hpp>

    namespace boost {
      namespace container {
        struct ordered_range_t;
        struct ordered_unique_range_t;

        static const ordered_range_t ordered_range;
        static const ordered_unique_range_t ordered_unique_range;
      }
    }

### Header <boost/container/deque.hpp>

    namespace boost {
      namespace container {
        template<typename T, typename A = std::allocator<T> > class deque;
        template<typename T, typename A>
          bool operator==(const deque< T, A > & x, const deque< T, A > & y);
        template<typename T, typename A>
          bool operator<(const deque< T, A > & x, const deque< T, A > & y);
        template<typename T, typename A>
          bool operator!=(const deque< T, A > & x, const deque< T, A > & y);
        template<typename T, typename A>
          bool operator>(const deque< T, A > & x, const deque< T, A > & y);
        template<typename T, typename A>
          bool operator<=(const deque< T, A > & x, const deque< T, A > & y);
        template<typename T, typename A>
          bool operator>=(const deque< T, A > & x, const deque< T, A > & y);
        template<typename T, typename A>
          void swap(deque< T, A > & x, deque< T, A > & y);
      }
    }

### Header <boost/container/flat_map.hpp>

    namespace boost {
      namespace container {
        template<typename Key, typename T,
                 typename Pred = std::less< std::pair< Key, T> >,
                 typename A = std::allocator<T> >
          class flat_map;
        template<typename Key, typename T,
                 typename Pred = std::less< std::pair< Key, T> >,
                 typename A = std::allocator<T> >
          class flat_multimap;
        template<typename Key, typename T, typename Pred, typename A>
          bool operator==(const flat_map< Key, T, Pred, A > & x,
                          const flat_map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator<(const flat_map< Key, T, Pred, A > & x,
                         const flat_map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator!=(const flat_map< Key, T, Pred, A > & x,
                          const flat_map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator>(const flat_map< Key, T, Pred, A > & x,
                         const flat_map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator<=(const flat_map< Key, T, Pred, A > & x,
                          const flat_map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator>=(const flat_map< Key, T, Pred, A > & x,
                          const flat_map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          void swap(flat_map< Key, T, Pred, A > & x,
                    flat_map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator==(const flat_multimap< Key, T, Pred, A > & x,
                          const flat_multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator<(const flat_multimap< Key, T, Pred, A > & x,
                         const flat_multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator!=(const flat_multimap< Key, T, Pred, A > & x,
                          const flat_multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator>(const flat_multimap< Key, T, Pred, A > & x,
                         const flat_multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator<=(const flat_multimap< Key, T, Pred, A > & x,
                          const flat_multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator>=(const flat_multimap< Key, T, Pred, A > & x,
                          const flat_multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          void swap(flat_multimap< Key, T, Pred, A > & x,
                    flat_multimap< Key, T, Pred, A > & y);
      }
    }

### Header <boost/container/flat_set.hpp>

    namespace boost {
      namespace container {
        template<typename T, typename Pred = std::less<T>,
                 typename A = std::allocator<T> >
          class flat_set;
        template<typename T, typename Pred = std::less<T>,
                 typename A = std::allocator<T> >
          class flat_multiset;
        template<typename T, typename Pred, typename A>
          bool operator==(const flat_set< T, Pred, A > & x,
                          const flat_set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator<(const flat_set< T, Pred, A > & x,
                         const flat_set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator!=(const flat_set< T, Pred, A > & x,
                          const flat_set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator>(const flat_set< T, Pred, A > & x,
                         const flat_set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator<=(const flat_set< T, Pred, A > & x,
                          const flat_set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator>=(const flat_set< T, Pred, A > & x,
                          const flat_set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          void swap(flat_set< T, Pred, A > & x, flat_set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator==(const flat_multiset< T, Pred, A > & x,
                          const flat_multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator<(const flat_multiset< T, Pred, A > & x,
                         const flat_multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator!=(const flat_multiset< T, Pred, A > & x,
                          const flat_multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator>(const flat_multiset< T, Pred, A > & x,
                         const flat_multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator<=(const flat_multiset< T, Pred, A > & x,
                          const flat_multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator>=(const flat_multiset< T, Pred, A > & x,
                          const flat_multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          void swap(flat_multiset< T, Pred, A > & x,
                    flat_multiset< T, Pred, A > & y);
      }
    }

### Header <boost/container/list.hpp>

    namespace boost {
      namespace container {
        template<typename T, typename A = std::allocator<T> > class list;
        template<typename T, typename A>
          bool operator==(const list< T, A > & x, const list< T, A > & y);
        template<typename T, typename A>
          bool operator<(const list< T, A > & x, const list< T, A > & y);
        template<typename T, typename A>
          bool operator!=(const list< T, A > & x, const list< T, A > & y);
        template<typename T, typename A>
          bool operator>(const list< T, A > & x, const list< T, A > & y);
        template<typename T, typename A>
          bool operator<=(const list< T, A > & x, const list< T, A > & y);
        template<typename T, typename A>
          bool operator>=(const list< T, A > & x, const list< T, A > & y);
        template<typename T, typename A>
          void swap(list< T, A > & x, list< T, A > & y);
      }
    }

### Header <boost/container/map.hpp>

    namespace boost {
      namespace container {
        template<typename Key, typename T,
                 typename Pred = std::less< std::pair< const Key, T> >,
                 typename A = std::allocator<T> >
          class map;
        template<typename Key, typename T,
                 typename Pred = std::less< std::pair< const Key, T> >,
                 typename A = std::allocator<T> >
          class multimap;
        template<typename Key, typename T, typename Pred, typename A>
          bool operator==(const map< Key, T, Pred, A > & x,
                          const map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator<(const map< Key, T, Pred, A > & x,
                         const map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator!=(const map< Key, T, Pred, A > & x,
                          const map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator>(const map< Key, T, Pred, A > & x,
                         const map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator<=(const map< Key, T, Pred, A > & x,
                          const map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator>=(const map< Key, T, Pred, A > & x,
                          const map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          void swap(map< Key, T, Pred, A > & x, map< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator==(const multimap< Key, T, Pred, A > & x,
                          const multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator<(const multimap< Key, T, Pred, A > & x,
                         const multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator!=(const multimap< Key, T, Pred, A > & x,
                          const multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator>(const multimap< Key, T, Pred, A > & x,
                         const multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator<=(const multimap< Key, T, Pred, A > & x,
                          const multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          bool operator>=(const multimap< Key, T, Pred, A > & x,
                          const multimap< Key, T, Pred, A > & y);
        template<typename Key, typename T, typename Pred, typename A>
          void swap(multimap< Key, T, Pred, A > & x,
                    multimap< Key, T, Pred, A > & y);
      }
    }

### Header <boost/container/scoped_allocator.hpp>

    namespace boost {
      namespace container {
        struct allocator_arg_t;
        template<typename T> struct constructible_with_allocator_suffix;
        template<typename T> struct constructible_with_allocator_prefix;
        template<typename T, typename Alloc> struct uses_allocator;

        template<typename OuterAlloc, typename... InnerAllocs>
          class scoped_allocator_adaptor;

        static const allocator_arg_t allocator_arg;
        template<typename OuterA1, typename OuterA2, typename... InnerAllocs>
          bool operator==(const scoped_allocator_adaptor< OuterA1, InnerAllocs... > & a,
                          const scoped_allocator_adaptor< OuterA2, InnerAllocs... > & b);
        template<typename OuterA1, typename OuterA2, typename... InnerAllocs>
          bool operator!=(const scoped_allocator_adaptor< OuterA1, InnerAllocs... > & a,
                          const scoped_allocator_adaptor< OuterA2, InnerAllocs... > & b);
      }
    }

### Header <boost/container/set.hpp>

    namespace boost {
      namespace container {
        template<typename T, typename Pred = std::less<T>,
                 typename A = std::allocator<T> >
          class set;
        template<typename T, typename Pred = std::less<T>,
                 typename A = std::allocator<T> >
          class multiset;
        template<typename T, typename Pred, typename A>
          bool operator==(const set< T, Pred, A > & x,
                          const set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator<(const set< T, Pred, A > & x, const set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator!=(const set< T, Pred, A > & x,
                          const set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator>(const set< T, Pred, A > & x, const set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator<=(const set< T, Pred, A > & x,
                          const set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator>=(const set< T, Pred, A > & x,
                          const set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          void swap(set< T, Pred, A > & x, set< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator==(const multiset< T, Pred, A > & x,
                          const multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator<(const multiset< T, Pred, A > & x,
                         const multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator!=(const multiset< T, Pred, A > & x,
                          const multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator>(const multiset< T, Pred, A > & x,
                         const multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator<=(const multiset< T, Pred, A > & x,
                          const multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          bool operator>=(const multiset< T, Pred, A > & x,
                          const multiset< T, Pred, A > & y);
        template<typename T, typename Pred, typename A>
          void swap(multiset< T, Pred, A > & x, multiset< T, Pred, A > & y);
      }
    }

### Header <boost/container/slist.hpp>

    namespace boost {
      namespace container {
        template<typename T, typename A = std::allocator<T> > class slist;
        template<typename T, typename A>
          bool operator==(const slist< T, A > & x, const slist< T, A > & y);
        template<typename T, typename A>
          bool operator<(const slist< T, A > & sL1, const slist< T, A > & sL2);
        template<typename T, typename A>
          bool operator!=(const slist< T, A > & sL1, const slist< T, A > & sL2);
        template<typename T, typename A>
          bool operator>(const slist< T, A > & sL1, const slist< T, A > & sL2);
        template<typename T, typename A>
          bool operator<=(const slist< T, A > & sL1, const slist< T, A > & sL2);
        template<typename T, typename A>
          bool operator>=(const slist< T, A > & sL1, const slist< T, A > & sL2);
        template<typename T, typename A>
          void swap(slist< T, A > & x, slist< T, A > & y);
      }
    }

### Header <boost/container/stable_vector.hpp>

    namespace boost {
      namespace container {
        template<typename T, typename A = std::allocator<T> > class stable_vector;
        template<typename T, typename A>
          bool operator==(const stable_vector< T, A > & x,
                          const stable_vector< T, A > & y);
        template<typename T, typename A>
          bool operator<(const stable_vector< T, A > & x,
                         const stable_vector< T, A > & y);
        template<typename T, typename A>
          bool operator!=(const stable_vector< T, A > & x,
                          const stable_vector< T, A > & y);
        template<typename T, typename A>
          bool operator>(const stable_vector< T, A > & x,
                         const stable_vector< T, A > & y);
        template<typename T, typename A>
          bool operator>=(const stable_vector< T, A > & x,
                          const stable_vector< T, A > & y);
        template<typename T, typename A>
          bool operator<=(const stable_vector< T, A > & x,
                          const stable_vector< T, A > & y);
        template<typename T, typename A>
          void swap(stable_vector< T, A > & x, stable_vector< T, A > & y);
      }
    }

### Header <boost/container/string.hpp>

    namespace boost {
      namespace container {
        template<typename CharT, typename Traits = std::char_traits<CharT>,
                 typename A = std::allocator<CharT> >
          class basic_string;
        typedef basic_string< char,std::char_traits< char >,std::allocator< char > > string;
        typedef basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > wstring;
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A >
          operator+(const basic_string< CharT, Traits, A > & x,
                    const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
          operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx,
                    basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
          operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx,
                    const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
          operator+(const basic_string< CharT, Traits, A > & x,
                    basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A >
          operator+(const CharT * s, const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
          operator+(const CharT * s,
                    basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A >
          operator+(CharT c, const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
          operator+(CharT c,
                    basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A >
          operator+(const basic_string< CharT, Traits, A > & x, const CharT * s);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
          operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx,
                    const CharT * s);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A >
          operator+(const basic_string< CharT, Traits, A > & x, const CharT c);
        template<typename CharT, typename Traits, typename A>
          basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
          operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx,
                    const CharT c);
        template<typename CharT, typename Traits, typename A>
          bool operator==(const basic_string< CharT, Traits, A > & x,
                          const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator==(const CharT * s,
                          const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator==(const basic_string< CharT, Traits, A > & x,
                          const CharT * s);
        template<typename CharT, typename Traits, typename A>
          bool operator!=(const basic_string< CharT, Traits, A > & x,
                          const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator!=(const CharT * s,
                          const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator!=(const basic_string< CharT, Traits, A > & x,
                          const CharT * s);
        template<typename CharT, typename Traits, typename A>
          bool operator<(const basic_string< CharT, Traits, A > & x,
                         const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator<(const CharT * s,
                         const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator<(const basic_string< CharT, Traits, A > & x,
                         const CharT * s);
        template<typename CharT, typename Traits, typename A>
          bool operator>(const basic_string< CharT, Traits, A > & x,
                         const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator>(const CharT * s,
                         const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator>(const basic_string< CharT, Traits, A > & x,
                         const CharT * s);
        template<typename CharT, typename Traits, typename A>
          bool operator<=(const basic_string< CharT, Traits, A > & x,
                          const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator<=(const CharT * s,
                          const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator<=(const basic_string< CharT, Traits, A > & x,
                          const CharT * s);
        template<typename CharT, typename Traits, typename A>
          bool operator>=(const basic_string< CharT, Traits, A > & x,
                          const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator>=(const CharT * s,
                          const basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          bool operator>=(const basic_string< CharT, Traits, A > & x,
                          const CharT * s);
        template<typename CharT, typename Traits, typename A>
          void swap(basic_string< CharT, Traits, A > & x,
                    basic_string< CharT, Traits, A > & y);
        template<typename CharT, typename Traits, typename A>
          std::basic_ostream< CharT, Traits > &
          operator<<(std::basic_ostream< CharT, Traits > & os,
                     const basic_string< CharT, Traits, A > & s);
        template<typename CharT, typename Traits, typename A>
          std::basic_istream< CharT, Traits > &
          operator>>(std::basic_istream< CharT, Traits > & is,
                     basic_string< CharT, Traits, A > & s);
        template<typename CharT, typename Traits, typename A>
          std::basic_istream< CharT, Traits > &
          getline(std::istream & is, basic_string< CharT, Traits, A > & s,
                  CharT delim);
        template<typename CharT, typename Traits, typename A>
          std::basic_istream< CharT, Traits > &
          getline(std::basic_istream< CharT, Traits > & is,
                  basic_string< CharT, Traits, A > & s);
        template<typename Ch, typename A>
          std::size_t hash_value(basic_string< Ch, std::char_traits< Ch >, A > const & v);
      }
    }

### Header <boost/container/vector.hpp>

    namespace boost {
      namespace container {
        template<typename T, typename A = std::allocator<T> > class vector;
        template<typename T, typename A>
          bool operator==(const vector< T, A > & x, const vector< T, A > & y);
        template<typename T, typename A>
          bool operator!=(const vector< T, A > & x, const vector< T, A > & y);
        template<typename T, typename A>
          bool operator<(const vector< T, A > & x, const vector< T, A > & y);
        template<typename T, typename A>
          void swap(vector< T, A > & x, vector< T, A > & y);
      }
    }