как может я получать станд.:: набор ключей к станд.:: карта

То, что Вы в основном хотите, является копией как станд.:: карта не сохраняет ключи в станд.:: набор. станд.:: копия предполагает, что типы значения совместимы, который не имеет место здесь. Станд.:: карта:: value_type является станд.:: пара. Вы хотите скопировать только первую часть пары, что означает, что Вам нужен станд.:: преобразовать. Теперь, так как Вы будете использовать insert_iterator на съемочной площадке, порядок не имеет значения. Станд.:: набор отсортирует на вставке, даже при том, что карта была уже отсортирована.

[редактирование] Код могло бы быть легче. Вершина моей головы, не скомпилированной.

std::transform(MyMap.begin(), MyMap.end(),
    std::inserter(MySet, MySet.end()),
    boost::bind(&std::pair<Key,Value>::first, _1));

Если у Вас есть select1st SGI, Вам не нужно повышение:: связать.

[редактирование], обновленное для C++ 14

std::transform(MyMap.begin(), MyMap.end(),
    std::inserter(MySet, MySet.end()),
    [](auto pair){ return pair.first; });

На практике,

yourmap::const_iterator mi;
set<key_type> k;
for (mi = yourmap.begin(); mi != yourmap.end(); ++mi)
  k.insert(mi->first);
return k; 

Карта действительно гарантирует порядок; вот почему это назвало отсортированный ассоциативный контейнер. Можно использовать set_intersection с пользовательской функцией компаратора, второй вариант, перечисленный здесь.

Так, что-то как

bool your_less(const your_map::value_type &v1, const your_map::value_type &v2)
{ return v1.first < v2.first; }

set_intersection(m1.begin(), m1.end(), m2.begin(), m2.end(), your_output_it, your_less);

должен добиться цели. (Также возможно использовать повышение:: лямбда и связывает, чтобы не писать временную функцию.)

Оператор по умолчанию <по парам сравнивает оба компонента. Так как Вам нужна эквивалентность только по первой части пары (ключ карты), необходимо определить собственный оператор сравнения, который обеспечивает такое отношение (который является тем, что функция выше делает).

Можно просто выполнить итерации через и добавить каждый ключ к набору. Наборы и карты оба заказаны, не заказаны, варианты не.

Я нашел хорошую ссылку для Вашего вопроса здесь

и имейте некоторый код для своей проблемы:

    #include <iostream>
    #include <map>
    #include <set>
    #include <iterator>

    typedef std::map<std::string, int> MyMap;

    // also known as select1st in SGI STL implementation
    template<typename T_PAIR>
    struct GetKey: public std::unary_function<T_PAIR, typename T_PAIR::first_type>
    {
        const typename T_PAIR::first_type& operator()(const T_PAIR& item) const
        {
            return item.first;
        }
    };

    int main(int argc, char** argv)
    {
        MyMap m1,m2;

        m1["a"] = 1;
        m1["b"] = 2;
        m2["c"] = 3;
        m2["b"] = 3;

        std::set<std::string> s;
        std::transform(m1.begin(), m1.end(), std::inserter(s, s.begin()), GetKey<MyMap::value_type>());
        std::transform(m2.begin(), m2.end(), std::inserter(s, s.begin()), GetKey<MyMap::value_type>());
        std::copy(s.begin(), s.end(), std::ostream_iterator<std::string>(std::cout, " "));
        std::cout << std::endl;
        return 0;
    }

Лучшее решение, не связанное с SGI и без ускорения алгоритмов STL, - это расширить map :: iterator следующим образом:

template<typename map_type>
class key_iterator : public map_type::iterator
{
public:
    typedef typename map_type::iterator map_iterator;
    typedef typename map_iterator::value_type::first_type key_type;

    key_iterator(const map_iterator& other) : map_type::iterator(other) {} ;

    key_type& operator *()
    {
        return map_type::iterator::operator*().first;
    }
};

// helpers to create iterators easier:
template<typename map_type>
key_iterator<map_type> key_begin(map_type& m)
{
    return key_iterator<map_type>(m.begin());
}
template<typename map_type>
key_iterator<map_type> key_end(map_type& m)
{
    return key_iterator<map_type>(m.end());
}

, а затем использовать их так:

        map<string,int> test;
        test["one"] = 1;
        test["two"] = 2;

        set<string> keys;

//      // method one
//      key_iterator<map<string,int> > kb(test.begin());
//      key_iterator<map<string,int> > ke(test.end());
//      keys.insert(kb, ke);

//      // method two
//      keys.insert(
//           key_iterator<map<string,int> >(test.begin()),
//           key_iterator<map<string,int> >(test.end()));

        // method three (with helpers)
        keys.insert(key_begin(test), key_end(test));