Reference

Header <boost/unordered_set.hpp>
Header <boost/unordered_map.hpp>

Header <boost/unordered_set.hpp>

namespace boost {
  template<typename Value, typename Hash = boost::hash<Value>, 
           typename Pred = std::equal_to<Value>, 
           typename Alloc = std::allocator<Value> > 
    class unordered_set;
  template<typename Value, typename Hash, typename Pred, typename Alloc> 
    bool operator==(unordered_set<Value, Hash, Pred, Alloc> const&, 
                    unordered_set<Value, Hash, Pred, Alloc> const&);
  template<typename Value, typename Hash, typename Pred, typename Alloc> 
    bool operator!=(unordered_set<Value, Hash, Pred, Alloc> const&, 
                    unordered_set<Value, Hash, Pred, Alloc> const&);
  template<typename Value, typename Hash, typename Pred, typename Alloc> 
    void swap(unordered_set<Value, Hash, Pred, Alloc>&, 
              unordered_set<Value, Hash, Pred, Alloc>&);
  template<typename Value, typename Hash = boost::hash<Value>, 
           typename Pred = std::equal_to<Value>, 
           typename Alloc = std::allocator<Value> > 
    class unordered_multiset;
  template<typename Value, typename Hash, typename Pred, typename Alloc> 
    bool operator==(unordered_multiset<Value, Hash, Pred, Alloc> const&, 
                    unordered_multiset<Value, Hash, Pred, Alloc> const&);
  template<typename Value, typename Hash, typename Pred, typename Alloc> 
    bool operator!=(unordered_multiset<Value, Hash, Pred, Alloc> const&, 
                    unordered_multiset<Value, Hash, Pred, Alloc> const&);
  template<typename Value, typename Hash, typename Pred, typename Alloc> 
    void swap(unordered_multiset<Value, Hash, Pred, Alloc>&, 
              unordered_multiset<Value, Hash, Pred, Alloc>&);
  namespace unordered {
    template<typename ImplementationDefined> class node_handle_set;
    template<typename ImplementationDefined> 
      void swap(node_handle_set<ImplementationDefined>&, 
                node_handle_set<ImplementationDefined>&);
  }
}

Header <boost/unordered_map.hpp>

namespace boost {
  template<typename Key, typename Mapped, typename Hash = boost::hash<Key>, 
           typename Pred = std::equal_to<Key>, 
           typename Alloc = std::allocator<std::pair<Key const, Mapped>> > 
    class unordered_map;
  template<typename Key, typename Mapped, typename Hash, typename Pred, 
           typename Alloc> 
    bool operator==(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&, 
                    unordered_map<Key, Mapped, Hash, Pred, Alloc> const&);
  template<typename Key, typename Mapped, typename Hash, typename Pred, 
           typename Alloc> 
    bool operator!=(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&, 
                    unordered_map<Key, Mapped, Hash, Pred, Alloc> const&);
  template<typename Key, typename Mapped, typename Hash, typename Pred, 
           typename Alloc> 
    void swap(unordered_map<Key, Mapped, Hash, Pred, Alloc>&, 
              unordered_map<Key, Mapped, Hash, Pred, Alloc>&);
  template<typename Key, typename Mapped, typename Hash = boost::hash<Key>, 
           typename Pred = std::equal_to<Key>, 
           typename Alloc = std::allocator<std::pair<Key const, Mapped>> > 
    class unordered_multimap;
  template<typename Key, typename Mapped, typename Hash, typename Pred, 
           typename Alloc> 
    bool operator==(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, 
                    unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&);
  template<typename Key, typename Mapped, typename Hash, typename Pred, 
           typename Alloc> 
    bool operator!=(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, 
                    unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&);
  template<typename Key, typename Mapped, typename Hash, typename Pred, 
           typename Alloc> 
    void swap(unordered_multimap<Key, Mapped, Hash, Pred, Alloc>&, 
              unordered_multimap<Key, Mapped, Hash, Pred, Alloc>&);
  namespace unordered {
    template<typename ImplementationDefined> class node_handle_map;
    template<typename ImplementationDefined> 
      void swap(node_handle_map<ImplementationDefined>&, 
                node_handle_map<ImplementationDefined>&);
  }
}