Pointer auf Array

[Nic2012]

Möchte in einer TQueue (D7) items vom typ [array of bytes] verwalten, einfügen über

Code:

queue.push(item@)

und auslesen über

Code:

item := queue.Pop^

, was zu einer Fehlermeldung führt: "Inkompatible Typen: 'Array' und 'procedure, untyped pointer or untyped parameter'"

ich stehe etwas auf dem Schlauch, wie muss ich hier typisieren bzw. casten ?

[p80286]

Was führt den zu der Fehlermeldung?
Die erste oder die zweite Zeile?
Übrigens würde ich an Deiner Stelle abstand von "Item" nehmen, das könnte u.U. Irritationen und Mißverständnisse hervorrufen.

und wenn Du einen Pointer brauchst dann solltest Du das so

Delphi-Quellcode:

MyPointer:=@MyData;

machen.

Gruß
K-H

[DeddyH]

Ungetestet (hab hier kein Delphi 7):

Delphi-Quellcode:

type
  TMyData = Datentyp;

...

var Data: TMyData;

queue.push(@Data);

Data := TMyData(queue.pop)^;

[ASM]

Zitat:

Zitat von DeddyH (Beitrag 1165547)

Ungetestet (hab hier kein Delphi 7):

Delphi-Quellcode:

type
  TMyData = Datentyp;

...

var Data: TMyData;

queue.push(@Data);

Data := TMyData(queue.pop)^;

Leider so nicht ganz richtig.
Muss richtig heißen:

Code:

Data := TMyData(queue.pop^);

[DeddyH]

Du hast natürlich recht, ich hatte erst noch einen PMyData-Typen deklariert und verwendet, den aber wieder rausgeworfen, ohne das ^ zu verschieben :oops:

[Nic2012]

Alles klar, danke.

[Blup]

Variablen vom Typ eines dynamischen Arrays sind bereits Pointer.

Zwei wichtige Sachen müssen beachtet werden:
- Jedes dynamische Array hat einen Referenzzähler, fällt dieser auf 0 werden die Daten des Arrays freigegeben.
- Der Inhalt des Arrays kann nachräglich verändert werden. Weisen mehrere Pointer oder Variablen auf das selbe Array, verändern sich die Daten für alle.

Delphi-Quellcode:

uses
  Types, Contnrs;

procedure PushByteDynArray(AQueue: TQueue; const AValue: TByteDynArray);
procedure PopByteDynArray(AQueue: TQueue; var AValue: TByteDynArray);

implementation

procedure PushByteDynArray(AQueue: TQueue; const AValue: TByteDynArray);
var
  p: Pointer;
begin
  {wichtig, Delphi versucht bei der Zuweisung eines anderen dyn. Arrays
   den Referenzzähler des bisher zugewiesenen dyn. Arrays zu verringern}
  p := nil;

  {eindeutige Kopie erzeugen und Referenzzähler auf 1 setzen}
  TByteDynArray(p) := Copy(AValue);

  AQueue.Push(p);
end;

procedure PopByteDynArray(AQueue: TQueue; var AValue: TByteDynArray);
begin
  {für den bisherigen Inhalt Referenzzähler -1 , eventuell freigeben}
  AValue := nil;
  {der Cast verhindert die Referenzzählung}
  Pointer(AValue) := AQueue.Pop;
end;

[Medium]

Alternativ ließe sich auch noch eine Klasse um den Arraytypen bauen, die dann dafür sorgt, dass der RefCounter nicht versickert.

Delphi-Quellcode:

type
  TByteArray = array of Byte;
  TMyArrayContainer = class
  private
    FData: TByteArray;
    function GetValue(index: Integer): Byte;
    procedure SetValue(index: Integer; Value: Byte);
    function GetLength: Integer
    procedure SetLength(Value: Integer);
  public
    property Data: TByteArray read FData write FData;
    property Value[index: Integer]: Byte read GetValue write SetValue; default;
    property Length: Integer read GetLength write SetLength;
  end;

function TMyArrayContainer.GetValue(index: Integer): Byte;
begin
  if (index<Low(FData)) or (index>High(FData)) then
    raise EIndexOutOfBoundsException.Create
  else
    result := FData[index];
end;

procedure TMyArrayContainer.SetValue(index: Integer; Value: Byte);
begin
  if (index<Low(FData)) or (index>High(FData)) then
    raise EIndexOutOfBoundsException.Create
  else
    FData[index] := Value;
end;

procedure TMyArrayContainer.SetLength(Value: Integer);
begin
  SetLength(FData, Value);
end;

function TMyArrayContainer.GetLength: Integer;
begin
  result := Length(FData);
end;

Das noch mit Generics gibt einen ziemlich netten OOP-mäßigen Wrapper, der auch insgesamt das Handling etwas aufhübscht wie ich finde.