Can I insert objects into tr1 unordered_map

Question

I have a large amount of data to process in c++ and find that unordered_map works effienct However, there is no example to stores objects in unorderd_map. When I tried myself it fails to complie.

First I inculde unordered_map

#include <tr1/unordered_map>

then define the type

typedef std::tr1::unordered_map<Vector3f, Vector3f> vectorMap;

Vector3f here is class I created. When I complile above it do not returns any error. However when I add

vectorMap _map; 
Vector3f v1,v2,v3;
_map.insert(std::make_pair(v1,v2));

complier returns a large paragraph of error, could you please tell me is there something wrong when I insert the pair, or it unsorted doesn't support inserting object, if not, is there any other effient wayin storing and searching objects pairs like hashmap in JAVA. Following is the error message reports in complier:

In file included from /usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/string:50,
                 from /usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/bits/locale_classes.h:42,
                 from /usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/bits/ios_base.h:43,
                 from /usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/ios:43,
                 from /usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/ostream:40,
                 from /usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/iostream:40,
                 from homework1.cc:1:
/usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/bits/stl_function.h: In member function ‘bool std::equal_to<_Tp>::operator()(const _Tp&, const _Tp&) const [with _Tp = Vector3f]’:
/usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/tr1_impl/hashtable_policy.h:769:   instantiated from ‘bool std::tr1::__detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, std::tr1::__detail::_Default_ranged_hash, false>::_M_compare(const _Key&, size_t, std::tr1::__detail::_Hash_node<_Value, false>*) const [with _Key = Vector3f, _Value = std::pair<const Vector3f, Vector3f>, _ExtractKey = std::_Select1st<std::pair<const Vector3f, Vector3f> >, _Equal = std::equal_to<Vector3f>, _H1 = std::tr1::hash<Vector3f>, _H2 = std::tr1::__detail::_Mod_range_hashing]’
/usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/tr1_impl/hashtable:918:   instantiated from ‘std::tr1::__detail::_Hash_node<_Value, __cache_hash_code>* std::tr1::_Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __cache_hash_code, __constant_iterators, __unique_keys>::_M_find_node(std::tr1::__detail::_Hash_node<_Value, __cache_hash_code>*, const _Key&, typename std::tr1::_Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __cache_hash_code, __constant_iterators, __unique_keys>::_Hash_code_type) const [with _Key = Vector3f, _Value = std::pair<const Vector3f, Vector3f>, _Allocator = std::allocator<std::pair<const Vector3f, Vector3f> >, _ExtractKey = std::_Select1st<std::pair<const Vector3f, Vector3f> >, _Equal = std::equal_to<Vector3f>, _H1 = std::tr1::hash<Vector3f>, _H2 = std::tr1::__detail::_Mod_range_hashing, _Hash = std::tr1::__detail::_Default_ranged_hash, _RehashPolicy = std::tr1::__detail::_Prime_rehash_policy, bool __cache_hash_code = false, bool __constant_iterators = false, bool __unique_keys = true]’
/usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/tr1_impl/hashtable:983:   instantiated from ‘std::pair<typename std::tr1::_Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __cache_hash_code, __constant_iterators, __unique_keys>::iterator, bool> std::tr1::_Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __cache_hash_code, __constant_iterators, __unique_keys>::_M_insert(const _Value&, std::tr1::true_type) [with _Key = Vector3f, _Value = std::pair<const Vector3f, Vector3f>, _Allocator = std::allocator<std::pair<const Vector3f, Vector3f> >, _ExtractKey = std::_Select1st<std::pair<const Vector3f, Vector3f> >, _Equal = std::equal_to<Vector3f>, _H1 = std::tr1::hash<Vector3f>, _H2 = std::tr1::__detail::_Mod_range_hashing, _Hash = std::tr1::__detail::_Default_ranged_hash, _RehashPolicy = std::tr1::__detail::_Prime_rehash_policy, bool __cache_hash_code = false, bool __constant_iterators = false, bool __unique_keys = true]’
/usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/tr1_impl/hashtable:420:   instantiated from ‘typename __gnu_cxx::__conditional_type<__unique_keys, std::pair<std::tr1::__detail::_Hashtable_iterator<_Value, __constant_iterators, __cache_hash_code>, bool>, std::tr1::__detail::_Hashtable_iterator<_Value, __constant_iterators, __cache_hash_code> >::__type std::tr1::_Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __cache_hash_code, __constant_iterators, __unique_keys>::insert(const _Value&) [with _Key = Vector3f, _Value = std::pair<const Vector3f, Vector3f>, _Allocator = std::allocator<std::pair<const Vector3f, Vector3f> >, _ExtractKey = std::_Select1st<std::pair<const Vector3f, Vector3f> >, _Equal = std::equal_to<Vector3f>, _H1 = std::tr1::hash<Vector3f>, _H2 = std::tr1::__detail::_Mod_range_hashing, _Hash = std::tr1::__detail::_Default_ranged_hash, _RehashPolicy = std::tr1::__detail::_Prime_rehash_policy, bool __cache_hash_code = false, bool __constant_iterators = false, bool __unique_keys = true]’
homework1.cc:181:   instantiated from here
/usr/lib/gcc/x86_64-redhat-linux/4.4.5/../../../../include/c++/4.4.5/bits/stl_function.h:203: error: no match for ‘operator==’ in ‘__x == __y’

This is the Vector3f class

class Vector3f {

    float _item[3];

    public:

    float & operator [] (int i) {
        return _item[i];
        }

    Vector3f(float x, float y, float z) 
    {  _item[0] = x ; _item[1] = y ; _item[2] = z; };

    Vector3f() {};


    Vector3f & operator = (Vector3f & obj) 
    {
        _item[0] = obj[0];
        _item[1] = obj[1];
        _item[2] = obj[2];

        return *this;
    };

    Vector3f & operator += (Vector3f & obj) 
    {
        _item[0] += obj[0];
        _item[1] += obj[1];
        _item[2] += obj[2];

        return *this;
    };
};

Answer 1

Make sure that your Vector3f class has an accessible equality operator==, and that std::hash<Vector3f> is defined.

For the former, you should probably just go with a member function:

struct Vector3f
{
  bool operator==(Vector3f const & rhs) const { /* ... */ }
  //...
};

Strictly speaking, all you need is that std::equal_to<Vector3f> is defined, but giving your class an equality operator is the most sensible way to achieve this.

Answer 2

unorderd_map declaration is like

template<class Key,
     class T,
     class Hash = hash<Key>,
     class Pred = std::equal_to<Key>,
     class Alloc = std::allocator<std::pair<const Key, T> > >  class unordered_map;

you have to provide hash and predicate for your custom type Vector3f