Hallo DP,

ich wollt ein Array so ansteuern:

markieren

Delphi-Quellcode:

s := '1,1';
arrayfeld[s] := 1;

Leider funktioniert das ja nicht. Gibt es vielleicht eine Möglichkeit das so zu realisieren.
Wäre nett, wenn ihr mir helfen könt.

assoziatives array

Über ein Array-Property läßt sich sowas selber erstellen.
Geht bei Objekten und seit D2006 auch in Records.
http://www.delphipraxis.net/132817-u...ler-e2506.html

Du könntest aber auch mal nach Hashmaps ausschau halten, da gibt's Welche mit String-Index.


PS: eine TStringList kann sowas auch

gibt es da nichts einfacheres??

Du könntest Dir einen Interpreter schreiben, der mit der Stringangabe etwas anfangen kann und dementsprechend das Array bearbeitet.

du meinst sowas?

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyArray = record
  private
    procedure readIndex(index: string; var x, y: integer);
    function getItem(index: string): integer;
    procedure setItem(index: string; value: integer);
  public
    arr: array[0..9] of array[0..9] of integer;
    property item[index: string] read getItem write setItem;
  end;

procedure TMyArray.readIndex(index: string; var x, y: integer);
var
  ex, ey: integer;
begin
  val(index, x, ex);
  val(copy(index, ex + 1), y, ey);
  if (ex = 0) or (index[ex] <> ',') or (ey <> 0)
      or (x < 0) or (x >= length(arr))
      or (y < 0) or (y >= length(arr[0])) then
    raise Exception.Create('invalid index');
end;

function TMyArray.getItem(index: string): integer;
var
  x, y: integer;
begin
  readIndex(index, x, y);
  result := arr[x, y];
end;

procedure TMyArray.setItem(index: string; value: integer);
var
  x, y: integer;
begin
  readIndex(index, x, y);
  arr[x, y] := value;
end;

und wehe es beschwert sich wer, daß meine Interpreter nicht genug oop und keine zigtausenden vererbungen enthalten

Hat sich erledigt, nur hab ich noch eine Frage.
Hab jetzt ein Dreidimensionales array (anderer Zweck). Kann ich das Array beim Programm überwachen???

ein array überwachen geht nicht direkt (gut, man könnte den Speicherblock über's windows mit einer exception absichern, welche bei einem Schreibzugriff ausgelöst wird. diese exception fängt man dann ab und hat so seine benachrichtigung.


einfach im Setter deiner Klasse, in welcher du dein Array kapselst, drauf reagieren.

Ich hät es halt so, dass ich dann ein Formular hab:
Wo ich die z-Koordinate einstell und dann hab ich drunter so ein Fenster:

markieren

Code:

1|0|0|1
0|1|1|0
1|0|0|1
0|1|1|0

so kann man alles beobachten x=1 y=1 ist unten links

Wie gesagt, in diesem Fall mußt du einfach nur in deinem Setter einen Callback einführen.

markieren

Delphi-Quellcode:

procedure TMyArray.MySetter(index: string; value: integer);
begin
  ...
  if assigned(fOnChange) then
    fOnChange(self);
end;

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyArray = class
  private
    fArr: array[0..9] of array[0..9] of array[0..9] of integer;
    fOnChange: TNotifyEvent;
    procedure readIndex(index: string; var x, y, z: integer);
    function getString(index: string): integer;
    procedure setString(index: string; value: integer);
    function getIndex (x, y, z: integer): integer;
    procedure setIndex (x, y, z: integer; value: integer);
  public
    property item[index: string]: integer read getString write setString; default;
    property item[x, y, z: integer]: integer read getIndex write setIndex; default;
    property onChange: TNotifyEvent read fOnChange write fOnChange;
  end;

procedure TMyArray.readIndex(index: string; var x, y, z: integer);
var
  ex, ey, ez: integer;
begin
  val(index, x, ex);
  val(copy(index, ex + 1), y, ey);
  val(copy(index, ey + 1), z, ez);
  if (ex = 0) or (index[ex] <> ',') or (ey <> 0)
      or (index[ey] <> ',') or (ez <> 0) then
    raise Exception.Create('invalid index string');
end;

{$IFOPT R+}
  {$DEFINE TMYARRAY_R}
{$ENDIF}

{$R+}

function TMyArray.getString(index: string): integer;
var
  x, y, z: integer;
begin
  readIndex(index, x, y, z);
  result := fArr[x, y, z];
end;

procedure TMyArray.setString(index: string; value: integer);
var
  x, y, z: integer;
begin
  readIndex(index, x, y, z);
  fArr[x, y, z] := value;
  if assigned(fOnChange) then
    fOnChange(self);
end;

function TMyArray.getIndex(x, y, z: integer): integer;
begin
  result := fArr[x, y, z];
end;

procedure TMyArray.setIndex(x, y, z: integer; value: integer);
begin
  fArr[x, y, z] := value;
  if assigned(fOnChange) then
    fOnChange(self);
end;

{$IFNDEF TMYARRAY_R}
  {$R-}
{$ENDIF}