Totale Pointer-Verwirrung

[rowkajjh]

Hallo,

ich komme aus der C-Welt und bin total von Pointers und dynamischen arrays in delphi verwirrt.

Was ist denn der Unterschied zwischen 'pDouble' und 'array of double'?

Was ich letztendlich will (ich schreibs mal auf c-isch);

float **map=malloc(maps*sizeof(float*)); // Wieviel maps
map[i]=malloc(w*h*sizeof(float)); // Groesse jeder map

float *src=map[i];
src[x]=1.0f;


Danke und Tschau!

[chaosben]

Hi rowkajjh, herzlich Willkommen in der DelphiPraxis!

Ich würde dir gern helfen und ich hab auch schon diese und jene kleine Sache in C/C++ gemacht. Aber sobald mehr als 2 Pointer-* in einer Zeile stehen, hakts bei mir aus.

Sag mir doch mal bitte, was du genau machen willst.

[mkinzler]

Zitat von rowkajjh:

Was ist denn der Unterschied zwischen 'pDouble' und 'array of double'?

pDouble ist ein Zeigen auf einen Double-Wert. array of double ist ein Array von Double-Werten.

Zitat:

Was ich letztendlich will (ich schreibs mal auf c-isch);

float **map=malloc(maps*sizeof(float*)); // Wieviel maps
map[i]=malloc(w*h*sizeof(float)); // Groesse jeder map

float *src=map[i];
src[x]=1.0f;


Danke und Tschau!

var
map: array of double;
begin
setLength( map, maps); { maps = Anzahl maps }
...
map[x] := 1;
...
end;

[rowkajjh]

Zitat von mkinzler:

var
map: array of double;
begin
map.setLength( maps);
...
map[x] := 1;
...
end;

Ich habe aber mehrere maps, die ich alle dynamisch haben will. Also bräuchte ich noch sowas wie
allmaps : array of array of double;

Dann hat aber getmem nicht mehr funktioniert: 'array type requiered' bei
GetMem(allmaps,10)
for i=0 to 10 do GetMem(allmaps[i], widht*height*sizeof(double));

Was dahinter steckt: Ich will einen große Box mit mehreren Layern. In die einzelnen Layer will ich Bilder laden können. Dann will ich Filteroperationen schreiben, die als Ziel einen anderen Layer haben.

Damit wird dann z.B. sowas möglich:

Filtere(zielmap, sourcemap : Integer); -> nimm das Bild aus sourcemap und filtere es, speichere das Ergebnis in zielmap.

[Robert Marquardt]

Ein PDouble ist einfach ein double *.

Ein "array of Double" ist ein dynamischer Datentyp wie "string".
Ich erklaere es mal anhand von string. Alle "array of" Typen funktionieren im Prinzip genauso.

string ist in Delphi der Datentyp der einer echten Klasse am naechsten kommt.
Wie bei jedem anderen Objekt auch ist die Variable ein Pointer auf das dynamisch alloziierte Objekt.
Deklariert man eine string Variable so wird sie automatisch am Beginn der Funktion instanziiert.
Es kommt allerdings ein Trick zum Einsatz. Die Variable wird nur mit nil initialisiert. Das ist die Repraesentation des Leerstrings.
Am Ende der Funktion wird das Objekt automatisch geloescht.

Weist man einem string etwas zu so wird alloziiert. Im string enthalten ist ein C string mit #0 am Ende.
Zusaetzlich wird noch die Groesse des alloziierten Bereichs und ein Referenzzaehler angelegt.
Der gelieferte Zeiger zeigt auf den Beginn des C strings. Groesse und Referenzzaehler liegen davor!

Weist man die Variable einer andren Variablen zu so wird nur der Referenzzaehler erhoeht.
Aendert man den Inhalt so wird der string geklont (copy-on-write).

Nun kann man leicht erkennen das SetLength einem realloc() plus copy-on-write entspricht.

Der Zugriff auf einen Char im string (z. B. Variable[1]) entspricht einem ueberladenen Operator, denn string ist 1-basiert waehrend "array of" 0-basiert ist.
Die Umtypung eines strings zu einem char * mit PChar() ist in Wirklichkeit ein Funktionsaufruf, da der Sonderfall Leerstring beruecksichtigt werden muss und der String moeglicherweise geklont werden muss.

"array of" ist etwas einfacher gestrickt. Es gibt keinen Referenzzaehler.
Es gibt aber eine Laenge, die mit SetLength auch veraendert werden kann.

Mehrdimensionale Arrays also "array of array of ..." stapeln einfach.
Insbesondere kann man mit SetLength auch einzelne Dimensionen aendern!

[Der Jan]

Vielleicht hilft dir das weiter (ungetestet)

Delphi-Quellcode:

type
  TMap = array of double;   //Feld von doubles
  pTMap = ^TMap;            //Zeiger auf eben jenes
  TMaps = array of pTMap;   //Feld von Zeigern

var 
  the_maps: TMaps;
  i: integer;

begin
  Setlength(the_maps, laenge);
  for i := 0 to laenge - 1 do
    the_maps[i] := GetMem(h * w * sizeof(double));
end;

[mkinzler]

var
allmaps: Array of Array of Double;
...
begin
setLength( allmaps, w, h);
end;

[rowkajjh]

Zitat von Der Jan:

Vielleicht hilft dir das weiter (ungetestet)

Delphi-Quellcode:

type
  TMap = array of double;   //Feld von doubles
  pTMap = ^TMap;            //Zeiger auf eben jenes
  TMaps = array of pTMap;   //Feld von Zeigern

Geil, geht

Noch ein letztes. Eigentlich müßte doch die Konvertierung char -> double problemlos sein, oder? Aber leider:

Procedure TImgProc.UC2double(outmap : integer; img : PChar; pitch : Integer);
var
x,y : Integer;
line : PChar;
srcline: pTLayer;
src : pTLayer;
begin
if(pitch =-1) then pitch:=FWidth;

for y := 0 to FHeight do
begin
line := img + y*pitch;
srcline := FMap[outmap];
for x := 0 to FWidth do
begin
src := srcline;
Inc(src,x);
src^[x] := line[x]; // <-- Incompatible types: 'Double' and 'char'
end;
end;
end;

Häh?

[3_of_8]

Ein Double ist eine Fließkommazahl.

Ein Char ist ein Zeichen (in etwa ein String mit Länge 1), also zum Beispiel 'A'.

[Der Jan]

Zitat von rowkajjh:

Eigentlich müßte doch die Konvertierung char -> double problemlos sein, oder? ...
Häh?

Ne leider nicht. Nimm "Byte". Char ist im Gegensatz zu C kein Integer-Typ. Pascal ist halt ganz schön gewöhnungsbedürftig, wenn man von C/C++ kommt. Ging mir auch so