Syntax-Frage: Einem Array mehrere Werte "aufeinmal" zuweisen

[Sherlock]

Da passiert mit Zeigern gar nichts. Dest und Source sind doch im Header der procedure als Arrays deklariert.
Aufgedröselt bedeutet

Delphi-Quellcode:

  Move(Source[Low(Source)],Dest[Low(Dest)],Length(Dest)*4);

nichts anderes als:
Verschiebe vom ersten Element des Arrays Source an, alle seine Elemente in das Array Dest, aber nur maximal so viele wie in Dest reinpassen. Und da ist glaub ich noch ein Problem, denn wenn in Source weniger ist als in Dest rein passt, wird unvorhersehbares als weiteres Arrayelement zugeordnet.

Sherlock

[Neutral General]

Hi,

1) Da hast du recht :?
2) Dachte ich auch, aber scheinbar ist das nicht der Fall.

Folgendes funktioniert:

Delphi-Quellcode:

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    arr: Array[3..7] of String;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure FillArray(var Dest: Array of String; Source: Array of String);
begin
  Move(Source[Low(Source)],Dest[Low(Dest)],Length(Dest)*4);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  FillArray(arr,['Hallo','Welt','!','DelphiPraxis','!']);
end;

procedure TForm1.Button2Click(Sender: TObject);
var i: Integer;
begin
  for i:= low(arr) to high(arr) do
    ShowMessage(arr[i]);
end;

Wegen 1) werd ich mal gucken...

@Sherlock

Zitat:

Da passiert mit Zeigern gar nichts.

Doch, es werden nur die Pointer auf die eigentlichen Strings von Array zu Array kopiert ;)

Zitat:

Verschiebe vom ersten Element des Arrays Source an, alle seine Elemente in das Array Dest, aber nur maximal so viele wie in Dest reinpassen.

Richtig.

Zitat:

Und da ist glaub ich noch ein Problem, denn wenn in Source weniger ist als in Dest rein passt, wird unvorhersehbares als weiteres Arrayelement zugeordnet.

Dieser Teil des Arrays wird dann gar nicht angerührt. Von daher kein Problem.

[Apollonius]

Mit konstanten Strings funktioniert das, da der Referenzzähler dort immer auf -1 steht. Trotzdem sollte man es lieber sauber machen.

[Sherlock]

Hmmm...ich seh das mit den Pointern nicht.
Aus der OH:

Zitat:

procedure Move(const Source; var Dest; Count: Integer);
Move kopiert Count Bytes vom Speicherblock Source in den Block Dest. Bei der Operation wird keine Bereichsprüfung durchgeführt. Überlappungen zwischen Quell- und Zielblock werden automatisch ausgeglichen.

Die Anzahl der zu kopierenden Bytes sollte aus Sicherheitsgründen mit der globalen Funktion SizeOf (Delphi) bzw. dem Operator sizeof (C++) ermittelt werden.

Und in Deinem Code zeigst Du move, wo es anfangen soll, wo es hin soll etc.
In dieser Hinsicht sind vielleicht Source[Low(Source)] und Dest[Low(Dest)] als Zeiger zu werten. Aber kopiert wir doch der Inhalt des Arrays Source.

Aber... :gruebel:

Sherlock

[Apollonius]

Das Array enthält Ansistrings, welche Zeiger sind. Dabei wird der Referenzzähler nicht erhöht.

[Uwe Raabe]

Zitat:

Zitat von Apollonius

Das Array enthält Ansistrings, welche Zeiger sind. Dabei wird der Referenzzähler nicht erhöht.

Deswegen ist das

Delphi-Quellcode:

  procedure FillArray(var Dest: array of string; const Source: array of string);
  var
    I: Integer;
  begin
    for I := 0 to Min(Length(source), Length(Dest)) - 1 do
      Dest[I] := Source[I];
  end;

auch die sauberste Methode.

[Neutral General]

Zitat:

Zitat von Uwe Raabe

Deswegen ist das auch die sauberste Methode.

Mhh.. Wo er Recht hat, hat er Recht :mrgreen:

[bernau]

Zitat:

Zitat von Apollonius

Mit konstanten Strings funktioniert das, da der Referenzzähler dort immer auf -1 steht.

Problem wird auch sein, wenn folgendes passiert:

Delphi-Quellcode:

  FillArray(arr,['Hallo','Welt','!','DelphiPraxis','!']); 

  arr[4]:='bla';

Das Array erhält mit "FillArray" die Zeiger der Konstanten. Dann wird mit dem Zweiten Befehl in den Speicher der Konstanten geschrieben. Übel.

[bernau]

Zitat:

Zitat von Uwe Raabe

Delphi-Quellcode:

  procedure FillArray(var Dest: array of string; const Source: array of string);
  var
    I: Integer;
  begin
    for I := 0 to Min(Length(source), Length(Dest)) - 1 do
      Dest[I] := Source[I];
  end;

auch die sauberste Methode.

Das ist tatsächlich die eleganteste Lösung.

Zugelernt habe ich, daß der Anfang eines Array in der Procedure immer mit 0 beginnt, obwohl das übergebende Array einen ganz anderen Indexbereich hat. z.B. von 4 bis 8.

[Neutral General]

Zitat:

Zitat von bernau

Das Array erhält mit "FillArray" die Zeiger der Konstanten. Dann wird mit dem Zweiten Befehl in den Speicher der Konstanten geschrieben. Übel.

Ich kenn mich da nicht 100%ig aus, aber es sind ja keine echten Konstanten. Von daher denke ich, dass es da keinen Unterschied zu "normalen" Variablen gibt. Kann mich aber auch täuschen :mrgreen: