kann man in folgendem code das optimieren, was in main() steht?

int n=7, p=5;
int f(int x) {n+=x;}
int main()
{
   int a=p;
   p=n;
   n=f(a);
}

... => das ist wirklichkeit eine aufwendigere berechnung, wo der inhalt von main in einer schleife steht...
aber so vom prinzip her? sowas wie n=f(p=n) oder so? weil n und p sind instanzen von klassen, die sehr viel speicher brauchen...

wäre nett,
lw

wenn das verschieben von großen datenmengen das prob ist, wäre das ein guter workaround.

ich bräuchte also eine möglichkeit, dem compiler mitzuteilen, dass er f(p) berechnen und das ergebnis in n speichern soll, "zwischenzeitlich" aber noch den alten wert von n in p speichern soll, bevor dieser von n=f(p) überschrieben wird.
wenn ich aber p=n einfach so vorausstelle, dann würde der wert von p verloren gehen und f(p) würde im enteffekt f(n) berechnen...

und da hab ich mich halt gefragt, ob das wirklich nicht irgendwie besser geht als diese art 'dreieckstausch'. weil es sich hier wirklich um große datenmengen handelt und dieser codeabschnitt in der schliefe sehr oft durchlaufen wird. außerdem sind ja das ja wie erwähnt klassen, die bei jedem schleifendurchaluf auch (de+)konstruiert etc. werden müssen...

lw

ist imho die schnellste Variante, die mir einfällt - wenn du wirklich beide Werte parallel benötigst, bleibt dir nichts anderes übrig als sie zu kopieren.

Aber eventuell kannst du deinen Algorithmus ja so umstellen, daß du nach der n=f(n) Berechnung den früheren Wert von n nicht mehr benötigst.

deinen Algorithmus ja so umstellen, daß du nach der n=f(n) Berechnung den früheren Wert von n nicht mehr benötigst

würd ich gerne, aber gerade n soll der algor. ja berechnen *GG*

lw

deinen Algorithmus ja so umstellen, daß du nach der n=f(n) Berechnung den früheren Wert von n nicht mehr benötigst

würd ich gerne, aber gerade n soll der algor. ja berechnen *GG*

Aber benötigst du irgendwo in deinem Algorithmus den alten UND neuen Wert von n an einer Stelle? Wenn nein, kannst du alle Zugriffe auf den alten Wert vor und alle Zugriffe auf den neuen Wert nach "n=f(n);" unterbringen.

(just for Info: Was für ein Algo soll denn das werden?)

benötigst du irgendwo in deinem Algorithmus den alten UND neuen Wert von n

der alte wert von n wird dann in ein array geschrieben (hier: p) und beim nächsten schleifen-durchlauf wieder benötgt. - brauche wie gesagt nicht f(n) sondern f(p)

just for Info: Was für ein Algo soll denn das werden?

is quasi just for fun, aber ich hab das gefühl, dass ich mich sowas öfter frage.

es leuchtet mir allerdings ein, dass ich - wenn ich die alten werte brauche -sie zwischenzeitlich irgendwo speichern muss und mir dann nichts anderes übrig bleibt, als den speicher komplett zu kopieren. ich werde es also so lassen wie es ist. wenn jemand noch eine gute idee hat, würd ich sie trotzdem gerne hören

lw

der alte wert von n wird dann in ein array geschrieben (hier: p) und beim nächsten schleifen-durchlauf wieder benötgt. - brauche wie gesagt nicht f(n) sondern f(p)

Nach der Anweisung "p=n;" steht doch in p und n der selbe Wert, also ist das egal

(PS: Falls du darüber gestolpert sein solltest "n=f(n);" ist keine mathematische Gleichung, die dein Programm errechnen soll, sondern eine Zuweisung (berechne f(n) und überschreibe n mit dem Ergebnis der Berechnung))

Nach der Anweisung "p=n;" steht doch in p und n der selbe Wert, also ist das egal ;)))

...ja doch. aber ich will f(p) berechnen, nicht f(n) deshalb hab ich ja in dem beispiel auch f(a) genommen (und in a vorher den wert von p gespeichert, bevor es mit dem wert n überschrieben wurde), weil er eben sonst f(n) berechnen würde und...ach ließ einfach mal den threat.

(PS: Falls du darüber gestolpert sein solltest "n=f(n);" ist keine mathematische Gleichung, die dein Programm errechnen soll, sondern eine Zuweisung (berechne f(n) und überschreibe n mit dem Ergebnis der Berechnung))

so gesagt: gewisser analogien in diesem beipsiel zu trotz, bin ich mir der unterschiedschiede durchaus bewusst.

lw