for-Schleife gegen über while-Schleife

[Nikolas]

Vielleicht sollte man auch den Wert von i nach Beendigung der Schleife in Betracht ziehen.

Bei der While Methode wird i inkrementiert, unabhängig davon, ob danach abgebrochen wird oder nicht.
Bei der for-schleife könnte man i direkt als Position des gefundenen Objekts benutzen.

wenn's um Lesbarkeit und minimale Geschwindigkeitsgewinne geht: wie wäre es mit

Delphi-Quellcode:

  for I := 0 to length(SonnenStundenListe) - 1 do
  begin
    if SonnenStundenListe[i, 0] = PLZ then
        return true;
  end;

[Luckie]

Zitat von jaenicke:

Sinnvoller wäre aber ja wohl eine Betrachtung des nächstkleineren Arrayeintrags statt alle Postleitzahlen durchzuprobieren.
Dafür müsstest du nur einmal dein Array durchgehen und alle vorhandenen Postleitzahlen betrachten. Das geht selbst bei einem unsortierten Array vermutlich schneller. Schließlich werden in deinem Array ja nicht so viele Postleitzahlen sein.

Manchmal sieht man den Wald vor lauter Bäumen nicht.

Zitat von Meflin:

Luckie, erlich gesagt habe ich keine Ahnung, was du für ein Problem mit derartigen Abbruchbedingungen in while-Schleifen hast

Das ist ein absolutes Standardkonstrukt...

Das ist es wohl, aber wie man sieht habe ich es mir unnötig schwer gemacht. Ich hatte also schon ein Gefühl, dass da was nicht gut ist.

Zitat von DJ-SPM:

Zitat von Luckie:

Unser Lehrer hat heute gemeint, [...]

Morgen,

darf ich fragen, was du machst? Machst du eine Fortbildung oder sowas in der Art? Bei deinem Wissen, Deine Tuts und deine Non-VCL-Programme fällt mir es schwer zu glauben, dass du hier

a) von einem Lehrer im klassischen Sinne redest und

Ich mache eine Ausbildung zum Fachinformatiker anwendungsentwicklung. Also schon ein Lehrer im klassischen Sinne.

Zitat:

b) Dich ernsthaft mit den "Grundlagen" von Pascal beschäftigst.

Auch nach Jahren kann man sich noch mit den Grundlagn beschäftigen, dazu ist es nie zu spät.

Zitat:

Versteh mich nicht falsch, wenn dich deine Frage - zurecht - interessiert ist das ok. Mir ging es nur darum, dass du sagtest, dass dein Lehrer das meinte.
[..]
und wofür du einen Lehrer hast, der dir Delphi erklärt

Das mit den Schleifen ist ja nicht Delphi spezifisch.

[Win32.API]

Zitat von jaenicke:

[...]Am optimalsten sieht das Ergebnis aus, wenn man direkt High benutzt, dann spart man auch noch das -1 [...]

Das ist nur die halbe Warheit, denn eigentlich sieht das ganze dann so aus:

Code:

00453340 8B45FC           mov eax,[ebp-$04]
00453343 E8E421FBFF       call @DynArrayHigh
   @DynArrayHigh:
   00404E88 E8F3FFFFFF       call @DynArrayLength
   00404E8D 48               dec eax ; Da ist dein -1 wieder ;)
   00404E8E C3               ret 
   00404E8F 90               nop 
00453348 85C0             test eax,eax

Edith: Die man koennte length() noch optimieren:


length():
Delphi internes length()

Code:

length():
Ticks: ~9
MS: 3.35*10^-5

length__()
Wie das delphi interne length() nur ohne nil check

Delphi-Quellcode:

function Length__(var Obj):Integer;
asm
  mov eax, [eax - 4]
end;

Code:

length__():
Ticks: ~8
MS: 3.38*10^-5

length_()
Als inline variante

Delphi-Quellcode:

function Length_(var Obj):Integer; inline;
begin
  result := pDWord(DWord(Obj) - 4)^;
end;

Code:

length_():
Ticks: ~1
MS: 2.94*10^-5

[omata]

Zitat von Luckie:

Unser Lehrer hat heute gemeint, dass man es möglichst vermeiden sollte aus Schleifen zu springen. Und wenn es nötig sein sollte, sollte man es im Schleifenkopf machen, also eine while-Schleife nehmen.

Da habt ihr ja einen sehr guten Lehrer

[sx2008]

Ich würde ich der For-Schleife sogar ein Exit anstelle eines Break verwenden (Natürlich nur wenn möglich).
Damit erreiche ich, dass das Register für Result möglichst lange dem Compiler für anderweitige
Benutzung zur Verfügung steht.

Delphi-Quellcode:

function IsPLZInArray(SonnenStundenListe: TSonnenStunden; PLZ: Integer): Boolean;
var
  i: Integer;
  CurrentPLZ: Integer;
begin
  for i := 0 to length(SonnenStundenListe) - 1 do
  begin
    CurrentPLZ := SonnenStundenListe[i, 0];
    if CurrentPLZ = PLZ then
    begin
      Result := True;
      Exit;
    end;
  end; 
  Result := False;  // nichts gefunden
end;

[RWarnecke]

Zitat von sx2008:

Ich würde ich der For-Schleife sogar ein Exit anstelle eines Break verwenden (Natürlich nur wenn möglich).
Damit erreiche ich, dass das Register für Result möglichst lange dem Compiler für anderweitige
Benutzung zur Verfügung steht.

Delphi-Quellcode:

function IsPLZInArray(SonnenStundenListe: TSonnenStunden; PLZ: Integer): Boolean;
var
  i: Integer;
  CurrentPLZ: Integer;
begin
  for i := 0 to length(SonnenStundenListe) - 1 do
  begin
    CurrentPLZ := SonnenStundenListe[i, 0];
    if CurrentPLZ = PLZ then
    begin
      Result := True;
      Exit;
    end;
  end; 
  Result := False;  // nichts gefunden
end;

Wenn Du Dein Result := False vor die FOR-Schleife setzt, brauchst Du auch kein Exit und kannst das Preak drinlassen.

[Keldorn]

Zitat von Luckie:

Unser Lehrer hat heute gemeint, dass man es möglichst vermeiden sollte aus Schleifen zu springen. Und wenn es nötig sein sollte, sollte man es im Schleifenkopf machen, also eine while-Schleife nehmen.

es gehört jetzt zwar nicht ganz zum Thema , aber ich finde es deprimierend, wenn sich ein Lehrer über die Verwendung einer for oder while-schleife Gedanken macht.
Auf der anderen Seite aber heute noch zuläßt, das eine PLZ als integer deklariert wird

Gruß Frank

[sx2008]

Zitat von RWarnecke:

Wenn Du Dein Result := False vor die FOR-Schleife setzt, brauchst Du auch kein Exit und kannst das Preak drinlassen.

Das Result wird doch im Register EAX gehalten.
Indem man das Result so spät wie möglich zuweist, gibt man dem Compiler die Möglichkeit das Register frei zu verwenden.

[jaenicke]

Zitat von Keldorn:

Auf der anderen Seite aber heute noch zuläßt, das eine PLZ als integer deklariert wird

Naja, die Architektur ist 32-Bit, insofern ist es durchaus sinnvoll auch eine 32-Bit Zahl zu benutzen.

Ich glaube dazu stand auch etwas entsprechendes in der Delphi-Hilfe.