Array an procedure übergeben

[Igotcha]

Hallo zusammen,

folgendes Problem:

Ich habe ein dynamisches Array der Form

Delphi-Quellcode:

type EKarte = record
    name: string;
    ort: integer;
    status: integer;
end;

mit

P1EKarte, P2EKarte: Array of Ekarte; und einem späteren

SetLength(P1EKarte,20).

Jetzt möchte ich das Array mischen und mir dazu eine Prozedur "mischen" schreiben, die von 0 bis High(P1EKarte) läuft und die Einträge von 0 bis zum Ende mit einem zufälligen Eintrag vertauscht. Dazu benötige ich aber ein Dummyrecord vom Typ EKarte als Zwischenspeicher.

Folgendes funktioniert schon mal nicht

Delphi-Quellcode:

procedure MixECards(PECards: Array of EKarte);
var
  CDummy: EKarte;
  ix: integer;
begin
    For ix:=0 to High(PECards) do
    begin
    CDummy:=Copy(PECards, ix, 1);
    end;
end;

Das Mischen selbst ist noch nicht implementiert, da ich hier bereits schon mit inkompatiblen Typen zu kämpfen habe.

Gruß Kay

[edit=sakura] [delphi]-Tags gesetzt. Mfg, sakura[/edit]

[choose]

Hallo Igotcha,

die Erklärung für dieses Phänomens sowie eine brauchbare Lösung solltest Du in dem Thread array of String als Result einer Funktion finden.

[Sanchez]

Zitat von Igotcha:

procedure MixECards(PECards: Array of EKarte);
var
CDummy: EKarte;
ix: integer;
begin
For ix:=0 to High(PECards) do
begin
CDummy:=Copy(PECards, ix, 1);
end;
end;

Das Mischen selbst ist noch nicht implementiert, da ich hier bereits schon mit inkompatiblen Typen zu kämpfen habe.

Die inkompatiblen Typen bekommst du aber beim Copy.
Willst du einfach die EKarte am Index ix in CDummy kopieren?

Wenn ja dann so:

  CDummy := PECards[ix]; grüße, daniel

[Igotcha]

Ja, beim Copy, stimmt.

CDummy := PECards[ix] funktioniert aber grundsätzlich.

Ich habe aber noch einen völlig anderen Denkfehler drin Das Array wird so natürlich in der Procedure schön gemischt, aber mein Input-Array nicht.

Ich benötige also folgendes:

Code:

GemischtesArray:=MixECards(UngemischtesArray);

oder

Code:

P1EKarte:=MixEcards(P1EKarte);

Wobei ein

Code:

P2EKarte:=MixEcards(P2EKarte) natürlich auch funktionieren sollte.

Das bekomme ich aber auch nicht so recht hin...

Gruß Kay

[himitsu]

Meinst du das so etwa ?

Delphi-Quellcode:

Type EKarte = Record
    name: String;
    ort: Integer;
    status: Integer;
  End;
  AEKarte = Array of EKarte;

Var P1EKarte: AEKarte;

Procedure MixECards(Var PECards: AEKarte);
  Var CDummy: EKarte;
    ix, p1, p2: Integer;

  Begin
    //For ix := 0 to High(PECards) do
    //  CDummy := PECards[ix];
    For ix := 0 to 10000 do Begin
      p1 := Random(High(PECards)); //zu tauschende Karten ermitteln
      p2 := Random(High(PECards));
      CDummy := PECards[p1];       //Karten tauschen
      PECards[p1] := PECards[p2]
      PECards[p2] := CDummy;
    End;
  End;


...
MixECards(P1EKarte);

[Igotcha]

Ich versuche es mal etwas ausführlicher:

Gegeben ist

Code:

Type EKarte = Record
    name: String;
    ort: Integer;
    status: Integer;
  End;

Davon gibt es nun für die beiden Spieler

Code:

var
   P1Ekarte, P2EKarte: Array of Ekarte

Diese beiden Arrays werden nun mit den Karten der Spieler geladen. Da es ist keine festgesetzte Anzahl von Karten gibt, wurde ein dynamisches Array verwendet (beim Laden wird mit Setlength jeweils die Endgröße der Arrays P1EKarte und P2EKarte bestimmt.

Jetzt soll eine Funktion / Prozedur existieren, die die gefüllten Arrays "mischt". Nach dem Mischen sollen in den beiden Arrays jeweils die ursprünglichen Karten vorhanden sein, nur gemischt.

Gesucht ist also ein Funktion / Prozedur "MixECards" in der Form:

Code:

P1EKarte (gemischt) :=MixECards(P1Ekarte (ungemischt));

die sich dann auch als

Code:

P2EKarte (gemischt) :=MixECards(P2Ekarte (ungemischt));

benutzen lassen sollte.

Wie schon geschrieben, ein Mischen innerhalb der Prozedur habe ich hinbekommen, nur blieb da mein Input-Array unverändert.

Code:

procedure MixECards(PECards: Array of EKarte); 
begin
     ...
end;

Bei einem MixEcards(P1EKarte) wurde praktisch "PECards" innerhalb der Prozedur gemischt, aber nicht "P1EKarte" als Ergebnis.

Gruß Kay

[choose]

In dem Thread, auf den ich in meinem vorherigen Posting verwiesen habe, würdest Du etwas in der Art

Delphi-Quellcode:

type
  TMyArray = array of TMyType;

function MyFunc(const AParam: TMyArray): TMyArray;
begin
  SetLength(Result, Length(AParam));
  //...
end;

//...
  AnArray:= MyFunc(AnotherArray);

finden...

[himitsu]

Also dann so ?

Delphi-Quellcode:

Type EKarte = Record
    name: String;
    ort: Integer;
    status: Integer;
  End;
  AEKarte = Array of EKarte;

Var P1Ekarte, P2EKarte: AEKarte;

Procedure MixECards(Var PECards: AEKarte);
  Var CDummy: EKarte;
    ix, p1, p2: Integer;

  Begin
    For ix := 0 to 10000 do Begin {je mehr Durchgänge, desto mehr wird gemischt}
      //2 Karten durch Zufall auswählen, die getauscht werden sollen
      p1 := Random(High(PECards));
      p2 := Random(High(PECards));
      //die Beiden ermittelten Karten austauschen
      CDummy := PECards[p1];
      PECards[p1] := PECards[p2];
      PECards[p2] := CDummy;
    End;
  End;

IrgendeineProzedur/Funkktion;
  Begin
    ...
    {hier sind die Karten noch ungemischt}
    MixECards(P1EKarte);
    MixECards(P2EKarte);
    {und hier sind sie gemischt}
    ...
  End;

Sowas ist doch nicht nötig:

Delphi-Quellcode:

Function MixECards(PECards: AEKarte): AEKarte;
  ...


P1EKarte := MixECards(P1EKarte);
P2EKarte := MixECards(P2EKarte);

Es geht doch so viel einfacher:

Delphi-Quellcode:

Procedure MixECards(Var PECards: AEKarte);
  ...


MixECards(P1EKarte);
MixECards(P2EKarte);

Die Angabe von VAR in der Parameterdeklaration der Prozedur gibt an, dass der übergebene Parameter geändert werden kann, daher ist auch der Umweg über ein zweites Array nicht nötig.

[Igotcha]

Zitat von choose:

type EDummy = array of EDummy; natürlich

und das habe ich geändert in

Delphi-Quellcode:

function MixECards(const AParam: EDummy): EDummy;

function MixECards(Var AParam: EDummy): EDummy;

Oh Mann, schwere Geburt, aber keine Typenfehler mehr

Vielen Dank Euch und ein frohes Fest...

Gruß Kay

[choose]

Bitte ändere zunächst Deine Bezeichnungen. Typen, die mit einem großen "E" beginnen, haben in Delphi eine besondere Bedeutung...

Das Problem besteht erneut in den unterschiedlichen Typen TKarteArray (vormals EDummy) versus array of TKarte (vormals EKarte). Ändere einfach die Deklaration von P1EKarte entsprechend ab und es sollte funktionieren (abgesehen davon, dass Dir die Funktion MixCards (vormals MixECards) zwar ein Array der passenden größe allerdings mit nicht belegten Daten zurückgibt...).