schönes c++?

volkard

µngbd schrieb:

b, a = a, b
Wer braucht dann noch eine swap-Funktion?

es muß keine FUNKTION sein. aber irgend eine praktische art swap braucht man eher schon. ein makro in c, ein idiom in python, eine funktion in c++, in java fehlt's.

schreibt man in python gerne

v[i],v[i+1]=v[i+1],v[i]

?

Nexus

avrül schrieb:

Die haben sich da mit dem Copy-and-swap schon was kompliziert schönes ausgedacht, damit es keine Exception geben kann, auch wenn es Nexus schlecht erklärt. Beruht übrigens auf C++ Innereien.

1. Wie würdest du es besser erklären? Ich habe versucht, mich einigermassen kurz zu halten.
2. Wenigstens hat man sich etwas ausgedacht. Exceptionsicherheit in anderen Sprachen einfach wegzudiskutieren löst keine Probleme. Das ist wie mit Destruktoren/Aufräumsemantik: Nur weil man Speicher nicht selbst freigeben muss, trifft das nicht auf alle Ressourcen zu. Ein GC ist eben auch kein Allheilmittel.

Aber ich wiederhole eh nur, was schon gesagt wurde. Also: Was ist an der C++-Exceptionsicherheit so schlimm? Dass man auch Speicher freizugeben hat (meistens nicht einmal manuell) oder dass man sich mit Idiomen wie Copy&Swap auseinandersetzen muss?

avrül schrieb:

Und zu swap in Java. Wozu auch? In Java kann man keine operatoren überladen, was swap zu einer unwichtigen Funktion macht und nicht wie in C++ zur fast wichtigsten.

Was hat bitte swap() mit Operatorüberladung zu tun? Ein Tausch kann auch in Java nützlich sein.

volkard schrieb:

schreibt man in python gerne
v[i],v[i+1]=v[i+1],v[i]
?

Good point. Weiss ich leider nicht. Mir fällt zumindest gerade nichts besseres ein.

volkard schrieb:

µngbd schrieb:
b, a = a, b
Wer braucht dann noch eine swap-Funktion?
es muß keine FUNKTION sein. aber irgend eine praktische art swap braucht man eher schon. ein makro in c, ein idiom in python, eine funktion in c++, in java fehlt's.

fricky hat schon erklärt, dass man in C auch eine Funktion swap() bauen kann, wenn man als drittes Argument die Größe übergibt. Soviel zur C-Verteidigung.

Wenn ich im Python-Modus bin, steck ich da irgendwie schon so fest drinnen, dass ich gar nicht mehr an swap() denke, sondern in einzelnen Zuweisungen (oder in Idiomen, wenn sie gerade passen). Dabei ist swap() an sich sicherlich eine sinnvolle Abstraktion. Da sieht man, wie sehr die Sprache das Denken bestimmt. Ich bin aber ehrlicherweise kein echter Python-Guru, vielleicht kann das Ding noch was feineres.

volkard

µngbd schrieb:

fricky hat schon erklärt, dass man in C auch eine Funktion swap() bauen kann, wenn man als drittes Argument die Größe übergibt. Soviel zur C-Verteidigung.

Ja, aber nur die swap-funktion wäre kurzsichtig. natürlich muß man immer nachdenken, ob die objekte byteweise vertauschbar sind.
darüberhinaus wäre ein makro drum schon ok.

define SWAP(a,b) {STATIC_ASSERT(sizeof(a)==sizeof(b));STATIC_ASSERT(__alignof(a)==__alignof(b));swap(&(a),&(b),sizeof(a));}

dürfte viele schusseligkeitsfehler abfangen.

DEvent

Zeus schrieb:

Zeus schrieb:

Swap ist einer der wichtigen elementare Operationen in Algorithmen.

Wie etwa

Sortieralgorithmen

Graphenalgorithmen

...

In Java ist es ein wenig kompliziert, dass stimmt schon, aber möglich:

public class Int {

    private int i;

    public Int(int i) {
        this.i = i;
    }

    public void setInt(int i) {
        this.i = i;
    }

    public int getInt() {
        return i;
    }
}

// ...
public void swap(Int a, Int b) {
    int old = b.getInt();
    b.setInt(a.getInt());
    a.setInt(old);
}

// ...
public main() {
    Int a = new Int(5);
    Int b = new Int(8);
    swap(a, b);

    sysout(a.getInt()); // 8
    sysout(b.getInt()); // 5
}

Ansonsten, in Java braucht man sowas wirklich nicht. Man sortiert doch eher Arrays und keine rohe PODs. Fuer Graphen nimmt man auch Objekte, die mehr Information enthalten als nur eine Ziffer, usw.

Wenn man wirklich etwas mit Bytes und Ints macht (wie z.B. Bilderbearbeitung), dann sollte man zu einer anderen Sprache greifen, wie C.

Das Makro gefällt mir. Und wieder was gelernt: es gibt __alignof().

Dürfte wirklich einer der Fälle sein, wo ein Makro eine gute Idee ist. Normalerweise hab ich grosse Angst vor Mehrfachbewertungen der Makro-Parameter, aber in dem Fall würde das ohnehin keinen Sinn ergeben (oder?).

volkard

DEvent schrieb:

In Java ist es ein wenig kompliziert, dass stimmt schon, aber möglich:
public class Int {

    private int i;

    public Int(int i) {
        this.i = i;
    }

    public void setInt(int i) {
        this.i = i;
    }

    public int getInt() {
        return i;
    }
}

// ...
public void swap(Int a, Int b) {
    int old = b.getInt();
    b.setInt(a.getInt());
    a.setInt(old);
}

// ...
public main() {
    Int a = new Int(5);
    Int b = new Int(8);
    swap(a, b);

    sysout(a.getInt()); // 8
    sysout(b.getInt()); // 5
}
Ansonsten, in Java braucht man sowas wirklich nicht. Man sortiert doch eher Arrays und keine rohe PODs. Fuer Graphen nimmt man auch Objekte, die mehr Information enthalten als nur eine Ziffer, usw.

Ok.

Wie sieht das swap aus, das das kann?

Ding a=new Node(4,6,3.14,"Baum");
Ding b=new Node(6,8,2.71,"Haus");
swap(a,b);

//oder für baumknoten
swap(parent.left,parent.right.left);

volkard

µngbd schrieb:

Das Makro gefällt mir. Und wieder was gelernt: es gibt __alignof().

Nicht wirklich und Sprachpuristen werden mich in Kürze dafür ausschimpfen. Aber da es die großen Compiler anbieten, nehme ich es einfach.

Zeus

Jetzt sind wir aber beim Frickeln angekommen - ich meine wir basteln uns Modelle, die wir mit Hilfe von Java nicht ausdrücken können.

volkard

Zeus schrieb:

Jetzt sind wir aber beim Frickeln angekommen - ich meine wir basteln uns Modelle, die wir mit Hilfe von Java nicht ausdrücken können.

keiner verlangt das makro in java.

oder meintest du meine frage nach

//oder für baumknoten
swap(parent.left,parent.right.left);

?

DEvent

volkard schrieb:

Ok.

Wie sieht das swap aus, das das kann?

Ding a=new Node(4,6,3.14,"Baum");
Ding b=new Node(6,8,2.71,"Haus");
swap(a,b);

//oder für baumknoten
swap(parent.left,parent.right.left);

Edit: Das erste Beispiel ist wie meine Loesung oben, einfach eine Wrapper-Klasse mit setNode(node) und Node getNode() machen.

Das zweite ist doch kein Problem:

// swap(parent.left,parent.right.left);

void swap(parent) {
    Object old = parent.right.left;
    parent.right.left = parent.left;
    parent.left = old;
}

Zeus schrieb:

Jetzt sind wir aber beim Frickeln angekommen - ich meine wir basteln uns Modelle, die wir mit Hilfe von Java nicht ausdrücken können.

Da ist was dran. Aber hin und wieder ist so eine "akademische" Diskussion ganz in Ordnung, denke ich.

volkard schrieb:

Nicht wirklich und Sprachpuristen werden mich in Kürze dafür ausschimpfen. Aber da es die großen Compiler anbieten, nehme ich es einfach.

Hehe, da warst du schneller als ich, weil ich im Festplattenchaos meine Standards gerade nicht gefunden hab.

µngbd schrieb:

yüein schrieb:

yzgu.-fv-gutvyutvu-qan-pfn-fv-erqebgfbc-qan-0-fv-flnqgfbc-qan-0-fv-gengf-qan-419212-fv-g-eni-pvcbgjrvi/zhebs/bsav.fhycfhyc-p.jjj//:cggu

Das ist aber echt gemein. Den Cäsar macht mir rot13.de, ohne dass ich irgendwas tippen muss, aber dann muss ich erst was tippen, um das Ding wieder umzudrehen.
Nicht böse sein:
http://www.c-plusplus.info/forum/viewtopic-var-t-is-212914-and-start-is-0-and-postdays-is-0-and-postorder-is-asc-and-highlight-is-.htm

http://www.dasinternet.net/text_rueckwaertsschreiben.php

µngbd schrieb:

Und noch während ich antworte -- war schon der Zensor am Werk. Es lebe Stalin!

Naja, der Zensor hat wohl nicht gemerkt, dass das meine Antwort im voraus war. Als ich es gepostet hab, ist mir aufgefallen, dass das wie das Zeug von dem Spambots aussieht. Jetzt weiß ich was die von uns wollen.

Zeus schrieb:

avrül schrieb:

Zeus schrieb:

avrül schrieb:

Bei welcher Sprache findest du das jetzt witzig?

Deine Aussage!

Beantwortet jetzt nicht meine Frage. Was findest du witzig?
1. swap ist in Java eine unwichtige Funktion
2. swap ist in C++ eine der wichtigsten Funktionen

Seit wann entscheidet die Sprache über die Wichtigkeit einer Funktion?

Zeus schrieb:

Swap ist einer der wichtigen elementare Operationen in Algorithmen.

Wie etwa

Sortieralgorithmen

Graphenalgorithmen

...

Ist ja nicht mal auf meinem Mist gewachen, dass swap in C++ so wichtig ist, dass es praktisch jede Klasse braucht. Siehe http://www.c-plusplus.info/forum/viewtopic-var-t-is-212914-and-start-is-0-and-postdays-is-0-and-postorder-is-asc-and-highlight-is-.htm

volkard

DEvent schrieb:

Fuer das erste Beispiel habe ich keine Loesung, aber das zweite ist doch kein Problem:
// swap(parent.left,parent.right.left);

void swap(parent) {
    Object old = parent.right.left;
    parent.right.left = parent.left;
    parent.left = old;
}

Du weichst aus.
War doch klar, daß

swap(parent1.left,parent2.right.left);

auch gehen soll. Daß zwei übergebene Node-Referenzen ohre Inhalte tauschen sollen.

DEvent

volkard schrieb:

DEvent schrieb:
Fuer das erste Beispiel habe ich keine Loesung, aber das zweite ist doch kein Problem:
// swap(parent.left,parent.right.left);

void swap(parent) {
    Object old = parent.right.left;
    parent.right.left = parent.left;
    parent.left = old;
}
Du weichst aus.
War doch klar, daß
swap(parent1.left,parent2.right.left);
auch gehen soll. Daß zwei übergebene Node-Referenzen ohre Inhalte tauschen sollen.

Die Semantik ist die selbe. Aber ansonsten siehe mein Edit. Einfach eine Wrap-Klasse drumherum und mein Beispiel von oben anwenden.

Edit: Wenn jemand nach der Performanz fragt: Der GC von Java kann sehr gut mit kurzlebigen Objekten umgehen oder vllt. kann der Jit'er es auch Kompelieren. Somit dürfte die Lösung mit der Wrapper Klasse auf die Performanz keinen Ausschlag geben.

Zeus

Also meinst du:

public class Ref<T> {
    private T object;

    public Ref(T object) {
        this.object = object;
    }

    public T getObject() {
        return object;
    }

    public void setObject(T object) {
        this.object = object;
    }
}

public class Swap<T> implements Runnable {
    private Ref<T> ref1;
    private Ref<T> ref2;

    public Swap(Ref<T> ref1, Ref<T> ref2) {
        this.ref1 = ref1;
        this.ref2 = ref2;
    }    

    public void run() {
        T tmp = ref1.getObject();
        ref1.setObject(ref2.getObject());
        ref2.setObject(tmp);
    }
}

public class Main {
    public static void main(String[] args) {
        Ref<Integer> rvalue1 = new Ref<Integer>(1);
        Ref<Integer> rvalue2 = new Ref<Integer>(2);

        Swap<Integer> swap = new Swap<Integer>(rvalue1, rvalue2);
        swap.run();

        System.out.println(rvalue1.getObject());
        System.out.println(rvalue2.getObject());
    }
}

Damit kann mal alle Objekte swappen. Vorausgesetzt man verwendet die Klasse Ref für den eigentlichen Baum.

Ist schon komplexer als in C++ mit eine einfache template Funktion.

volkard

DEvent schrieb:

Die Semantik ist die selbe. Aber ansonsten siehe mein Edit. Einfach eine Wrap-Klasse drumherum und mein Beispiel von oben anwenden.

Also das hier?

//swap(parent1.left,parent2.right.left);
    NodeWrapper a = new NodeWrapper(parent1.left); 
    NodeWrapper b = new NodeWrapper(parent2.right.left); 
    swap(a, b);

Nee, das glaube ich nicht. Also wie soll swap ganz einfach aussehen?

DEvent schrieb:

Edit: Wenn jemand nach der Performanz fragt: Der GC von Java kann sehr gut mit kurzlebigen Objekten umgehen oder vllt. kann der Jit'er es auch Kompelieren. Somit dürfte die Lösung mit der Wrapper Klasse auf die Performanz keinen Ausschlag geben.

Nach der Performance von Java fragt schon lange keiner mehr.

Es macht doch nichts, daß Java kein swap kann und ein wenig langsamer ist. Dafür hat es doch andere Vorzüge.

DEvent

Zeus schrieb:

Also meinst du:
...
Damit kann mal alle Objekte Swappen. Vorausgesetzt man verwendet NodeRef, das von Ref<T> erbt und in der Baumstruktur verwendet wird.

Ist schon komplexer als in C++ eine einfache template Funktion.

Wieso muss NodeRef von Ref erben? Integer erbt doch auch nichts.

Ist komplexer, ja, aber man schreibt es nur einmal und kann es wiederverwenden. Dafuer kann ich in Java dann einfach schreiben:

Thread thread = new Thread(new Swap<Integer>(rvalue1, rvalue2));
thread.start();

// oder mit Executor:

public class Swap<T> implements Runnable {
    private Ref<T> ref1;
    private Ref<T> ref2;

    public Swap(Ref<T> ref1, Ref<T> ref2) {
        this.ref1 = ref1;
        this.ref2 = ref2;
    }

    public void run() {
        T tmp = ref1.getObject();
        ref1.setObject(ref2.getObject());
        ref2.setObject(tmp);
    }

    public T getRef1() {
        return ref1;
    }

    public T getRef2() {
        return ref2;
    }
}

ExecutorService service = //...

Ref<Integer> rvalue1 = new Ref<Integer>(1);
Ref<Integer> rvalue2 = new Ref<Integer>(2);
final Swap<Integer> swap = new Swap<Integer>(rvalue1, rvalue2);

Future<Swap<Integer>> future = executor.submit(swap);

displayOtherThings(); // do other things while swapping

sysout(future.get().getRef1());
sysout(future.get().getRef2());

Aber egal. Java ist halt für andere Aufgaben und ist, im Gegensatz zu C++, Highlevel Sprache.

Edit: Wenn jemand nach der Performanz fragt: Der GC von Java kann sehr gut mit kurzlebigen Objekten umgehen oder vllt. kann der Jit'er es auch Kompelieren. Somit dürfte die Lösung mit der Wrapper Klasse auf die Performanz keinen Ausschlag geben.

Schon klar, aber man muss halt schon wieder einen Wrapper schreiben, weil's sonst der Compiler nicht versteht.

Hat Java eigentlich einen richtigen GC? Der von Python zB ist ziemlicher Schrott ("Igitt, reference counting!").

Zeus

volkard schrieb:

Zeus schrieb:

Jetzt sind wir aber beim Frickeln angekommen - ich meine wir basteln uns Modelle, die wir mit Hilfe von Java nicht ausdrücken können.

keiner verlangt das makro in java.

oder meintest du meine frage nach
//oder für baumknoten
swap(parent.left,parent.right.left);
?

Ja damit die Swap-Funktion alle Objekte swappen kann. Siehe mein Code-Post oben.

DEvent schrieb:

Wieso muss NodeRef von Ref erben? Integer erbt doch auch nichts.

Muss nicht, hab mein Post, während du deinen geschrieben hast, bearbeitet.

µngbd schrieb:

Hat Java eigentlich einen richtigen GC? Der von Python zB ist ziemlicher Schrott ("Igitt, reference counting!").

Ja, mehere sorgar, so dass sich seinen GC in Java einstellen kann.