Delphi-PRAXiS - Compileroptimierung: Was passiert?

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)

- Sonstige Fragen zu Delphi (https://www.delphipraxis.net/19-sonstige-fragen-zu-delphi/)

- - Compileroptimierung: Was passiert? (https://www.delphipraxis.net/55873-compileroptimierung-passiert.html)

Compileroptimierung: Was passiert?

Als ich mit c++ angefangen habe, hatte ich in meinen Tutorials immer auch gleich Hinweise, wie die Compileroptimierung funzt. Also mit C++ bin ich noch ganz am Anfang und weiß kaum was darüber, aber bei Delphi weiß ich garnichts darüber.

Ich habe zum Beispiel

hier gelesen, dass man result in Funktionen besser nicht benutzen sollte. Also ist die C++-Lösung (mit return) dann doch eigentlich besser. Zumindest zum Verständnis. Wenn es Delphi aber schon mit result macht, dann würde ich denken, dass die Compileroptimierung darauf eingestellt ist, dass man result auch richtig benutzt.

Naja, irgendwie versuche ich beim Programmieren schon öfters mal darüber nach, was die Compileroptimierung mit meinem Code so macht. Also ist es jetzt egal, ob man inc(a) oder a :=a +1 benutzt? Wie sieht es mit inline-Funktionen aus? So "richtig" gibt es die ja in Delphi nicht, aber eigentlich habe ich bis jetzt schon angenimmen, das die Compileroptimierung sehr kurze Funktionen dann doch als inline compiliert. Was ist, wenn ich mit div statt mit / dividiere? Ich könnte ja auch trunc oder round benutzen, um wieder einen integer zu bekommen. Macht da die Compileroptimierung was mit? Wie sieht es mit solchen Aufrufen aus:

Delphi-Quellcode:

			type TZeug= record;

var1: integer;

var2: string;

end;

var bla: array of TZeug;

setlength(bla, length(bla) +1);

bla[length(bla) -1].var1 :=1;

bla[length(bla) -1].var2 :='bla';

macht die compileroptimierung draus was besseres oder berechnet der dann length(bla) wirklich 3 mal?

Was ist mit Konstanten? Geht der Compiler da einfach von oben nach unter durch und ersetzt alle constanten durch ihre Werte, oder gibt es da was tiefsinnigeres?
Was ist eigenlich mit Pointern? Also ist es besser zu versuchen in einem array den key zu meiden und stattdessen einen Pointer auf das arrayitem zu verwenden oder ist das garnicht schneller? (Also besonders wenn man einen array aus records hat und die Element bezug aufeinander haben. Soll man da einen Pointer nehmen, oder lieber den key als integer im record speichern? Grundätzlich ist der key ja praktischer, weil man dann auch in dem array das vorhergende Element oder sowas rankommt. Wenn Pionter wirklich schnelle sind: Darf man dafür hinnehmen, das gewisse Sachen iterativ nicht mehr lösbar sind? (Also beispielsweise einen Stammbaum, wo es immer Mutter und Vater gibt. Dort muss man dann schließlich rekursiv jeden der Beiden Zweige durchgehen, wenn man eine Aktion mit allen Elementen durchführen will, und alles nur mit New() und Dispose() statt mit array gelöst ist. Achja, wenn man einen array iteriert (bei PHP gibt es ja foreach dafür), also mit for i:=0 to count(array)-1 do, erkennt der compiler das und macht da irgendwas besseres draus?
mit while(i<100) do inc(i); ist soviel langsamer als die Version mit for. Was macht der Compiler mit for soviel anders?

Also wirklich sehr viele Fragen zur Codeoptimierung und Compileroptimierung. Ich fände es mal äußerst interessant zu wissen, wie der Compiler da vorgeht. Und vielleicht ein Vergeleich zu andern Compilern? Haben die C++-Compiler wirklich eine besser Optimierung? Wie sieht das eigentlich mit PHP aus? Da sind die Möglichkeiten ja sehr eingeschränkt bis nicht vorhanden. Was macht der Interpreter da?