Template typedefs - What's your work around?

What do you like to use as work around ? Container objects or Macros ? Do you feel its worth it ?

The canonical way is to use a metafunction like thus:

template <typename T>
struct my_string_map {
    typedef std::map<std::string, T> type;
};

// Invoke:

my_string_map<int>::type my_str_int_map;

This is also used in the STL (allocator::rebind<U>) and in many libraries including Boost. We use it extensively in a bioinformatical library.

It's bloated, but it's the best alternative 99% of the time. Using macros here is not worth the many downsides.

(EDIT: I've amended the code to reflect Boost/STL conventions as pointed out by Daniel in his comment.)

template <typename T>
struct my_string_map : public std::map<std::string,T> 
{
};

You shouldn't inherit from classes that do not have a virtual destructor. It's related to destructors in derived classes not being called when they should be and you could end up with unallocated memory.

That being said you could *****probably***** get away with it in the instance above because you're not adding any more data to your derived type. Note that this is not an endorsement. I still advice you don't do it. The fact that you can do it doesn't mean you should.

EDIT: Yes, this is a reply to ShaChris23's post. I probably missed something because it showed up above his/her message instead of below.