Why doesn’t std::map provide key_iterator and value_iterator?

There is no need for std::map<K, V> to provide iterators for the keys and/or the values: such an iterator can easily be built based on the existing iterator(s). Well, it isn't as easy as it should/could be but it is certainly doable. I know that Boost has a library of iterator adapters.

The real question could be: why doesn't the standard C++ library provide iterator adapters to project iterators? The short answer is in my opinion: because, in general, you don't want to modify the iterator to choose the property accessed! You rather want to project or, more general, transform the accessed value but still keep the same notion of position. Formulated different, I think it is necessary to separate the notion of positioning (i.e., advancing iterator and testing whether their position is valid) from accessing properties at a given position. The approach I envision is would look like this:

std::for_each(m_map.key_pm(), m_map.begin(), m_map.end(), &func);

or, if you know the underlying structure obtained from the map's iterator is a std::pair<K const, V> (as is the case for std::map<K, V> but not necessarily for other containers similar to associative containers; e.g., a associative container based on a b-tree would benefit from splitting the key and the value into separate entities):

std::for_each(_1st, m_map.begin(), m_map.end(), &func);

My STL 2.0 page is an [incomplete] write-up with a bit more details on how I think the standard C++ library algorithms should be improved, including the above separation of iterators into positioning (cursors) and property access (property maps).

So why isn’t it provided?

I don't know.

And is there a way to adapt the first pattern to the second one?

Alternatively to making a “key iterator” (cf. my comment and other answers), you can write a small wrapper around func, e.g.:

class FuncOnFirst { // (maybe find a better name)
public:
    void operator()(std::map<X,Y>::value_type const& e) const { func(e.first); }
};

then use:

std::for_each( m_map.begin(), m_map.end(), FuncOnFirst() );

Slightly more generic wrapper:

class FuncOnFirst { // (maybe find a better name)
public:
    template<typename T, typename U>
    void operator()(std::pair<T, U> const& p) const { func(p.first); }
};

There is no need for key_iterator or value_iterator as value_type of a std::map is a std::pair<const X, Y>, and this is what function (or functor) called by for_each() will operate on. There is no performance gain to be had from individual iterators as the pair is aggregated in the underlying node in the binary tree used by the map.

Accessing the key and value through a std::pair is hardly strenuous.

#include <iostream>
#include <map>

typedef std::map<unsigned, unsigned> Map;

void F(const Map::value_type &v)
{
    std::cout << "Key: " << v.first << " Value: " << v.second << std::endl;
}

int main(int argc, const char * argv[])
{
    Map map;

    map.insert(std::make_pair(10, 20));
    map.insert(std::make_pair(43, 10));
    map.insert(std::make_pair(5, 55));

    std::for_each(map.begin(), map.end(), F);

    return 0;
}

Which gives the output:

Key: 5 Value: 55
Key: 10 Value: 20
Key: 43 Value: 10
Program ended with exit code: 0