list von pointern sortieren

mata

hallo zusammen,

ich versuche verzweifelt, eine list<node*> zu sortieren. hab hier im forum rumgeguckt, und eigentlich auch was gefunden, was genau meinen fall trifft:
http://www.c-plusplus.net/forum/viewtopic.php?t=75579&highlight=list+sortieren. Leider klappt das nicht (hab auch MS VC 6). Hab das so quasi abgetippt:

typedef struct node_elem{
	punkt position; 
	int wert;
	..
	struct node_elem * parent;

}node;

struct testsort : public greater<node*> 
{ 
	bool operator()(const node* t1, const node* t2) 
	{
		return t1->wert < t2->wert; 
	}
};

liste.sort(testsort());

wie kann ich das denn hinbiegen, damit das läuft? muss ich das irgendwie in ne klasse basteln und dann den operator< implementieren? oder geht das auch irgendwie geschickter, so wie oben?

EDIT: ähm, was mir grad noch einfällt, das Programm wird ohne murren kompiliert und ausgeführt, nur ist die liste nach dem liste.sort(..) nicht sortiert.

Viele Grüße,

Mata

HumeSikkins

Hallo,
Das:

struct testsort : public greater<node*> 
{ 
    bool operator()(const node* t1, const node* t2) 
    {
        return t1->wert < t2->wert; 
    }
};

ist völliger Käse. Auf Compilern mit Membertemplates ist die Vererbung unnötig (da du hier den konkreten Typ hast) und auf dem VC 6.0 macht sie den Code zwar kompilierbar, selbiger tut aber nicht das was sich der Programmierer scheinbar wünscht, da der operator() von greater<node> nicht virtuell ist.
Sprich: Das Verhalten von STL-Prädikaten kann durch Vererbung nicht beeinflusst werden.
VC 6.0 Lösung: std::greater für den Typ spezialisieren.

namespace std
{
    template <>
    struct greater<node*>
    {
         ...
    };
}

...
l.sort(std::greater<node*>());

prima, vielen dank

MrBigglesworth

Hi,

ich sitze gerade vom selben Problem, allerdings mit VC .NET 2003. Entweder funktioniert die Lösung nicht mit der VC Version, oder ich verstehe nicht, was ich hier eintragen muss:

HumeSikkins schrieb:

VC 6.0 Lösung: std::greater für den Typ spezialisieren.
namespace std
{
    template <>
    struct greater<node*>
    {
         ...
    };
}

Könntest Du das bitte noch einmal erläutern? Mein compiler moniert nach "greater" ein fehlendes ;
So sieht mein Code aus:

struct LINE{
	double xStart,yStart,zStart, xEnd,yEnd,zEnd;
};
namespace std 
{ 
    template <> 
    struct greater<LINE*> 
    { 
        //hier käme dann wohl die Auswertungsfunktion hin
        //es soll die Membervariable xStart verglichen werden
    }; 
}
...
typedef list<LINE*> LINEVECTOR;
LINEVECTOR lineVector;
...
/* sort the vector */
lineVector.sort(std::greater<LINE*>());

mata

lineVector.sort(std::greater<LINE*>());

MrBigglesworth

Oh ja stimmt - danke. (Ich habs jetzt im obigen Code geändert)

Die Compiler Meldung ändert sich aber nicht, er moniert weiterhin "struct greater<LINE*> "

Das hier scheint das Kernproblem zu sein: "error C2913: Explizite Spezialisierung; 'std::greater' ist keine Spezialisierung einer Klassenvorlage"

MrBigglesworth

Mit ein bißchen Basteln habe ich es jetzt so hinbekommen:

struct LINE{
    double xStart,yStart,zStart, xEnd,yEnd,zEnd;
};
template <typename T>  struct pointer_greater{ 
    operator() (const LINE* a,const LINE* b) const {
    return b->xStart < a->xStart ;    
   }
}; 
...
typedef list<LINE*> LINEVECTOR;
LINEVECTOR lineVector;
...
/* sort the vector */
lineVector.sort(std::greater<LINE*>());

Gute/Schlechte Lösung?

otze

typedef list<LINE*> LINEVECTOR;

schlechte lösung, eine liste in keinem fall ein vector

und ganz groß geschriebene typen...ach ich hör besser auf

ansonsten: was istd er return type von operator()?

MrBigglesworth

Ja gut, das ..VECTOR ist ein Überbleibsel, weil ich es erst mit std::vector probiert hatte und dann zu faul war es überall zu ändern

Aber mit dem Rückgabetyp hast Du natürlich recht, danke.

ness

Jetzt hab ich aber mal ne Frage: Warum nicht so:

template<class T>struct pointer_greater
{
    bool operator()(T* t1,T* t2)
    {
        return *t1>*t2;
    };
};

std::list<node*> v;
//...
v.sort(pointer_greater<node>());

/edit: immer davon ausgegangen, das T operator > definiert.

otze

//edit schongut