Dyn. Array of Double an funktion übergeben

[DeddyH]

Nur mal als Anregung:

Delphi-Quellcode:

function MaxFloatValue(const Values: array of double): double;
var
  i: integer;
begin
  if Length(Values) < 1 then
    raise Exception.Create('Keine Vergleichswerte übergeben');
  Result := Values[Low(Values)];
  for i := Low(Values) + 1 to High(Values) do
    if Values[i] > Result then
      Result := Values[i];
end;

[dummzeuch]

Zitat von DeddyH:

Nur mal als Anregung:

Delphi-Quellcode:

function MaxFloatValue(const Values: array of double): double;
var
  i: integer;
begin
  if Length(Values) < 1 then
    raise Exception.Create('Keine Vergleichswerte übergeben');
  Result := Values[Low(Values)];
  for i := Low(Values) + 1 to High(Values) do
    if Values[i] > Result then
      Result := Values[i];
end;

Oder, wenn's leichter zu lesen sein soll:

Delphi-Quellcode:

function MaxFloatValue(const Values: array of double): double;
var
  i: integer;
  Len: integer;
begin
  Len := Length(Values)
  if Len < 1 then
    raise Exception.Create('Keine Vergleichswerte übergeben');
  Result := Values[0];
  for i := 1 to Len - 1 do
    if Values[i] > Result then
      Result := Values[i];
end;

Denn: Innerhalb der Funktion ist Low() immer 0 und High() immer Length()-1.

Um nochmal Rudy zu Wort kommen zu lassen:
http://rvelthuis.de/articles/articles-openarr.html

[himitsu]

Wurde nicht vorhin noch der Index geliefert?
Jetzt das Max.

Der Compiler sollte aus Low(Values) eine konstante 0 machen,
also im Compilat gibt es keinen Unterschied zwischen Low(Values) und 0.

Eine Lösung für 10.4.2

Delphi-Quellcode:

function MaxFloatValue(const Values: array of Double): Double;
begin
  if Length(Values) = 0 then
    Exit(0);  // oder eine Exception
  Result := Values[0];  // oder eben Result := Values[Low(Values)];
  for var Value in Values do
    if Value > Result then
      Result := Value;
end;

und noch was für alle Delphis/FreePascal/...

Delphi-Quellcode:

function MaxFloatValue(const Values: array of Double): Double;
begin
  if Length(Values) = 0 then
    Exit(0); // oder eine Exception
  Result := MaxValue(Values);
end;

Zitat von System.Math.pas:

Delphi-Quellcode:

function MaxValue(const Data: array of Single): Single;
var
  I: Integer;
begin
  Result := Data[Low(Data)];
  for I := Low(Data) + 1 to High(Data) do
    if Result < Data[I] then
      Result := Data[I];
end;

[TomyN]

Auch wenn ich weiß, dass der Compiler es automatisch macht, so schreibe ich persönlich doch lieber

Code:

function MaxValue(const Data: array of Single): Single;
var
  I: Integer;
  startL: Integer;
  endL: Integer; 
begin
  Result := Data[Low(Data)];
  startL:= Succ(Low(Data));
  endL:= High(Data);
  for I := startL to endL do
    if Result < Data[I] then
      Result := Data[I];
end;

Und ob max absolut sein soll oder nicht, wäre noch zu klären.

Tomy

[wendelin]

Hallo,
vielen Dank für Eure Antworten.

Die Fehlermedung 'Incompatible Types' Array und dyn. Array kam von einer falschen Array-Var.
Jetzt läuft es!

Ich habe noch eine Frage: Warum muß im Funktionskopf das Array of Double als Konstante deklariert werden ?

Ich habe noch die Funktion IndexOfMinValue geschrieben:

Delphi-Quellcode:

function IndexOfMinValue_1(Const x : Array of Double): Integer;
Var
  Index    : Integer;
  MinValue : Double;
begin
  Result   := high(x);
  MinValue := MaxDouble;
  for Index := 0 to high(x) do begin
    if x[Index] < MinValue then begin
      Result := Index;
      MinValue := x[Index];
    end;
  end;
end;

Wendelin

[Andreas13]

CONST im Funktionskopf sorgt dafür, daß
- ein Pointer auf das Array übergeben wird und nicht der Inhalt des Arrays kopiert wird,
- das Original-Array nicht verändert werden kann
- das Ablegen des Arrays im Speicher vom Compiler optimiert werden kann, um effizientere Zugriffe zu ermöglichen.

Möglicherweise gibt es noch mehr Gründe, die unsere Top-Spezialisten Dir besser erklären können.
Gruß, Andreas

[wendelin]

Danke Andreas,

Gruß Wendelin

[Andreas13]

Viel Efolg, Wendelin !
Gruß, Andreas

[Andreas13]

Hallo Wendelin,
noch ein kleiner Tipp: Wenn Delphi 7 Enterprise noch kein CONST im Funktionskopf kennt, Du solltest stattdessen überall VAR benutzen.
Gruß, Andreas

[Stevie]

Zitat von Andreas13:

Die "Gefahr" bei offenen Parametern besteht nur darin, daß der Index sowohl bei 0 (dynamisch), als auch bei 1 (statisch) beginnen kann. Daher sollte der Zugriff immer über Low(..) und High(..) erfolgen, wenn man nicht total durcheinanderkommen will.
Andreas

Sorry, aber das ist leider falsch - ein open array parameter besteht aus dem Pointer aufs erste Element und den letzten index.

Zitat von Dokumentation:

Sie sind stets nullbasiert.

for i := 0 to High(values) ist somit immer korrekt.
Kannste auch im disassembly angucken, aus Low(values) wird immer stumpf hardcoded 0.

Und deshalb geht damit auch sowas schickes.