list<vector<string>> data;

Dieser ist in meiner Klasse cDBSet enthalten.
weiterhin hab ich einen

vector<int> sorted_by;

der mir sagt, in welcher Reihenfolge meine "Datenzeilen" (vector<string>) sortiert werden sollen.
Die Klasse cDBSet beinhaltet folgende Funktionen:

int cDBSet::sortby (vector<int> cols)
{
    sorted_by = cols;
    // subset_left und subset_right sind iteratoren von data
    std::sort (subset_left,subset_right, cDBSet::itr_sort)
}

static int cDBSet::itr_sort(const void *a, const void *b)
{
    vector<string>::iterator  x = reinterpret_cast<vector<string>::iterator>(a),
                              y = reinterpret_cast<vector<string>::iterator>(b);
    vector<int>::iterator item;

    for (item = sorted_by.begin(); item <= sorted_by.end(); item++)
    {
        if (x[*item] < y[*item])         
              return -1;
        if (x[*item] > y[*item])         
              return +1;
    }
    return 0;
}

Mein Problem ist jetzt, daß der Compiler mit den Iteratoren nicht klar kommt. Leider kann ich das Compilelog hier nicht posten, weil ich mit meinem Laptop derzeit nicht ins Netz komme.
Vielleicht findet trotzdem wer meinen Fehler...

wtf? wieso void*?

mach mal

template<class Iterator>
static int cDBSet::itr_sort(const Iterator a, const Iterator b)

nächster punkt: du solltest bool zurückgeben. true wenn das erste objekt kleiner ist, sonst false.

daß die sortierfunktion nur true oder false zurückgeben soll, hab ich nach etlichem Suchen jetzt auch gefunden, aber trotzdem hab ich immernoch nen Problem.
Der Compiler bringt immernoch nen Fehler. angeblich sollen die Iteratoren (parameter 1 und 2) keinen Operator- besitzen..

template<class T>
static int cDBSet::itr_sort(const T& x, const T& y)
{

    for (vector<int>::iterator item = sorted_by.begin(); item != sorted_by.end(); item++)
    {
        if (x[*item] >= y[*item])        
              return 0;
    }
    return 1;
}

die funktion muss folgenden ansprüchen genügen:

http://www.sgi.com/tech/stl/LessThanComparable.html

und hier ein Beispiel:

http://www.sgi.com/tech/stl/less.html

die funktion muss folgenden ansprüchen genügen:

http://www.sgi.com/tech/stl/LessThanComparable.html

Nö. Sondern denen hier:
http://www.sgi.com/tech/stl/StrictWeakOrdering.html

Die Elemente selbst müssen LessThanComparable sein.

Also ich hab einen Datenbereich, der wie folgt aussieht:

list<vector<string>> data;

Hoffentlich sieht das auch so aus :

list< vector<string> > data;

otze schrieb:

die funktion muss folgenden ansprüchen genügen:

http://www.sgi.com/tech/stl/LessThanComparable.html

Nö. Sondern denen hier:
http://www.sgi.com/tech/stl/StrictWeakOrdering.html

Die Elemente selbst müssen LessThanComparable sein.

=>

# The ordering relation on RandomAccessIterator's value type is a strict weak ordering, as defined in the LessThan Comparable requirements.

nachzulesen hier:
http://www.sgi.com/tech/stl/sort.html

... For the algorithms to work correctly, Comp has to induce a strict weak ordering on the values.

Oder hier aus der SGI Doku:
template <class RandomAccessIterator, class StrictWeakOrdering>
void sort(RandomAccessIterator first, RandomAccessIterator last,
StrictWeakOrdering comp);

StrictWeakOrdering kann man anklicken und bringt einen direkt zu den Strict Weak Ordering Requirements.
Die gehen nämlich einen Schritt weiter als die LessThanComparable Requirements und führen "Transitivity of equivalence" ein.