| Home | Libraries | People | FAQ | More

## Boost.Container Header Reference

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

    namespace boost {
      namespace container {
        template<typename T, std::size_t NodesPerBlock = ADP_nodes_per_block,
                 std::size_t MaxFreeBlocks = ADP_max_free_blocks,
                 std::size_t OverheadPercent = ADP_overhead_percent>
          class adaptive_pool;
      }
    }

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

This class is an extended STL-compatible that offers advanced allocation mechanism (in-place expansion, shrinking, burst-allocation...)

This allocator is a wrapper around a modified DLmalloc.

    namespace boost {
      namespace container {
        template<typename T> class allocator;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename Allocator> struct allocator_traits;
      }
    }

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

This header file forward declares the following containers:

- boost::container::vector

- boost::container::stable_vector

- boost::container::static_vector

- boost::container::slist

- boost::container::list

- boost::container::set

- boost::container::multiset

- boost::container::map

- boost::container::multimap

- boost::container::flat_set

- boost::container::flat_multiset

- boost::container::flat_map

- boost::container::flat_multimap

- boost::container::basic_string

- boost::container::string

- boost::container::wstring

It forward declares the following allocators:

- boost::container::allocator

- boost::container::node_allocator

- boost::container::adaptive_pool

And finally it defines the following types

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

        enum tree_type_enum;
        typedef implementation_defined tree_assoc_defaults;

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

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

    namespace boost {
      namespace container {
        template<typename T, typename Allocator = new_allocator<T> > class deque;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename Key, typename T, typename Compare = std::less<Key>,
                 typename Allocator = new_allocator< std::pair< Key, T> > >
          class flat_map;
        template<typename Key, typename T, typename Compare = std::less<Key>,
                 typename Allocator = new_allocator< std::pair< Key, T> > >
          class flat_multimap;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename Key, typename Compare = std::less<Key>,
                 typename Allocator = new_allocator<Key> >
          class flat_multiset;
        template<typename Key, typename Compare = std::less<Key>,
                 typename Allocator = new_allocator<Key> >
          class flat_set;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename T, typename Allocator = new_allocator<T> > class list;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename Key, typename T, typename Compare = std::less<Key>,
                 typename Allocator = new_allocator< std::pair< const Key, T> >,
                 typename MapOptions = tree_assoc_defaults>
          class map;
        template<typename Key, typename T, typename Compare = std::less<Key>,
                 typename Allocator = new_allocator< std::pair< const Key, T> >,
                 typename MultiMapOptions = tree_assoc_defaults>
          class multimap;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename T> class new_allocator;

        template<> class new_allocator<void>;

        template<bool Value> struct new_allocator_bool;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename T,
                 std::size_t NodesPerBlock = NodeAlloc_nodes_per_block>
          class node_allocator;
      }
    }

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

    namespace boost {
      namespace container {
        template<bool Enabled> struct optimize_size;
        template<class... Options> struct tree_assoc_options;
        template<tree_type_enum TreeType> struct tree_type;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename T> struct constructible_with_allocator_prefix;
        template<typename T> struct constructible_with_allocator_suffix;

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

        template<typename T, typename Allocator> struct uses_allocator;
        template<typename OuterA1, typename OuterA2,
                 BOOST_CONTAINER_SCOPEDALLOC_ALLINNERCLASS >
          bool operator==(const scoped_allocator_adaptor< OuterA1, InnerAllocs...> & a,
                          const scoped_allocator_adaptor< OuterA2, InnerAllocs...> & b);
        template<typename OuterA1, typename OuterA2,
                 BOOST_CONTAINER_SCOPEDALLOC_ALLINNERCLASS >
          bool operator!=(const scoped_allocator_adaptor< OuterA1, InnerAllocs...> & a,
                          const scoped_allocator_adaptor< OuterA2, InnerAllocs...> & b);
      }
    }

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

This header file forward declares boost::container::scoped_allocator_adaptor and defines the following types:

    namespace boost {
      namespace container {
        typedef const std::allocator_arg_t & allocator_arg_t;

        static allocator_arg_t allocator_arg;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename Key, typename Compare = std::less<Key>,
                 typename Allocator = new_allocator<Key>,
                 typename MultiSetOptions = tree_assoc_defaults>
          class multiset;
        template<typename Key, typename Compare = std::less<Key>,
                 typename Allocator = new_allocator<Key>,
                 typename SetOptions = tree_assoc_defaults>
          class set;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename T, typename Allocator = new_allocator<T> > class slist;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename T, std::size_t N,
                 typename Allocator = new_allocator<T> >
          class small_vector;
        template<typename Allocator> class small_vector_allocator;
        template<typename T, typename SecondaryAllocator> class small_vector_base;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename T, typename Allocator = new_allocator<T> >
          class stable_vector;
      }
    }

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

    namespace boost {
      namespace container {
        template<typename Value, std::size_t Capacity> class static_vector;
        template<typename V, std::size_t C1, std::size_t C2>
          bool operator==(static_vector< V, C1 > const &,
                          static_vector< V, C2 > const &);
        template<typename V, std::size_t C1, std::size_t C2>
          bool operator!=(static_vector< V, C1 > const &,
                          static_vector< V, C2 > const &);
        template<typename V, std::size_t C1, std::size_t C2>
          bool operator<(static_vector< V, C1 > const &,
                         static_vector< V, C2 > const &);
        template<typename V, std::size_t C1, std::size_t C2>
          bool operator>(static_vector< V, C1 > const &,
                         static_vector< V, C2 > const &);
        template<typename V, std::size_t C1, std::size_t C2>
          bool operator<=(static_vector< V, C1 > const &,
                          static_vector< V, C2 > const &);
        template<typename V, std::size_t C1, std::size_t C2>
          bool operator>=(static_vector< V, C1 > const &,
                          static_vector< V, C2 > const &);
        template<typename V, std::size_t C1, std::size_t C2>
          void swap(static_vector< V, C1 > &, static_vector< V, C2 > &);
      }
    }

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

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

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

    namespace boost {
      namespace container {
        void throw_bad_alloc();
        void throw_out_of_range(const char *);
        void throw_length_error(const char *);
        void throw_logic_error(const char *);
        void throw_runtime_error(const char *);
      }
    }

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

    namespace boost {
      namespace container {
        template<typename T, typename Allocator = new_allocator<T> > class vector;
      }
    }