schönes c++?

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.

Zeus schrieb:

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

Gefällt mir.

(offtopic)
Wo fängt man denn zu lesen an, wenn man sich Java anschauen will?

Zeus

Google Java Buch Online

Nexus

DEvent schrieb:

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

C++ ist beides. Aber wieso zählst du swap() als Low-Level-Funktionalität?

µngbd schrieb:

(offtopic)
Wo fängt man denn zu lesen an, wenn man sich Java anschauen will?

Auf der Sun-Homepage findest du auch Tutorials, obwohl ich persönlich ein Buch bevorzugen würde.

volkard

Zeus schrieb:

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.

So einen ausgemachten Blödsinn lese ich sonst nur im C++-Forum. Man mag doch nicht die Datenstrukturen so vergewaltigen, nur um statt

//swap(parent1.left,parent2.right.left); 
{Node tmp=parent1.left; parent1.left=parent2.right.left; parent2.right.left=tmp;}

etwas swap-ähnliches schreiben zu dürfen.

Java kann bestimmte Sachen einfach nicht ausdrücken. Da mangelts an Abstraktionsmöglichkeiten und das ist low im Level. In diesem Punkt ist C highleveliger als Java. Tja, traurig aber wahr.

volkard schrieb:

;fricky schrieb:
volkard schrieb:
Kannst Du was bauern, das
int a=4;
int b=5;
swap(a,b);
ermöglicht? Ja oder nein? Wenn ja, gib Code an.
so etwa in Java:
int[] a = {4,5};
swap(a);
wie baust du swap?
und komm mir nicht mit lösungen, die so umständlich zu benutzen sind wie
int a=4;
int b=5;

//begin swap
int[] c = {a,b};
swap(c);
a=c[0];
b=c[1];
//swapped in only 4 lines of code

nee, in Java swapped man ints nicht so. in Java gibts keine referenzen auf einfache typen. wenn du in Java ein int-swapping intensives programm machen wilst, dann musste arrays nehmen. also so dann:

int[] array = {....};  // n elemente
...
swapInts (array, 3, 91);   // elemente 3 und 91 tauschen
...
public static void swapInts (int[] array, int p, int q)
{
   int temp = array[p];
   array[p] = array[q];
   array[q] = temp;
}

wenn du stattdessen nur mal eben 'nen swap von zwei variablen 'on the fly' brauchst, dann schreibst du's eben direkt hin: int t=a; a=b; b=t;
^^ in unterschiedlichen programmiersprachen geht sowas nunmal anders.

DEvent

volkard schrieb:

//swap(parent1.left,parent2.right.left); 
{Node tmp=parent1.left; parent1.left=parent2.right.left; parent2.right.left=tmp;}
etwas swap-ähnliches schreiben zu dürfen.

Java kann bestimmte Sachen einfach nicht ausdrücken. Da mangelts an Abstraktionsmöglichkeiten und das ist low im Level. In diesem Punkt ist C highleveliger als Java. Tja, traurig aber wahr.

Das glaubst du doch selbst nicht. Also ist Asm das Highlevelige an allen Sprachen, weil du damit Sachen ausdrücken kannst, die du in Ruby, Php und Java nicht kannst?

Das ist doch die Definition einer hochabstrakten Sprache, dass du eben die Low-Level-Sachen nicht mehr (oder nur umständlich) machen kannst. Bytes zu swappen ist für mich low-level. Mir wäre es sogar lieber, wenn man in Java ganz auf primitive Typen verzichtet hätte.

Nexus

DEvent schrieb:

Bytes zu swappen ist für mich low-level. Mir wäre es sogar lieber, wenn man in Java ganz auf primitive Typen verzichtet hätte.

Ich wiederhole mich gerne nochmals:

Nexus schrieb:

Aber wieso zählst du swap() als Low-Level-Funktionalität?

Es geht ja gar nicht um Bytes. Wenn man in Java einen Dreieckstausch macht, hat man nie mit Bytes oder Bits zu tun (in C++ übrigens auch fast nie). Trotzdem besitzt der Tausch zweier Objekte eine Semantik, die auch auf höherem Abstraktionslevel von Bedeutung sein kann.

Das Inline-Schreiben des Tauschs über drei Zuweisungen ist meiner Ansicht nach eher Low-Level als ein swap() -Funktionsaufruf, weil die temporäre Variable ein Implementierungsdetail ist. In diesem Punkt abstrahiert C++ sogar besser, da es eine fertige Funktion für sowas anbietet und es dem Aufrufer egal sein kann, auf welche Weise zwei Objekte getauscht werden.