storing handlers (templated classes)

Hello

I'd like to store a templated class (handler) in a container..

The simplified design of handler class:

Code:

class handler_base {
public:
	virtual ~handler_base() { }
	virtual void callback(
		) = 0;
};

template <typename T>
class handler : public handler_base {
public:
	handler(T h) : m_handler(h) {
	  }
	~handler() { }

	void callback() {
		std::cout << "okay\n"; //here I call bind on m_handler
	}
private:
	T m_handler;
};

Now the problem is I dont know what would be proper way to store more objects of handler class in a map container since you have to dynamically allocate memory to be able to store the function in a class.

I've been thinking about having boost::map_ptr container or just ordinary map but with smart (shared_ptr) pointer..

For instance:

Code:

std::map<int, boost::shared_ptr<handler_base> > somemap;
somemap.insert(3, new boost::shared_ptr<handler_object>(arguments));

What do you guys think would be best way? Maybe any other better implementation for that kind of design?

I've been thinking about having boost::map_ptr container or just ordinary map but with smart (shared_ptr) pointer..

Both are possible, but the ptr_map provides the nicer interface and is faster. Assuming you don't actually need shared ownership, it's the better choice.

How should I check with map_ptr if key exists?
Is this the right way to do:

Code:

callback_map::iterator it = m_callbacks.find(key);
if (! boost::is_null(it) ) {
}

or should I do:

Code:

if (it != m_callbacks.end())

Thanks for help!

http://www.boost.org/doc/libs/1_35_0...ics-algorithms

The second one. Just like in a regular map, you need to make sure the key was found by checking the iterator against end().