Übergebenes Array: low() immer 0?

[Thanatos81]

Nur mal ne schnelle Frage: wenn ich einer Prozedur/Funktion ein Array übergebe, ergibt low immer 0?

Zur Verdeutlichung mal ein kurzes Beispiel:

Delphi-Quellcode:

procedure getChecksumme(var bc : array of Byte);
var i,cs : Byte;
begin
  cs := 0;
  for i := low(bc) to high(bc)-1 do
    begin
      if (i mod 2 = 0)
        then cs := cs + bc[i]
        else cs := cs + bc[i]*3;
    end;  
  if (cs mod 10 = 0)
    then cs := 0
    else cs := 10 - (cs mod 10);
  bc[high(bc)] := cs;
end;

Der Proezdur übergebe ich ein array[1..13]of Byte. low spuckt mir aber 0 statt 1 raus. Wenn das immer so ist (auch wenn das Array mal mit 2, 12 oder weiss der Geier was anfängt) ist alles i.O. Ansonsten muss ich mir noch was anderes überlegen, damit jedes 2. Array-Elemente mit 3 multipliziert wird.

Schönen Dank im Voraus,
Thomas

P.S.: Bevor wer fragt, ja es geht um die Prüfsumme des EAN13 :wink:

[Sourcemaker]

Hi,

Arrays werden meines Wissens immer nullrelativ übergeben.
Delphi-Hilfe "Offene Array-Parameter" als Bestätingung.

Grüße

Frank

[Thanatos81]

Danke, genau so was in der Richtung wollte ich hören! Das passt mir jetzt super in den Kram *freu*

[bigg]

:oops: Ihr habt recht. :oops:

[NicoDE]

Zitat:

Zitat von bigg

Gegenbeispiel: :???:

Das ist kein 'Offenes Array'.

[Thanatos81]

Das mit dem Gegenbeispiel war mir schon klar, das da bei low 1 und bei high 63 rauskommen muss. Aber da wurde es ja auch nicht an eine Methode übergeben.

Ne, das var in meinen Beispiel ist schon OK, ich will ja die letzte Zelle des Arrays ändern. Und ein const kann man soweit ich weis nicht ändern.

[negaH]

Gegenfrage: "Was interessiert dich das ?" Du solltest immer mit Low(), High() arbeiten, statt mit konstant 0.
Es gibt arrays di nicht mit Low() == 0 anfangen, zb.

Delphi-Quellcode:

type
  TMyArray = array[123...345] of Type;
  TMyArray = array[-123..+123] of Type;
  TMyArray = array[Boolean] of Type;
  TMyArray = array[red..green] of Type;

Low(), High() arbeiten aber auch ganz speziell mit solchen Spezial-Arrays die andere ordinale Indizees zulassen.

Gruß Hagen

[Thanatos81]

Ich arbeite schon immer mit low und high, wenn ich nicht innerhalb einer Prozedur ein festes Array habe.

Aber bei meinem Beispiel geht es um das "i mod 2". Jedes zweite Element muss mit drei multipliziert werden. Nicht jedes Element mit einem durch zwei teilbaren Index. Da ist der Wert von low schon von Bedeutung.

Wenn low null oder gerade ist muss es

Delphi-Quellcode:

if (i mod 2 = 0)
  then cs := cs + bc[i]
  else cs := cs + bc[i]*3;

heissen.

Ansonsten wäre

Delphi-Quellcode:

if (i mod 2 = 0)
  then cs := cs + bc[i]*3
  else cs := cs + bc[i];

richtig.

Deswegen brauch ich halt einen Wert für low auf den ich mich verlassen kann.

[NicoDE]

Zitat:

Zitat von Thanatos81

Jedes zweite Element muss mit drei multipliziert werden. Nicht jedes Element mit einem durch zwei teilbaren Index.

Delphi-Quellcode:

if not Odd(i - Low(bc)) then

Odd ist übrigens besser als der Versuch mit mod die Performance zu optimieren...

[negaH]

Delphi-Quellcode:

var
  C: array[0..1] of Integer;
  I,J: Integer;
begin
  C[0] := 0;
  C[1] := 0;
  J := 0;
  for I := Low(Array) to High(Array) do
  begin
    Inc(C[J], Array[I]);
    J := (J + 1) and 1;
  end;
  Result := C[0] + C[1] * 3;
end;

Gruß hagen

[negaH]

oder noch besser:

Delphi-Quellcode:

var 
  C: array[Boolean] of Integer; 
  I: Integer; 
  J: Boolean;
begin 
  C[False] := 0; 
  C[True] := 0; 
  J := False; 
  for I := Low(Array) to High(Array) do 
  begin 
    Inc(C[J], Array[I]); 
    J := not J;
  end; 
  Result := C[False] + C[True] * 3; 
end;

Wichtig ist

1.) Multiplikation mit *3 wird nur einmalig durchgeführt
2.) es gibt in der Schleife nur Additionen
3.) es gibt in der Schleife KEINE bedingten Sprünge, sprich Abfragen wie IF THEN und somit keine unnötigen Branches in der CPU, ergo der Code kann wesentlich schneller ausgeführt werden
4.) durch das separate J ist der Algo. unabhängig von der Array[] Deklaration
5.) durch J: Boolean muß auf J keinerlei zeitraubende Operation durchgeführt werden, ein simples NOT reicht aus
6.) durch die separate Addition auf 2 Elementesummen halbiert sich die Gefahr eines Integer-Überlaufes und erst am Ende der Schleife kann es eine ERangeCheck Exception geben

Gruß Hagen

[Thanatos81]

Danke für eure Ideen! Vor allem die Lösung vion negaH sagt mir wirklich zu.

Auch wenn, oder viel mehr gerade weil, ich mich erstmal reindenken und es an meine Bedürfnisse anpassen musste ;-)

[negaH]

Zitat:

Auch wenn, oder viel mehr gerade weil, ich mich erstmal reindenken und es an meine Bedürfnisse anpassen musste

Ich kaue dir doch nicht die fertige Lösung vor ;)

Gruß Hagen

[Thanatos81]

Zitat:

Zitat von negaH

Zitat:

Auch wenn, oder viel mehr gerade weil, ich mich erstmal reindenken und es an meine Bedürfnisse anpassen musste

Ich kaue dir doch nicht die fertige Lösung vor ;)

Gruß Hagen

Eben, wo würde denn da der Spaß bleiben :-D Vom Lerneffekt ganz zu schweigen :wink:

Schönen Gruß,
Thomas