Zeiger auf array

[Martin K]

Hi, hab mal wieder ein Problem:

Ich habe mir zwei statische Arrays gebastelt und einen Pointer, der auf eines der beiden Arrays zeigen soll.

Delphi-Quellcode:

var
  Palette4: array[0..15]  of TColor;
  Palette8: array[0..255] of TColor;
  Palette:  PByteArray;

Wahrscheinlich habe ich meinen Pointer falsch deklariert oder so, aber auf jeden Fall kommt das bei raus:

Ich lasse also meinen Pointer auf eines der beiden Arrays zeigen:

Delphi-Quellcode:

  Palette := @Palette4;

Bei High(Palette) müsste dann (zumindest nach meiner Logik) 15 raus kommen, ich erhalte aber 32768.

Woran kann das liegen?
Wie muss ich meine Deklaration ggf. ändern?
:gruebel:

[Hawkeye219]

Hallo Martin,

so sieht die Deklaration von PByteArray in der Unit SysUtils aus:

Delphi-Quellcode:

PByteArray = ^TByteArray;
TByteArray = array[0..32767] of Byte;

High(Palette^) muß somit den Wert 32767 liefern.

Die Obergrenzen der Arrays kannst du ja über High(Palette4) bzw. High(Palette8) abfragen, mit einer gemeinsamen Typvereinbarung wirst du wohl scheitern.
Vielleicht hilft dir eine Prozedur mit einem "open array"-Parameter:

Delphi-Quellcode:

procedure MachWas (const aColors: array of TColor);
begin
  ShowMessage (IntToStr(High(aColors)));
end;

MachWas (Palette4);  // zeigt "15" an
MachWas (Palette8);  // zeigt "255" an

Gruß Hawkeye

[Martin K]

Hm...

Gibt es keinen allgemeinen Pointer, mit dem man auf ein Array zeigen kann?

Also ich würde gerne überall im Code einfach nur Palette:= usw. schreiben.
Und je nachdem, auf welches der beiden arrays dann der Pointer zeigt (lege ich ganz am Anfang fest, z.B. bei FormCreate), dieses array soll halt auch verwendet werden...

Zitat:

Zitat von Hawkeye219

High(Palette^) muß somit den Wert 32767

Ja, stimmt so wars auch.
Hatte den Code nur nicht mehr ganz genau im Kopf...

[nat]

was spricht gegen dynamische arrays? damit würde es gehen!

Delphi-Quellcode:

type
  TColorArray = array of TColor;
  PColorArray = ^TColorArray;

var
  Palette4: TColorArray;
  Palette8: TColorArray;
  Palette: PColorArray;

procedure TForm1.FormCreate(Sender: TObject);
begin
  setlength(Palette4, 16);
  setlength(Palette8, 256);

  Palette := @Palette4;
end;

[Martin K]

Ach, damit geht das?

Hm...
Aber warum geht das mit dem Zeiger auf ein Array nur bei dynamischen und nicht bei statischen?
...das ist doch unlogisch!

Naja gut, dann nehm ich eben zwei dynamische Arrays.
Danke, übrigens!!!

Hier geht es halt um Farbpaletten (4 Bit und 8 Bit) und da die Anzahl der Farben in der Palette konstant ist (16 bzw. 256 Farben), wären hier statische Arrays irgendwie logischer...

Aber egal...

[himitsu]

Zitat:

Zitat von Martin K

Aber warum geht das mit dem Zeiger auf ein Array nur bei dynamischen und nicht bei statischen?
...das ist doch unlogisch!

Also einen Zeiger auf ein Array kannst du bei dynamischen und statischen Arrays anlegen.

Du mußt nur beachten, das in dynamisches Array auch eigentlich nur ein Zeiger auf seine Daten ist.

[mkinzler]

Zitat:

Du mußt nur beachten, das in dynamisches Array auch eigentlich nur ein Zeiger auf seine Daten ist.

Ein "normaler" array m.W. auch

[himitsu]

Zitat:

Zitat von mkinzler

Ein "normaler" array m.W. auch

Wenn "normal" bei dir statisch ( also Array[x..y] ) bedeutet ... NEIN.

Ein Array[0..3] of Byte ist zozusagen ein Record mit 4 Bytes drin,

wärend ein Array of Byte ein Pointer auf eine Array-Struktur ist, welche in sich wiederum ein Record mit Integern für ElementCount (Length) und Referenzzähler, mit einem dahinterliegendem Record der nötigen Bytes.

Delphi-Quellcode:

Var D: Array of Word
  S: Array[0..9] of Word;

SizeOf(D) = 4 (der Pointer ist ja ein Integer, also 4 Byte)
SizeOf(S) = 20 (10 * Word, also 20 Byte)

[Martin K]

Zitat:

Zitat von himitsu

Zitat:

Zitat von Martin K

Aber warum geht das mit dem Zeiger auf ein Array nur bei dynamischen und nicht bei statischen?
...das ist doch unlogisch!

Also einen Zeiger auf ein Array kannst du bei dynamischen und statischen Arrays anlegen.

Du mußt nur beachten, das in dynamisches Array auch eigentlich nur ein Zeiger auf seine Daten ist.

Ja und wie kann ich das realisieren:
Ein Zeiger auf ein statisches Array ?
:gruebel:

//Edit:
für etwas Quellcode wäre ich dankbar...

[Dax]

Zitat:

Zitat von Martin K

Ja und wie kann ich das realisieren:
Ein Zeiger auf ein statisches Array ?

Hast du in deinem ersten Post doch schon vorgemacht^^

[Martin K]

Zitat:

Zitat von Dax

Zitat:

Zitat von Martin K

Ja und wie kann ich das realisieren:
Ein Zeiger auf ein statisches Array ?

Hast du in deinem ersten Post doch schon vorgemacht^^

Ja natürlich, aber da hatte ich doch das Problem, dass die Länge des Arrays nicht richtig war.
Der Höchstwert bei meinem Pointer auf das Array war immer 32767, obwohl das Original-Array (auf das mein Pointer zeigt) viel kürzer war (der Höchstwert war 15).

Wie kann ich also einen "richtigen Pointer" auf ein statisches Array machen, bei dem auch die Länge mit der des Original-Arrays übereinstimmt?

Mit PByteArray (erster Post) ging es ja nicht...

[himitsu]

Das mit der Länge liegt doch daran, daß in einem statischen Array keine Länge gespeichert wird, also es ist da unmöglich die Länge rauszubekommen.

Schau doch einfach mal in den generierten ASM-Code rein ... bei den Statischen Arrays wird LENGTH und HIGH nicht über eine Funktion ermittelt, sondern der Wert ist hardgecodet.


Entweder du nimmst 'nen Record, wo die Länge mit eingetragen wird, oder halt dynamische Arrays, welche ja eine Längenangebe mit integriert haben.

Beispiel für die Recordvariante:

Delphi-Quellcode:

Palette4 = packed Record
  Len: Integer;
  Data: Array[0..15] of Irgendwas;
End;
Palette4 = packed Record
  Len: Integer;
  Data: Array[0..255] of Irgendwas;
End;

dann mußt du halt einfach Len ganz am Anfang auf 16/256 setzen.

Dann kannst du damit über einen Pointer auf alles zugreifen

Delphi-Quellcode:

PaletteX = packed Record
  Len: Integer;
  Data: Array[0..255] of Irgendwas;  // für 255 mindestendens den größtmöglichen Wert
End;
PPaletteX = ^PaletteX;

[Martin K]

Ja, ok das hätte ich mir so auch selber basteln können.

Nö, ich nehm dann einfach zwei dynamische Arrays.
Dann brauch ich ja am Anfang einfach nur:

Delphi-Quellcode:

SetLength(Palette4, 16);
SetLength(Palette8, 256);

zu setzen.

Zitat:

Zitat von himitsu

Das mit der Länge liegt doch daran, daß in einem statischen Array keine Länge gespeichert wird, also es ist da unmöglich die Länge rauszubekommen.

Komisch:

Delphi-Quellcode:

var test: array[0..15] of Irgendwas;
{...}
ShowMessage( IntToStr(Length(test)) ); <-- hier bekomme ich '16' angezeigt!!!

Das funzt!!!

Nur bei einem Pointer auf das Array klappts nicht mehr...

[Khabarakh]

Zitat:

Zitat:

Zitat von himitsu

Das mit der Länge liegt doch daran, daß in einem statischen Array keine Länge gespeichert wird, also es ist da unmöglich die Länge rauszubekommen.

Komisch:
[...]

Öhm... Lies dir bitte mal himitsus zweiten Abschnitt und nicht nur den ersten durch.

[Martin K]

Den hier?

Zitat:

Zitat von himitsu

Schau doch einfach mal in den generierten ASM-Code rein ... bei den Statischen Arrays wird LENGTH und HIGH nicht über eine Funktion ermittelt, sondern der Wert ist hardgecodet.

Was heißt denn 'hardgecodet' :oops: ?

[Khabarakh]

Stimmt, wenn dann muss es schon "hartgecodet" heißen ;) .
"Hartgecodet" bedeutet, dass der Compiler deinen Length-Aufruf einfach statisch durch die obere Grenze des Arrays ersetzt. Bei Pointern kann er das schlecht machen, da dort ja diese Grenze dynamisch ist.

[Martin K]

Egal ob obere Grenze (High) oder Länge (Length) einens Array.
Das geht also beides nicht bei Pointern auf ein statisches Array sondern nur beim Aufruf des Arrays selbst???

[himitsu]

genau, denn woher sollte er denn wissen wie lang das Array ist, auf das der Pointer zeigt ... im statischen Array jedenfalls wird nirgends die Länge gespeichert.

Das geht höchstens, wenn du den Pointer auf ein bestimmtes Array setzt:

Delphi-Quellcode:

Type A = Array[0..15] of Irgendwas; 
  P = ^A;

Aber dann zeigt Length(P^) immer das an, auf was das Array A eingestellt ist und nicht das, auf was P wirklich zeigt.