Liegt bei array of Werte hintereinander?

[rowkajjh]

Hallo,

vielleicht erinnert sich noch einer an mein gestriges Problem. Egal, ich habe es jetzt so gelöst:

Delphi-Quellcode:

type TLayer   = array of double;   //Feld von doubles
type TMap     = array of TLayer;   //Feld von Zeigern

FMap           : TMap;

Function TImgProc.Min(map : Integer) : double;
var
   x,y,line: Integer;
   lsrc    : pDouble;
begin
     Result := 99999999.9;

     for y := 0 to FHeight-1 do
     begin
          lsrc    := @FMap[map, FWidth*y];
          line := FWidth*y;
          for x := line to line+FWidth-1 do
          begin
            //if(Result > lsrc^) then Result := lsrc^;  // <-- schnelle Version
            //Inc(lsrc);                                // <--°

            if(Result > FMap[map, x]) then Result := FMap[map, x]; // <-- sichere ? Version
          end;
     end;
end;

Der Zugriff über den Pointer (lsrc := @FMap[map, FWidth*y] ist schneller, aber darf man sowas? Es ginge ja nur, wenn sichergestellt ist, daß bei FMap (also array of array of double) der Speicher hintereinander allokiert wurde.

Vielen Dank für Hilfe
Tschau!

[Dax]

Natürlich ist es so. Ein Array ist ein simpler Datentyp, die Indizierung der Elemente beruht auf Pointerarithmetik. Von daher machts keinen Sinn, die Werte nicht an einem Stück hintereinander abzulegen

[rowkajjh]

Zitat von Dax:

Natürlich ist es so. Ein Array ist ein simpler Datentyp, die Indizierung der Elemente beruht auf Pointerarithmetik. Von daher machts keinen Sinn, die Werte nicht an einem Stück hintereinander abzulegen

Danke. Ich wollt' ja nur sicher sein.

Was mir noch ein bissel Bauchschmerzen macht ist dieses:

Delphi-Quellcode:

lsrc    := @FMap[map, FWidth*y];
for x := 0 to FWidth-1 do
begin
 if(Result < lsrc^) then Result := lsrc^;
 Inc(lsrc);
end;

Nach dem letzten Durchlauf zeigt ja lsrc durch das Inc auf Speicherplatz, der mir garnicht gehört? Macht das was? Kann man die for-Schleife irgendwie "besser" aufbauen, damit das nicht passiert?

Danke und Tschau - Robert

[Oxmyx]

Das ist völlig egal, solange du nicht darauf zugreifst.

[Muetze1]

Ansonsten könntest du nach Delphi Syntax noch für Sicherheit in der Zukunft sorgen, wenn du einfach die beiden Arrays so definierst:

Delphi-Quellcode:

Type 
  TLayer   = packed array of double;   //Feld von doubles
  TMap     = packed array of TLayer;   //Feld von Zeigern

[alzaimar]

Nach meinen kurzen Tests ist bei mir folgender Code noch schneller:

Delphi-Quellcode:

Function TImgProc.Min(map : Integer) : double;
var
   x,y,line: Integer;
   lsrc    : TLayouer;
begin
     Result := 99999999.9;
     lsrc := fmap[map];
     for y := 0 to FHeight-1 do
     begin
          line := FWidth*y;
          for x := line to line+FWidth-1 do
          begin
            if(Result > lsrc[x]) then Result := lsrcp[x]; 
          end;
     end;
end;

Also, statt Pointeraddition ein Array. Matrizen sind dann wieder langsamer, da bei der Adressierung eine Multiplikation involviert ist.