std::set +find +Eigenes Funktionsobjekt +Speicherzugriffsfehler

drakon

War ja nicht so direkt, als Vorwurf gedacht, sondern nur um zu zeigen, was halt wirklich oft hilft. Oft wissen die Leute gar nicht, was ein Debugger ist.

LordJaxom hat ein Fragezeichen hinten an den Satz gehängt
Ich habe geschrieben , dass ich der Auffassung bin, dass find von
der Ordnung der Elemente abhängt. Er war so freundlich das auf zu nehmen, und sich gedanken darüber zu machen. Er hat mir erklärt, dass
die Elemente nicht verändert werden dürfen, da sonst find aussteigen könnte.
Es wäre ja möglich, dass außer der schleife noch ein weiterer fehler wäre.
So habe ich das zumindest verstanden.
Gruß

@Drakon
Ich benutze meinen debugger zwar, aber so wirklich gut kennen tue ich ihn tatsächlich nicht.
Er zickt öfter.
Darf ich fragen mit was du entwickelst ==
Gruß

drakon

Ich benutze Visual Studio 2008. (die Express Versionen sind auch zu empfehlen).

Nexus

Die Express-Version von MSVC++ kannst du gratis herunterladen. Der Debugger ist wirklich sehr gut, den kann ich ebenfalls empfehlen (sowie die gesamte IDE). Vorausgesetzt, du arbeitest unter Windows.

Plattform Werbung.
Ich glaub ihr bezieht schmiergelder *ggg*
Im Ernst. Habe mit Visual Studio .NET auch schon programmiert,
und finde die Entwicklungsumgebung richtig gut.
Aber ich Entwickle unter Linux. Als IDE habe ich mir CODE::BLOCKS
kompiliert. Der debugger nervt.
Ist hier eher Windows oder linux Fraktion ??

Gruß

drakon

VS ist imo unter Windows das beste, was man machen kann.

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

Seufz..... Alle Macht dem Pinguin *lach*
Na ja bin kein Fanatiker.

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

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;
        }

LordJaxom

@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.

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

Du meinst:

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

LordJaxom schrieb:

@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..

LordJaxom

drakon schrieb:

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.

Man kann aber das ordnungskriterium Während dem ordnen Ändern, in dem man den Functor mit

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ß