force key type of a std::map not to be const

C++ refe开发者_运维问答rences tells us for a std::map

typedef pair<const Key, T> value_type;

Is it possible to force the Key Type not to be const ? I need to do this in a template method like

template<class T> // T represent a map in general (std::map, boost::unordered_map or whatever..)
void foo(const T& m)
{
  typename T::value_type::first_type x;
  x=0; // Wrong because x is const ...
}

No, it's not.

This is because map performs its internal ordering based on key. If you could modify the key yourself, willy-nilly, all hell would break loose.

You should use the provided API functions; where the use of one results in changing a Key value (actually I don't think that any do), the appropriate internal re-ordering may take place.

Think of getters and setters, and their use in providing an alternative to messy/dangerous direct member access.

However, you could write this:

template<class T>
void foo(const T& m)
{
   typename T::key_type x;
   x = 0;
}

std::map type aliases

key_type                Key
mapped_type             T
value_type              pair<const Key,T>
key_compare             Compare
value_compare           Nested class to compare elements
allocator_type          Allocator
reference               Allocator::reference
const_reference         Allocator::const_reference
iterator                Bidirectional iterator
const_iterator          Constant bidirectional iterator
size_type               Unsigned integral type (usually same as size_t)
difference_type         Signed integral type (usually same as ptrdiff_t)
pointer                 Allocator::pointer
const_pointer           Allocator::const_pointer
reverse_iterator        reverse_iterator<iterator>
const_reverse_iterator  reverse_iterator<const_iterator>

typename T::key_type will give you the key type without adding a const qualifier.

Previous answers should be sufficient for your simple question. As a more general approach, you may use boost::remove_const (from boost type_traits) to remove const qualifier to a type.

template<class T> // T represent a map in general (std::map, boost::unordered_map or whatever..)
void foo(const T& m)
{
  typedef typename T::value_type::first_type X; //is const
  typedef typename boost::remove_const<X>::type NonConstX;
  NonConstX x;
  x=0; 
}

The key type must be const. If you're certain that you won't change the ordering of the map you can cast away the const-ness of iterators. If you're mistaken this can lead to ugly bugs though.