✔ Mit schelife durchlaufen lassen oder ohne

[son gohan]

Mit oder ohne schelife durchlaufen lassen, was sparsamer?

Hallo,

ich will ja gerne immer sparsamen code schreiben aber nicht nur an Quellcode möchte ich sparen, sondern auch an Rechenleistung!

Eine Frage welche Variante wäre wohl sparsamer von beiden, einmal lasse ich einfach manuell von oben nach unten verschiedene Werte austauschen in einem Array wo immer der letztere Wert weiter gegeben wird an den nächsten und beim zweiten Versuch habe ich mir gedacht das man auch mit einer Schleife das lösen könnte.

Erste Variante

       _5er[9][1]=_5er[8][1];
      _5er[8][1]=_5er[7][1];
      _5er[7][1]=_5er[6][1];
      _5er[6][1]=_5er[5][1];
      _5er[5][1]=_5er[4][1];
      _5er[4][1]=_5er[3][1];
      _5er[3][1]=_5er[2][1];
      _5er[2][1]=_5er[1][1];
      _5er[1][1]=_5er[0][1];
     
      _5er[9][0]=_5er[8][0];
      _5er[8][0]=_5er[7][0];
      _5er[7][0]=_5er[6][0];
      _5er[6][0]=_5er[5][0];
      _5er[5][0]=_5er[4][0];
      _5er[4][0]=_5er[3][0];
      _5er[3][0]=_5er[2][0];
      _5er[2][0]=_5er[1][0];
      _5er[1][0]=_5er[0][0];
      
      _5minRK[9][0]=_5minRK[8][0];
      _5minRK[8][0]=_5minRK[7][0];
      _5minRK[7][0]=_5minRK[6][0];
      _5minRK[6][0]=_5minRK[5][0];
      _5minRK[5][0]=_5minRK[4][0];
      _5minRK[4][0]=_5minRK[3][0];
      _5minRK[3][0]=_5minRK[2][0];
      _5minRK[2][0]=_5minRK[1][0];
      _5minRK[1][0]=_5minRK[0][0];
  
      _5minRK[9][1]=_5minRK[8][1];
      _5minRK[8][1]=_5minRK[7][1];
      _5minRK[7][1]=_5minRK[6][1];
      _5minRK[6][1]=_5minRK[5][1];
      _5minRK[5][1]=_5minRK[4][1];
      _5minRK[4][1]=_5minRK[3][1];
      _5minRK[3][1]=_5minRK[2][1];
      _5minRK[2][1]=_5minRK[1][1];
      _5minRK[1][1]=_5minRK[0][1];

Beim zweiten Versuch habe ich eine while Schleife gebaut die einfach immer die Indexvariable der Arrays ändert da die ja sowieso nur immer um 1 erhöt werden müssen.

int ens=5,zwe=4;

     while(ens>0){
      
      _5er[ens][0]=_5er[zwe][0];
      _5er[ens][1]=_5er[zwe][1];
      
      _5minRK[ens][0]=_5minRK[zwe][0];
      _5minRK[ens][1]=_5minRK[zwe][1];

      ens--;
      zwe--;
     }

Meine Frage ist was glaubt ihr welche Variante sparsammer ist von der Rechenleistung her, es interissiert mich mal einfach, leider weiß ich es selber nicht

 

[LukeS]

Ich habe keine direkte Antwort für dich.
Doch wird bei modernen Compilern der Code sowieso optimiert. Wahrscheinlich macht es schussendlich keinen grossen Unterschied.
Ich persölich mag die Version mit der Schleife lieber. Aber nur, da sie mir angenehmer zu lesen erscheint.

Arrays kann man ja auch mit der Zeigerarithmetik durchlaufen. Ich glaube das ist effizienter als mit einer int Variablen.

Gruss LukeS

 

[son gohan]

Hallo,

danke für dein Beitrag.

Ich finde natrlich auch die zweite Variante schöner wegen der besseren Lesbarkeit.

Ich bin mir aber halt nicht sicher ob es vom Rechen und Speicheraufwand besser ist, ich programmiere nämlich nur so für mich hin und habe das mir selbst beigebracht.

Zum Thema Zeigerarithmetik bei arrays muss ich dann noch etwas neues lernen.

 

[kle-ben]

Arrays kann man ja auch mit der Zeigerarithmetik durchlaufen. Ich glaube das ist effizienter als mit einer int Variablen.

Das dachte ich auch, und deswegen hab ich das mal letztens getestet.
Ich hab dazu eine Funkion geschrieben die eine Zeichenkette umdreht. Einmal mit Zugriff über den Index, und einmal nur mit Zeigern. Und ich hab von beiden die Zeiten bei ner 1 Mio. Zeichen Zeichenkette gemessen, und es hat überhaupt kein Unterschied gemacht. Es wird ja auch in beiden Fällen einfach nur ein Adresswert um einen Offset erhöht.

Doch wird bei modernen Compilern der Code sowieso optimiert.

Deswegen glaub ich auch nicht das das viel unterschied macht. Die zweite Variante find ich daher auch besser. Du kannst ja mal von beiden Varianten die Zeiten messen und vergleichen. In der time.h findest du dazu die Funktion clock().
Die rufst du einmal vor und einmal nach dem Programmabschnitt auf. Dann Ziehst du die Startzeit von der Endzeit ab udn teilst durch CLOCKS_PER_SEC. Allerdings wird die Zeit für so ein kleines stück Code wohl kaum messbar sein.


Gruß Benny

 

[MCoder]

Hallo son gohan,

meiner Ansicht nach sollte man bei einer Hochsprache alle Möglichkeiten nutzen, um bestmöglich lesbaren und strukturierten Quellcode zu erzeugen. Gerade bei deinem Beispiel dürften Performanceunterschiede kaum nachweisbar sein, zumal man inzwischen schwer abschätzen kann, was der Compiler am Ende daraus macht.
Die zweite Variante z.B. lässt sich viel einfacher modifizieren, falls etwa mal andere Array-Größen verwendet werden sollen.

Gruß
MCoder

 

[son gohan]

Hallo,

also ich bedanke mich für eure guten Ratschläge und denke das ich auch die zweite Variante nehmen werde weil die natürlich übersichtlicher ist.

Zum Thema Zeiger werde ich mir dann auch noch mal etwas durchlesen.

Viele Grüße
son gohan