Comment puis-je trier une std::map d'abord par la valeur, puis par la clé?

std::map permettra de trier les éléments par keys. Il ne se soucie pas de la values lors du tri.

Vous pouvez utiliser std::vector<std::pair<K,V>> puis de les trier à l'aide de std::sort suivie par std::stable_sort:

std::vector<std::pair<K,V>> items;

//fill items

//sort by value using std::sort
std::sort(items.begin(), items.end(), value_comparer);

//sort by key using std::stable_sort
std::stable_sort(items.begin(), items.end(), key_comparer);

Note que bien que std::sort est choisi pour des raisons de performances, std::stable_sort est nécessaire pour le bon de commande, vous souhaitez que la commande soit par valeur, d'être conservé.

@gsf a noté dans le commentaire, vous pouvez utiliser seulement std::sort si vous choisissez un comparateur qui compare values d'abord, et S'ils sont égaux, trier les keys.

auto cmp = [](std::pair<K,V> const & a, std::pair<K,V> const & b) 
{ 
     return a.second != b.second?  a.second < b.second : a.first < b.first;
};
std::sort(items.begin(), items.end(), cmp);

Qui doit être efficace.

Mais attendez, il ya une meilleure approche: magasin std::pair<V,K> au lieu de std::pair<K,V> et puis vous n'avez pas besoin de tout comparer à tous — le standard de comparaison pour std::pair serait suffisant, qu'il compare first (qui est V) d'abord, puis second qui est K:

std::vector<std::pair<V,K>> items;
//...
std::sort(items.begin(), items.end());

Qui devrait fonctionner à merveille.

Comme expliqué dans Nawaz du réponse, vous ne pouvez pas trier votre carte en elle-même que vous en avez besoin, parce que std::map trie les éléments de base sur les touches seulement. Donc, vous avez besoin d'un autre conteneur, mais si vous devez vous en tenir à votre carte, alors vous pouvez toujours copier son contenu (temporairement) dans une autre structure de données.

Je pense, la meilleure solution est d'utiliser un std::set stockage retourné paires clé-valeur, comme présenté dans la ks1322 de réponse.
Le std::set est triée par défaut et la ordre des paires est exactement comme vous le souhaitez:

3) Si lhs.first<rhs.first, renvoie true. Sinon, si rhs.first<lhs.first, renvoie false. Sinon, si lhs.second<rhs.second, renvoie true. Sinon, retourne false.

De cette façon, vous n'avez pas besoin d'un supplément de tri étape et le code résultant est très courte:

std::map<std::string, int> m;  //Your original map.
m["realistically"] = 1;
m["really"]        = 8;
m["reason"]        = 4;
m["reasonable"]    = 3;
m["reasonably"]    = 1;
m["reassemble"]    = 1;
m["reassembled"]   = 1;
m["recognize"]     = 2;
m["record"]        = 92;
m["records"]       = 48;
m["recs"]          = 7;

std::set<std::pair<int, std::string>> s;  //The new (temporary) container.

for (auto const &kv : m)
    s.emplace(kv.second, kv.first);  //Flip the pairs.

for (auto const &vk : s)
    std::cout << std::setw(3) << vk.first << std::setw(15) << vk.second << std::endl;

De sortie:

  1  realistically
  1     reasonably
  1     reassemble
  1    reassembled
  2      recognize
  3     reasonable
  4         reason
  7           recs
  8         really
 48        records
 92         record

Code sur Ideone

Remarque: Depuis C++17 vous pouvez utiliser gamme pour les boucles avec structuré liaisons pour itérer sur une carte.
En conséquence, le code de la copie de votre carte devient encore plus court et plus lisible:

for (auto const &[k, v] : m)
    s.emplace(v, k);  //Flip the pairs.

EDIT: Les deux autres réponses faire un bon point. Je suis en supposant que vous souhaitez commander dans une autre structure, ou dans le but de les imprimer.

"Meilleur" peut signifier un certain nombre de choses différentes. Voulez-vous dire par "plus facile," "le plus rapide", "la plupart efficace", "moins de code" "plus lisible?"

Le plus évident de l'approche est de faire une boucle par deux fois. Sur la première passe, l'ordre des valeurs:

if(current_value > examined_value)
{
    current_value = examined_value
    (and then swap them, however you like)
}

Puis sur la deuxième passe, classer par ordre alphabétique les mots, mais seulement si leurs valeurs correspondent.

if(current_value == examined_value)
{
    (alphabetize the two)
}

À proprement parler, c'est un "tri à bulles" qui est lent, car à chaque fois que vous faire un échange, vous devrez recommencer. Un "pass" est terminé une fois que vous obtenez par le biais de l'ensemble de la liste sans faire de swaps.

Il existe d'autres algorithmes de tri, mais le principe est le même: à l'ordre par la valeur, puis les classer par ordre alphabétique.