Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext

Boost.Container Header Reference

Header <boost/container/allocator_traits.hpp>
Header <boost/container/container_fwd.hpp>
Header <boost/container/deque.hpp>
Header <boost/container/flat_map.hpp>
Header <boost/container/flat_set.hpp>
Header <boost/container/list.hpp>
Header <boost/container/map.hpp>
Header <boost/container/scoped_allocator.hpp>
Header <boost/container/scoped_allocator_fwd.hpp>
Header <boost/container/set.hpp>
Header <boost/container/slist.hpp>
Header <boost/container/stable_vector.hpp>
Header <boost/container/static_vector.hpp>
Header <boost/container/string.hpp>
Header <boost/container/throw_exception.hpp>
Header <boost/container/vector.hpp>

Header <boost/container/allocator_traits.hpp>

template<typename Alloc> struct allocator_traits;

Header <boost/container/container_fwd.hpp>

namespace boost {
  namespace container {
    template<typename T, typename Allocator = std::allocator<T> > class vector;
    template<typename T, typename Allocator = std::allocator<T> > 
      class stable_vector;
    template<typename CharT, typename Traits = std::char_traits<CharT>, 
             typename Allocator = std::allocator<CharT> > 
      class basic_string;

    struct ordered_range_t;
    struct ordered_unique_range_t;
    struct default_init_t;

    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> 
      bool operator==(const deque< T, Allocator > & x, 
                      const deque< T, Allocator > & y);
    template<typename T, typename Allocator> 
      bool operator<(const deque< T, Allocator > & x, 
                     const deque< T, Allocator > & y);
    template<typename T, typename Allocator> 
      bool operator!=(const deque< T, Allocator > & x, 
                      const deque< T, Allocator > & y);
    template<typename T, typename Allocator> 
      bool operator>(const deque< T, Allocator > & x, 
                     const deque< T, Allocator > & y);
    template<typename T, typename Allocator> 
      bool operator>=(const deque< T, Allocator > & x, 
                      const deque< T, Allocator > & y);
    template<typename T, typename Allocator> 
      bool operator<=(const deque< T, Allocator > & x, 
                      const deque< T, Allocator > & y);
    template<typename T, typename Allocator> 
      void swap(deque< T, Allocator > & x, deque< T, Allocator > & y);
  }
}

Header <boost/container/flat_map.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator==(const flat_map< Key, T, Compare, Allocator > & x, 
                      const flat_map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator<(const flat_map< Key, T, Compare, Allocator > & x, 
                     const flat_map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator!=(const flat_map< Key, T, Compare, Allocator > & x, 
                      const flat_map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator>(const flat_map< Key, T, Compare, Allocator > & x, 
                     const flat_map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator<=(const flat_map< Key, T, Compare, Allocator > & x, 
                      const flat_map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator>=(const flat_map< Key, T, Compare, Allocator > & x, 
                      const flat_map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      void swap(flat_map< Key, T, Compare, Allocator > & x, 
                flat_map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator==(const flat_multimap< Key, T, Compare, Allocator > & x, 
                      const flat_multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator<(const flat_multimap< Key, T, Compare, Allocator > & x, 
                     const flat_multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator!=(const flat_multimap< Key, T, Compare, Allocator > & x, 
                      const flat_multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator>(const flat_multimap< Key, T, Compare, Allocator > & x, 
                     const flat_multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator<=(const flat_multimap< Key, T, Compare, Allocator > & x, 
                      const flat_multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator>=(const flat_multimap< Key, T, Compare, Allocator > & x, 
                      const flat_multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      void swap(flat_multimap< Key, T, Compare, Allocator > & x, 
                flat_multimap< Key, T, Compare, Allocator > & y);
  }
}

Header <boost/container/flat_set.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename Compare, typename Allocator> 
      bool operator==(const flat_set< Key, Compare, Allocator > & x, 
                      const flat_set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator<(const flat_set< Key, Compare, Allocator > & x, 
                     const flat_set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator!=(const flat_set< Key, Compare, Allocator > & x, 
                      const flat_set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator>(const flat_set< Key, Compare, Allocator > & x, 
                     const flat_set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator<=(const flat_set< Key, Compare, Allocator > & x, 
                      const flat_set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator>=(const flat_set< Key, Compare, Allocator > & x, 
                      const flat_set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      void swap(flat_set< Key, Compare, Allocator > & x, 
                flat_set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator==(const flat_multiset< Key, Compare, Allocator > & x, 
                      const flat_multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator<(const flat_multiset< Key, Compare, Allocator > & x, 
                     const flat_multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator!=(const flat_multiset< Key, Compare, Allocator > & x, 
                      const flat_multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator>(const flat_multiset< Key, Compare, Allocator > & x, 
                     const flat_multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator<=(const flat_multiset< Key, Compare, Allocator > & x, 
                      const flat_multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator>=(const flat_multiset< Key, Compare, Allocator > & x, 
                      const flat_multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      void swap(flat_multiset< Key, Compare, Allocator > & x, 
                flat_multiset< Key, Compare, Allocator > & y);
  }
}

Header <boost/container/list.hpp>

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

Header <boost/container/map.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator==(const map< Key, T, Compare, Allocator > & x, 
                      const map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator<(const map< Key, T, Compare, Allocator > & x, 
                     const map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator!=(const map< Key, T, Compare, Allocator > & x, 
                      const map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator>(const map< Key, T, Compare, Allocator > & x, 
                     const map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator<=(const map< Key, T, Compare, Allocator > & x, 
                      const map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator>=(const map< Key, T, Compare, Allocator > & x, 
                      const map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      void swap(map< Key, T, Compare, Allocator > & x, 
                map< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator==(const multimap< Key, T, Compare, Allocator > & x, 
                      const multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator<(const multimap< Key, T, Compare, Allocator > & x, 
                     const multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator!=(const multimap< Key, T, Compare, Allocator > & x, 
                      const multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator>(const multimap< Key, T, Compare, Allocator > & x, 
                     const multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator<=(const multimap< Key, T, Compare, Allocator > & x, 
                      const multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      bool operator>=(const multimap< Key, T, Compare, Allocator > & x, 
                      const multimap< Key, T, Compare, Allocator > & y);
    template<typename Key, typename T, typename Compare, typename Allocator> 
      void swap(multimap< Key, T, Compare, Allocator > & x, 
                multimap< Key, T, Compare, Allocator > & y);
  }
}

Header <boost/container/scoped_allocator.hpp>

namespace boost {
  namespace container {
    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 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/scoped_allocator_fwd.hpp>

namespace boost {
  namespace container {
    struct allocator_arg_t;

    static const allocator_arg_t allocator_arg;
  }
}

Header <boost/container/set.hpp>

namespace boost {
  namespace container {
    template<typename Key, typename Compare, typename Allocator> 
      bool operator==(const set< Key, Compare, Allocator > & x, 
                      const set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator<(const set< Key, Compare, Allocator > & x, 
                     const set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator!=(const set< Key, Compare, Allocator > & x, 
                      const set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator>(const set< Key, Compare, Allocator > & x, 
                     const set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator<=(const set< Key, Compare, Allocator > & x, 
                      const set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator>=(const set< Key, Compare, Allocator > & x, 
                      const set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      void swap(set< Key, Compare, Allocator > & x, 
                set< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator==(const multiset< Key, Compare, Allocator > & x, 
                      const multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator<(const multiset< Key, Compare, Allocator > & x, 
                     const multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator!=(const multiset< Key, Compare, Allocator > & x, 
                      const multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator>(const multiset< Key, Compare, Allocator > & x, 
                     const multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator<=(const multiset< Key, Compare, Allocator > & x, 
                      const multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      bool operator>=(const multiset< Key, Compare, Allocator > & x, 
                      const multiset< Key, Compare, Allocator > & y);
    template<typename Key, typename Compare, typename Allocator> 
      void swap(multiset< Key, Compare, Allocator > & x, 
                multiset< Key, Compare, Allocator > & y);
  }
}

Header <boost/container/slist.hpp>

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

Header <boost/container/stable_vector.hpp>

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

Header <boost/container/static_vector.hpp>

namespace boost {
  namespace container {
    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 {
    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 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 > && mx, 
                basic_string< CharT, Traits, Allocator > && my);
    template<typename CharT, typename Traits, typename Allocator> 
      basic_string< CharT, Traits, Allocator > 
      operator+(basic_string< CharT, Traits, Allocator > && mx, 
                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 > && my);
    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 * str);
    void throw_length_error(const char * str);
    void throw_logic_error(const char * str);
    void throw_runtime_error(const char * str);
  }
}

Header <boost/container/vector.hpp>

template<typename T, typename Allocator = std::allocator<T> > class vector;namespace boost {
  namespace container {
     vec_iterator();
     vec_iterator(vec_iterator< Pointer, false > const & other);
    reference operator*();
    pointer operator->();
    reference operator[](difference_type off);
    vec_iterator & operator++();
    vec_iterator operator++(int);
    vec_iterator & operator--();
    vec_iterator operator--(int);
    vec_iterator & operator+=(difference_type off);
    vec_iterator & operator-=(difference_type off);
    friend vec_iterator operator+(const vec_iterator & x, difference_type off);
    friend vec_iterator operator+(difference_type off, vec_iterator right);
    friend vec_iterator operator-(vec_iterator left, difference_type off);
    friend difference_type 
    operator-(const vec_iterator & left, const vec_iterator & right);
    friend bool operator==(const vec_iterator & l, const vec_iterator & r);
    friend bool operator!=(const vec_iterator & l, const vec_iterator & r);
    friend bool operator<(const vec_iterator & l, const vec_iterator & r);
    friend bool operator<=(const vec_iterator & l, const vec_iterator & r);
    friend bool operator>(const vec_iterator & l, const vec_iterator & r);
    friend bool operator>=(const vec_iterator & l, const vec_iterator & r);
  }
}
template<typename Pointer, bool IsConst> 
  const Pointer & vector_iterator_get_ptr(unspecified it);
template<typename Pointer, bool IsConst> Pointer & get_ptr(unspecified it);
template<typename T, typename Allocator> 
  bool operator==(const vector< T, Allocator > & x, 
                  const vector< T, Allocator > & y);
template<typename T, typename Allocator> 
  bool operator!=(const vector< T, Allocator > & x, 
                  const vector< T, Allocator > & y);
template<typename T, typename Allocator> 
  bool operator<(const vector< T, Allocator > & x, 
                 const vector< T, Allocator > & y);
template<typename T, typename Allocator> 
  void swap(vector< T, Allocator > & x, vector< T, Allocator > & y);
Copyright © 2009-2013 Ion Gaztanaga

Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

PrevUpHomeNext