Ich habe folgendes Problem:
In einer map<string,int> wird einer bestimmten Eigenschaft ihre Anzahl (wie oft sie vorkommt) zugeordnet. Anschließend möchte ich diese Map gerne mit einer Schleife durchlaufen, und zwar bei der Eigenschaft beginned wo die Anzahl (int) am höchsten ist. Das Problem ist nun, dass sich Maps (meines Wissens) nicht sortieren lassen bzw. automatisch sortiert werden - nur falsch herum. Vektoren zum Speichern der Anzahlen kommen auch nicht in Frage, da dann der Bezug zu den Eigenschaften fehlt.
Was kann man da machen?

#include <map>
#include <string>
#include <algorithm>
using namespace std;

class Sorter
{
public:
    bool operator ()(map<string, int>::iterator &lhs, map<string, int>::iterator &rhs)
    {
        return lhs->second <= rhs->second;
    }
};

int main()
{
    map<string, int> foo;

    // fülle foo irgendwie

    sort(foo.begin(), foo.end(), Sorter());
}

sort(property_map_count.begin(), property_map_count.end(), Sorter());

bekomme ich folgenden Fehler den ich mir nicht erklären kann:

(...)\stl_algo.h In function `void std::sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = std::_Rb_tree_iterator<std::pair<const std::string, int> >, _Compare = Sorter]': 
 2591 (...)\stl_algo.h no match for 'operator-' in '__last - __first' 
  note (...)\stl_bvector.h:180 candidates are: ptrdiff_t std::operator-(const std::_Bit_iterator_base&, const std::_Bit_iterator_base&)

std::__inplace_stable_sort(__first, __last, __comp);

in stl_algo.h angemeckert. Der gesamte Fehler unterscheidet sich nicht viel von dem vorherigen.

class Sorter
{
public:
    bool operator ()(const map<const string, int>::const_iterator &lhs, const map<const string, int>::const_iterator &rhs)    // direkt noch die Parameter const gemacht
    {
        return lhs->second <= rhs->second;
    }
};

Du musst beim Erzeugen der Map einen Comparator übergeben, der dein Vergleichskriterium enthält:

class Comp {
  public:
    bool operator( const string& s1, const std::string s2) const 
    {
       return s1 > s2; // oder was immer Du willst  
    }
};

void x()
{
   map<string, int, Comp> myMap;
  //   myMap.insert <- fügt es an der Stelle gemäß obigen Kriterium ein
}

}

Das Problem ist nun, dass sich Maps (meines Wissens) nicht sortieren lassen bzw. automatisch sortiert werden - nur falsch herum.

Das kommt ganz darauf an - du kannst der Map als Template-parameter eine Comparator-Klasse mitgeben. Die ist per default std::less<Key>. Wenn du stattdessen std::greater<Key> (in deinem Fall also std::greaterstd::string) einsetzt, wird sie genau andersrum sortiert. Da man den Comparator allerdings nur einmal angeben kann, lohnt sich das nur, wenn es okay ist, dass die Map IMMER so sortiert ist. (evtl. könnte man sonst per std::copy() die Elemente einer mit less<> sortierten map in eine mit greter<> sortierten map kopieren...)

63 (...) expected identifier before '(' token

in dieser Zeile:

bool operator( const string& s1, const std::string s2) const

Habe bisher mit Operatorüberladungen (oder was immer das ist) nicht gearbeitet, also wäre es schon schön wenn du mir einen Code geben könntest der fehlerfrei kompliert. Bis ich in C++ soweit bin wird es noch ein bisschen dauern.

So ist es im Moment perfekt, also vielen Dank

#include <iostream>
#include <map>
#include <string>

using namespace std;

class Comp
{
public:
   bool operator()( const int i1, const int i2) const
   {
      return i1 > i2;
   }
};

int main()
{
   map<int, string, Comp> x;
   x.insert( make_pair( 2, string( "Hallo")));
   x.insert( make_pair( 5, string( "Test")));
   x.insert( make_pair( 1, string( "Welt")));
   x.insert( make_pair( 3, string( "C++")));

   map<int, string, Comp>::const_iterator it = x.begin();
   map<int, string, Comp>::const_iterator const end = x.end();
   for( ; it != end; ++it) {
      cout << it->first << " " << it->second << endl;
   }

}

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

typedef std::pair<std::string, int> string_int_pair;

class Sorter
{
public:
    bool operator ()(const string_int_pair &lhs, const string_int_pair &rhs) const {
        return lhs.second < rhs.second;
    }
};

int main() {

   std::map<std::string, int> m;
   std::vector<string_int_pair> v;
   m.insert(std::make_pair("a",1 ));
   m.insert(std::make_pair("b",8 ));
   m.insert(std::make_pair("v",5 ));

   for(std::map<std::string, int>::iterator i = m.begin(); i != m.end(); ++i ) {
     v.push_back(*i);
   }

   std::cout << "unsorted\n";
   for(std::vector<string_int_pair>::iterator i = v.begin(); i != v.end(); ++i ) {
      std::cout << (*i).first << " " << (*i).second << std::endl;
   }

   std::sort(v.begin(), v.end(), Sorter()); 

   std::cout << "sorted\n";
   for(std::vector<string_int_pair>::iterator i = v.begin(); i != v.end(); ++i ) {
      std::cout << (*i).first << " " << (*i).second << std::endl;
   }
}

output

unsorted
a 1
b 8
v 5
sorted
a 1
v 5
b 8

Kurt

Also so geht es auch nicht. Ich muss nämlich auch die Anzahl der Eigenschaften hin und wieder erhöhen. Deswegen hatte ich am Anfang map<string,int>, weil ich dann einfach map["Eigenschaft"] += 1 machen konnte. Wie das bei dir funktionieren soll ist mir nicht ganz klar. Irgendwie müsste der Vektor dann ja auch aktualisert werden.

Sieht so aus als wenn es funktioniert. Ich werde es morgen mal in mein Programm einbauen und gucken wie es läuft, denke aber dass es jetzt stimmt. Ich melde mich dann nochmal.

Auf jeden Fall schonmal danke für das Interesse bzw. die zahlreichen Antworten

Das ist klar. Du musst den vektor jedesmal neu erzeugen und sortieren wenn du die map nach value sortiert ausgeben möchtest. Eine bessere lösung fällt mir nicht ein.
Kurt

Das ist schon OK so denke ich, weil die Map erst erzeugt wird und anschließend ausgegeben wird.