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

[STaRDoGGCHaMP]

Hallo,
Folgendes Problem : Ich habe zwei Arrays (String-Arrays, jeweils 52 Indizes) und muss nun jedem Glied manuell einen Wert zuweisen. Geht das auch anders als:

Delphi-Quellcode:

array1[1] := "xxx";
array1[2] := "xxx";
array1[3] := "xxx";

irgendsowas wie

Delphi-Quellcode:

array1 := {"xxx", "xxx", "xxx"}

[DeddyH]

Nimm doch eine Schleife.

[STaRDoGGCHaMP]

Eine Schleife bringt mir recht wenig, da die Strings die in das Array sollen nicht mathematisch oder in irgend einer Art und weise zusammenhängen (es ist jetz nicht das Alphabet oder so, da wäre ja z.b. chr() hilfreich)

[Sven M.]

Dann bleibt dir wohl tatsächlich nur die manuelle Zuweisung...

[STaRDoGGCHaMP]

Okay, vielen Dank für die Antwort :mrgreen:
Ist ja auch kein Problem, sieht halt nur ein wenig komisch aus^^. Aber wenns anders nicht geht kann man nix machen, danke nochmals.

[Frankfurtoder]

Ich wollte mal darauf hinweisen das bei diesem Code:

Delphi-Quellcode:

array1[1] := "xxx";
array1[2] := "xxx";
array1[3] := "xxx";

Der Eindruck entsteht als wolltest du das Array immer mit dem selben Inhalt füllen (hier "xxx"). Zum besseren Verständnis auch hier im Beispiel dann bitte verschiedene Werte benutzen wie zB abc, mno, xyz. So wird deutlich das es sich um verschiedene Werte handelt.

Grüße

[bernau]

Kannst folgende procedure verwenden.

Delphi-Quellcode:

procedure AssignStringArrayValues(var aStringArrayTarget: array of string;aStringArraySource: array of string);
var
  lTargetIndex:Integer;
  lSourceIndex:Integer;
begin
  lTargetIndex:=Low(aStringArrayTarget);
  lSourceIndex:=Low(aStringArraySource);

  while (lTargetIndex<=high(aStringArrayTarget)) and
        (lSourceIndex<=high(aStringArraySource)) do
    begin
       aStringArrayTarget[lTargetIndex]:=aStringArraySource[lSourceIndex];
       Inc(lTargetIndex);
       Inc(lSourceIndex);
    end;
end;

Dann kannst du so die Daten zuweisen

Delphi-Quellcode:

var
  myArray:array[3..5] of string;
begin
  AssignStringArrayValues(myArray,['asdasd','asdasd']);
end;

Ungetestet.

[Neutral General]

Hi bernau

Ich glaube den Code kann man noch extrem vereinfachen:

Delphi-Quellcode:

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


var arr: Array[3..7] of String;
begin
  FillArray(arr,['Hallo','Welt','!','DelphiPraxis','!']);
end;

Aber gute Idee! :) :thumb:
Auf die Idee wäre ich nicht gekommen. Mich ärgert das z.T. auch :?

Gruß
Neutral General

[bernau]

Zitat:

Zitat von Neutral General

Ich glaube den Code kann man noch extrem vereinfachen:

Ja bestimmt. Ich hatte es aber nur so runtergeschrieben. War mir aber nicht sicher, ob der index von myArray in der procedure nun mit 3 anfängt oder mit 0. Ist ja z.B. mit [3..5] deklariert. Deshalb habe ich jedem array einen eigenen index zugewiesen und jeweils geprüft, ob dieser sich im Wertebereich befindet.

Bis denne.

[bernau]

Zitat:

Zitat von Neutral General

Delphi-Quellcode:

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

Helf mir mal. Vieleicht habe ich ja einen Gedankenfehler aber hierbei werden doch nur die Zeiger der Strings kopiert.

1) Was ist, wenn Dest schon gefüllt ist. Die Pointer werden doch einfach überschrieben. Leckt da der Speicher nicht etwas.

2) Du weist Pointer von Source zu, die nach Ablauf der Procedure gar nicht mehr gültig sind.

[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:

[Hawkeye219]

Hallo,

bei der Initialisierung von dynamischen Arrays unterstützt das BDS auch die folgende Notation:

Delphi-Quellcode:

type
  TDynStringArray = array of string;
var
  DynamicArray : TDynStringArray;
begin
  DynamicArray := TDynStringArray.Create('A', 'B', 'C', 'D');
end;

Wenn die Initialisierung wirklich im Code durchgeführt werden muss, dann kann die genannte Variante unter Umständen zu einem etwas kompakteren Quelltext führen.

Gruß Hawkeye

[Neutral General]

Zitat:

Zitat von Hawkeye219

bei der Initialisierung von dynamischen Arrays unterstützt das BDS auch die folgende Notation:

:shock: :freak: