ansaurus

Question

Answer 1

A:

From the code above what is the compiler error?

Have you tried forward declaring the class Neuron?

class Neuron; // class Neuron must be forward declared to be used

typedef double WEIGHT;
typedef stdext::hash_map<boost::shared_ptr<Neuron>,WEIGHT> NeuronWeightMap;


class Neuron
{
private:
    NeuronWeightMap m_outputs;
    //...
public:

    Neuron();
    ~Neuron();
    //...
};

a standard map should also be fine in this case, what is your specific reason to use hash_map?

AppDeveloper 2009-05-22 23:22:37

Hi Baumes, I've separated the forward declaration from his code and added comments is that what you wanted?

AppDeveloper 2009-05-22 23:33:28

Answer 2

+6 A:

You probably have Neuron declared in your .h file.

So the below could work:

struct hasher {
    size_t operator()(const boost::shared_ptr<Neuron>& n) { return ...; }
};

typedef stdext::hash_map<boost::shared_ptr<Neuron>,WEIGHT,hasher> NeuronWeightMap;

The problem probably is that boost:shared_ptr has no default hashing function (what one would look like?), so you just need to provide one.

Piotr Findeisen 2009-05-22 23:33:01

Answer 3

+2 A:

A "normal" Neuron* should work as key for the hash_map:

typedef stdext::hash_map<Neuron*, WEIGHT> NeuronWeightMap;

If you want to lookup shared_ptr-Neurons you can use shared_ptrs get() method to access the raw pointer:

NeuronWeightMap weights;
boost::shared_ptr<Neuron> n;

weights.find(n.get());

sth 2009-05-22 23:37:42

Answer 4

A:

Since you already use Boost, why not use boost::unordered_map for the hash table? It compiles out of the box with shared_ptr for the key, though you better check how to do it properly (Boost.Unordered)

Nikolai N Fetissov 2009-05-23 00:01:23

Answer 5

A:

I find by adding a hash_value() function I can use a shared_ptr as a key in a stdext::hash_map. Below I compare using boost::unordered_map with std::hash_map

#include <boost/smart_ptr.hpp>
#include <boost/unordered_map.hpp>
#include <hash_map>
#include <assert.h>

struct MyItem
{
    int i;
};
typedef boost::shared_ptr<const MyItem> MyItem_csptr;

struct MyExtra
{
    double d;
};

//Boost's unordered_map already knows how to hash shared_ptr
typedef boost::unordered_map<MyItem_csptr,MyExtra> MapMyItemToExtra;


//But for stdext::hash_map, we need to write this:
template<class T>
size_t hash_value(const boost::shared_ptr<T>& aSptr)
{
    return reinterpret_cast<size_t>( aSptr.get() );
};
typedef stdext::hash_map<MyItem_csptr,MyExtra> MapMyItemToExtra2;


template<class MAP>
void TryMapMyItemToExtra_T()
{
    MAP tMap;

    MyItem_csptr tItem1(new MyItem);
    MyItem_csptr tItem2(new MyItem);
    tMap[tItem1].d=1.0;
    tMap[tItem1].d=1.1;
    tMap[tItem2].d=2.0;

    assert( tMap[tItem1].d == 1.1 );
    assert( tMap[tItem2].d == 2.0 );
}

void TryMapMyItemToExtra()
{
    TryMapMyItemToExtra_T<MapMyItemToExtra>();
    TryMapMyItemToExtra_T<MapMyItemToExtra2>();
}

MartinP 2010-01-05 13:01:54

Answer 6

A:

You could also provide a template specialization for the hash:

#include <functional>
#include <boost/shared_ptr.hpp>

template<class T>
class std::tr1::hash<boost::shared_ptr<T>> {
public:
    size_t operator()(const boost::shared_ptr<T>& key) const {
        return (size_t)key.get();
    }
};

Works perfectly with unordered_set:

class Foo;
typedef boost::shared_ptr<Foo> FooPtr;
typedef std::tr1::unordered_set<FooPtr> FooSet;

Jeremie Pelletier 2010-01-18 16:16:40

ansaurus

tags:

views:

answers:

C++ boost shared_ptr as a hash_map key

related questions