Gruß

template <typename T>
class WE_Algo : public WingedEdge<T>
{.
.
.
.
.
//Nicht wundern dass cih nicht einen queue voon std nehme, der geht hier nicht
std::set< VList<T> *,EventLineOrder<VList<T> * > >    event_queue;
.
.
//wird hier in eine rfunktion aufgerufen, ist aber member dieser klasse.
//Deswegen stehts hier
event_queue.find(item);
.};

//das Funktionsobjekt zum ordnen

template <typename T>
class EventLineOrder : private std::binary_function<T,T,bool>
{
.
.
inline bool operator () (const T &LeftValue, const T &RightValue)
        {
            for(unsigned int x=Dimension-1;x>=0;x--)
                if(LeftValue->V[x] < RightValue->V[x])
                    return false^!(x%2);
                else if(LeftValue->V[x] > RightValue->V[x])
                    return true^!(x%2);

            //If the Points are the same,
            return true;
        }
.
}

int main(void)
{
.
.
WE_Algo<long double> a;

Also aus main raus wird eine funktion von WE_Algo aufgerufen, welche wiederum find aufruft.
Mit dem Funktionsobjekt, werden die Daten richtig geordnet, find steigt aber aus,
Ohne sind die daten falsch, find funktioniert aber.
Gruß

kann nicht aufgrund der Schleifenbedingung terminieren, und sobald der Überlauf da ist (das passiert genau dann, wenn zwei Elemente äquivalent sind...), dürfte ein Zugriffsfehler folgen. Eine so dekrementierende Schleife muss das Dekrementieren an den Anfang stellen:

for(unsigned int x=Dimension;x-- >0;)

1. Du hättest den Debugger benutzen können, dann hättest du gemerkt, dass du einfach nicht aus der Schleife kommst.

2. Du hättest wirklich mal ein Minimalbeispiel von deiner Situation machen können, welches natürlich (aufgrund der vereinfachten Vergleichsfunktion) geklappt hätte. Somit hättest du dann schon gewusst, dass es prinzipiell funktioniert. Und dann wäre es nicht mehr lange genangen, dass du bei der Implementierung der Vergleichsfunktion misstrauisch geworden wärst und da nochmal nachgehackt hättest, weil sonst ja nichts grossartig anderst ist..

@LordJaxom:
Ehrlich gesagt verstehe ich deinen Gedankengang nicht ganz.

Ein Punkt ist, dass ein unsigned int per Definition >= 0 ist. Dann, ändert sich die Reihenfolge der Elemente zur Laufzeit? Objekte eines Set müssen konstant sein, zumindest die Teile, die als Schlüssel verwendet werden.

Was hat hier unsigned int mit der Reihenfolge zu tun? Und geändert wird die Reihenfolge ja "ständig", respektive wenn es nötig ist wenn ein neuer Eintrag gemacht wird. Und in wie fern muss ein set konstant sein? - Und speziell, wie kann lediglich ein Teil davon konstant sein? Und als Schlüssel und gleichzeitig Value werden ja alle Einträge behandelt..

Verstehe ich dich einfach falsch, oder hast du da eine andere Datenstruktur im Kopf?

Gruß

Ich kenne jetzt keine genauen Zahlen, aber ich denke, dass hier eher VS vorherrscht..

//---------------------------------------------------------------------

Was ich noch zum Thema schreiben wollte ist, dass Find nur funktioniert, wenn
die Ordnungsfunktion bei Gleichheit False zurück gibt.
Ansonsten findet finde nie ein Objekt.
Also das letzte false ist noch ausschlaggebend.
(Nicht dass ein anonymer Leser das verfolgt, und dann entteuscht ist dass es nicht funktioniert wie behauptet).

inline bool operator () (const T &LeftValue, const T &RightValue)
        {
            for(unsigned int x=Dimension;x-- >0;)
            {
                if(LeftValue->V[x] < RightValue->V[x])
                    return false^!(x%2);
                else if(LeftValue->V[x] > RightValue->V[x])
                    return true^!(x%2);
            }
            //If the Points are the same,
            return false;
        }

Das weisst Du sicher, aber ich scheine mich gestern etwas undeutlich ausgedrückt zu haben

inline bool operator () (const T &LeftValue, const T &RightValue) const 
        {
            for(unsigned int x=Dimension;x-- >0;)
            {
                if(LeftValue->V[x] < RightValue->V[x])
                    return !(x%2);
                else if(LeftValue->V[x] > RightValue->V[x])
                    return (x%2);
            }
            //If the Points are the same,
            return false;
        }

???

Gruß

@drakon:
"Ein Punkt" und "Dann" sollten andeuten, dass die Anmerkung zu unsigned und die zur Reihenfolge zwei unabhängige Punkte darstellen. Weiterhin (besser als "dann"? :p) müssen die Schlüssel von Maps und Sets konstant sein, sprich die relative Reihenfolge der Elemente darf sich nicht ändern. Beim Set ist das Element selbst der Schlüssel.

OK. Das mit dem unsigned weiss ich jetzt, was du gemeint hast. Allerdings weiss ich immer noch nicht, was du meinst mit dem, dass die Keys konstant sein müssen.. Man kann da einfügen/löschen, wie man lustig ist. Von Konstanz imo keine Spur..

OK. Das mit dem unsigned weiss ich jetzt, was du gemeint hast. Allerdings weiss ich immer noch nicht, was du meinst mit dem, dass die Keys konstant sein müssen.. Man kann da einfügen/löschen, wie man lustig ist. Von Konstanz imo keine Spur..

*seufz*

Kannst Du den Key eines Elements in der Map ändern? Nein, Du musst es, wie Du sagst, löschen und neu einfügen. Ergo sind die Keys konstant. Da in einem Set das Element der Key ist, ist das Element konstant.

Das wollte ich an dieser Stelle erwähnt haben, da in einem Set von Zeigern ja de Zeiger konstant ist, nicht aber das Bezeigte. Wenn man aber das Bezeigte als Sortierkriterium nutzt, kommt man schnell in Teufels Küche, weil der Compiler nicht warnt, wenn man das Bezeigte ändert.

typename std::multiset< EList<T> *,StatusOrder<EList<T> *,T > >::key_compare        Compare_Functor;
Compare_Functor=status_tree.key_comp();
Compare_Functor.setOrder(false);

sofern man im Functor die Funktion setOrder definiert hat:

template <typename T,typename T2>
class StatusOrder : private std::binary_function<T,T,bool>
{
    private:
        bool OrderUp;
    public:
        explicit StatusOrder(bool OrderUpper=true){OrderUp=OrderUpper;};
        void setOrder(bool OrderUpper=true){OrderUp=OrderUpper;};

Das kann die Laufzeit beim suchen verbessern.
Gruß