Warum delphi lahmer als c++?

[Olli]

Zitat von Der_Unwissende:

Wichtig ist es natürlich zu beachten, dass eben nicht jeder Befehl gleich lange dauert (@Olli ich denke das ist Dir schon klar!). Nur kostet jede Division doch immer noch >> mehr als eine einfache Addition.

Nunja, da ich beruflich programmiere und Reverse Engineering betreibe ... jupp, ist mir klar. Ich wollte dies nur als theoretische Annahme einführen damit die Komplexität nicht unnötig ansteigt. Das unterscheidet bekanntlich Modelle von der realen Welt

Das Beispiel von überladenen Operatoren und Matrizen (Vektor und/oder Skalarprodukt) ist hier ein gutes Beispiel. Der Code ist intuitiv und supergut lesbar, aber die Operatoren selber sind auch zu implementieren. Sie müssen allerdings nicht für den Programmierer sichtbar sein. Ergo kann eine solche simple Zeile HLL-Code gut und gern ein kleines C-Programm in der Komplexität übertreffen ohne mehr Zeilen zu haben.

Zitat von alzaimar:

Delphi-Quellcode:

For i:=1 to length (Haystack)-Length(Needle)+1 do
  For j:=1 to Length (Needle) do
    If Haystack[i+j-1] = Needle[j] Then 
      Found := True;

Wo ist die Abbruchbedingung? (Scherz!)

Zitat von alzaimar:

Code:

void buildSuffixAutomaton(char *x, int m, Graph aut) {
   int i, art, init, last, p, q, r;
   char c;
  
   init = getInitial(aut);
   art = newVertex(aut);
   setSuffixLink(aut, init, art);
   last = init;
   for (i = 0; i < m; ++i) {
      c = x[i];
      p = last;
      q = newVertex(aut);
      setLength(aut, q, getLength(aut, p) + 1);
      setPosition(aut, q, getPosition(aut, p) + 1);
      while (p != init &amp;&amp;
             getTarget(aut, p, c) == UNDEFINED) {
         setTarget(aut, p, c, q);
         setShift(aut, p, c, getPosition(aut, q) -
                             getPosition(aut, p) - 1);
         p = getSuffixLink(aut, p);
      }
      if (getTarget(aut, p, c) == UNDEFINED) {
         setTarget(aut, init, c, q);
         setShift(aut, init, c,
                  getPosition(aut, q) -
                  getPosition(aut, init) - 1);
         setSuffixLink(aut, q, init);
      }
      else
         if (getLength(aut, p) + 1 ==
             getLength(aut, getTarget(aut, p, c)))
            setSuffixLink(aut, q, getTarget(aut, p, c));
         else {
            r = newVertex(aut);
            copyVertex(aut, r, getTarget(aut, p, c));
            setLength(aut, r, getLength(aut, p) + 1);
            setSuffixLink(aut, getTarget(aut, p, c), r);
            setSuffixLink(aut, q, r);
            while (p != art &amp;&amp;
                   getLength(aut, getTarget(aut, p, c)) >=
                   getLength(aut, r)) {
               setShift(aut, p, c,
                        getPosition(aut,
                                    getTarget(aut, p, c)) -
                        getPosition(aut, p) - 1);
               setTarget(aut, p, c, r);
               p = getSuffixLink(aut, p);
            }
         }
      last = q;
   }
   setTerminal(aut, last);
   while (last != init) {
      last = getSuffixLink(aut, last);
      setTerminal(aut, last);
   }
}

Igittigitt. Variablen nicht initialisiert. Variablen außerhalb des allernötigsten Bereichs deklariert *brrr*

Nee, aber mal ernst, uns ist allen klar warum sowas schneller geht. Und das ist nicht wegen der fehlenden Abbruchbedingung ...

Zitat von alzaimar:

Egal: Natürlich benötigen 10000 Op-codes i.R. länger als 3

Jupp, mein Punkt war halt, daß man bei einer Schleife ja die Instruktionen innerhalb der Schleife pro Durchlauf einmal ausführen muß. Ergo dürfte die Binärdatei kleiner sein als bei deinem Algo, jedoch werden netto mehr Instruktionen vom Prozessor ausgeführt.

Ich muß echt an meinem Ausdruck feilen. Zu lange im Ausland

Gruß aus dem (nicht vom Internet abgeschnittenen) Reykjavik,