Hallo alle zusammen!
Nach ganz langer Zeit habe ich mich dazu entschieden, wieder mal etwas in Delphi zu schreiben und hab als Fingerübung mit einem rekursiven Mergesort angefangen. Nun will allerdings Delphi nicht so wie ich. Zum Testen habe ich ein kleines Beispiel gemacht um zu überprüfen, ob das in dem speziellen Fall so ist oder ob ich das generell falsch implementiere. Der Output ist konsequent 'Inkompatible Typen'.
Die SuFu habe ich bereits ausgiebig genutzt, ebenso Google und Konsorten. Jede Erklärung erscheint mir schlüssig und ich habe es genauso gemacht, wie die Fehlerbehebung beschrieben wird, aber der Fehler taucht dennoch auf.

Bitte erbarmet euch, ihr Delphi-Coder, und helft einem Delphi-Anfänger


Hier einmal der Quellcode:
(Ja, er ist nicht hübsch und auch nicht gut benannt et cetera - es war auch nur eine schnelle Anwendung um zu überprüfen, ob es an mir liegt oder an Delphi. Ich schätze mal es liegt an mir und ich habe irgendeinen Hinweis im Forum dazu überlesen.)

zusammenfalten · markieren

Delphi-Quellcode:

type
  TArray = array of integer;

procedure TForm1.Button1Click(Sender: TObject);
var
  dan,stan: array of integer;
  k: integer;
begin
  SetLength(dan,ListBox1.Items.Capacity);
  SetLength(stan,ListBox1.Items.Capacity);
  for k:=0 to ListBox1.Items.Capacity-1 do
    dan[k] := StrToInt(ListBox1.Items[k]);
  stan := up(dan);
  for k:=0 to ListBox1.Items.Capacity-1 do
    ListBox2.Items.Add(IntToStr(stan[k]));
end;

function TForm1.up(i: array of integer):TArray;
var
  k: integer;
begin
  for k:=0 to High(i)-1 do
    Result[k] := 2*i[k];
end;

Du hast doch schon den richtigen Ansatz:
Du musst alle array vom Typ TArraY haben, dann sollte es gehen, oder?

Zitat von WM_CLOSE:

Du hast doch schon den richtigen Ansatz:
Du musst alle array vom Typ TArra haben, dann sollte es gehen, oder?

Oh ._. auf einmal funktioniert es

Aber im eigentlichen Programm macht das Probleme:

zusammenfalten · markieren

Delphi-Quellcode:

procedure Tsortalgo.MergeSortRun;
var
  i: integer;
begin
  SetLength(mlist,1);
  mlist[0] := 0;
  for i := 0 to elements-1 do
    begin
      SetLength(mlist, High(mlist));
      mlist[i] := StrToInt(ListBox_List.Items[i]);
    end;
  mlist := MergeSort(mlist);
end;

function Tsortalgo.Merge(llst, rlst: TArray): TArray;
var
  n: integer;
begin
  SetLength(result,elements);
  n := 0;
  while (High(llst)>0) and (High(rlst)>0) do
    begin
      if llst[0] <= rlst[0]
        then
          begin
            result[n] := llst[0];
            n := n+1;
            llst := RemoveItem(llst, 0);
          end
        else
          begin
            result[n] := rlst[0];
            n := n+1;
            rlst := RemoveItem(rlst, 0);
          end;
    end;
  while High(llst)>0 do
    begin
      result[n] := llst[0];
      n := n+1;
      llst := RemoveItem(llst, 0);
    end;
  while High(rlst)>0 do
    begin
      result[n] := rlst[0];
      n := n+1;
      rlst := RemoveItem(rlst, 0);
    end;
end;

function Tsortalgo.MergeSort(lst: TArray): TArray;
var
  q, i: integer;
  llst, rlst: TArray;
begin
  if High(lst) <= 1
    then
      result := lst
    else
      begin
        q := High(lst);
        for i := 0 to round(q/2) do
          begin
            llst[i] := lst[i];
          end;
        for i := round(q/2) to q do
          begin
            rlst[i] := lst[i];
          end;
      end;
  llst := MergeSort(llst);
  rlst := MergeSort(rlst);
  result := Merge(llst, rlst);
end;

function Tsortalgo.RemoveItem(lst: TArray; n: integer): TArray;
var
  i: integer;
begin
  for i := n to High(lst) do
    begin
      lst[i] := lst[i+1];
    end;
  SetLength(lst, High(lst)-1);
end;

Da spuckt er mir am Ende ein "Exception EAccessViolation". Hab ich vielleicht irgendwo eine Grenze zu hoch gesetzt?

Nein, das nicht nicht der gleiche Typ .... nichtmal ein ähnlicher.

array of ... direkt als Parameter angegeben ist ein Open-Array-Typ und hat nichts mit dem normalen Typ zu tun.

Typen müssen meist sogar identisch und nicht nur gleich sein.



So, ansonsten liebe ich es, wenn man ständig vergißt die Fehlerposition mit anzugeben.
stan := up(dan); .
Das Problem ist hier z.B. nicht der Parameter "dan", sondern das Result.
> hier wird nämlich garantiert nicht "dan" markiert, sondern ")"

ein Open-Array-Parameter ist, wie der Name schon sagt, offen für Vieles, also auch "ähnliche" Typen oder gar direkte Konstanten ala stan := up([123, 456, 789]); .

Das Result muß aber identisch sein, daß hier die Inhalte direkt zugewiesen werden.

Dein einziger Deklarationsfehler war also

markieren

Delphi-Quellcode:

var
  dan,stan: array of integer; {TArray}

PS: TIntegerDynArray (da identisch oft nötig ist, machen sich solche Standardtypen besser)



PPS: Es ist zwar toll, daß mal jemand Code-Tags nutzt, aber wie wäre es mit einem Delphi-Tag?
[delphi]...[/delphi] (der rot-goldne Helm)
Vielleicht kannst'e das ja noch editieren



Und zum Rest:
Tut mir Leid ... wieder nicht gesagt WO der Fehler auftritt und ich hab keine Lust zu suchen.

Tipp:
- Debuggen ist was Tolles
- schalte mal in den Projektoptionen die Bereichs- und Überlaufprüfungen an

Zitat von himitsu:

Nein, das nicht nicht der gleiche Typ .... nichtmal ein ähnlicher.

Ah, dann liegt der Fehler schonmal klar auf der Hand, ist klar, warum das nicht so will.

Zitat:

So, ansonsten liebe ich es, wenn man ständig vergißt die Fehlerposition mit anzugeben.
stan := up(dan); .
Das Problem ist hier z.B. nicht der Parameter "dan", sondern das Result.
> hier wird nämlich garantiert nicht "dan" markiert, sondern ")"

ein Open-Array-Parameter ist, wie der Name schon sagt, offen für Vieles, also auch "ähnliche" Typen oder gar direkte Konstanten ala stan := up([123, 456, 789]); .

Das Result muß aber identisch sein, daß hier die Inhalte direkt zugewiesen werden.

Dein einziger Deklarationsfehler war also

markieren

Delphi-Quellcode:

var
  dan,stan: array of integer; {TArray}

PS: TIntegerDynArray (da identisch oft nötig ist, machen sich solche Standardtypen besser)

Ok, den werde ich gleich mal implementieren statt meinem eigenen Gedudel. Und das mit der Fehlerstelle tut mir leid - Ich habe selbst schon lange nicht mehr in Foren ums Programmieren geschrieben, weil mir dafür einfach die Zeit fehlt. Ebenso wie für das Programmieren (leider).

Zitat:

PPS: Es ist zwar toll, daß mal jemand Code-Tags nutzt, aber wie wäre es mit einem Delphi-Tag?
[delphi]...[/delphi] (der rot-goldne Helm)
Vielleicht kannst'e das ja noch editieren

Wurde sofort geändert

Zitat:

Und zum Rest:
Tut mir Leid ... wieder nicht gesagt WO der Fehler auftritt und ich hab keine Lust zu suchen.

Tipp:
- Debuggen ist was Tolles
- schalte mal in den Projektoptionen die Bereichs- und Überlaufprüfungen an

Ich denke mal, der Fehler wird sich gleich auftun, wenn ich die korrekten Typen benutze - auch wenn ich hoffe, dass der Rest richtig ist
Der Debugger von Borlands Delphi hatte mir nicht mehr ausgegeben als die Meldung, dass es inkompatible Typen sind.
Vielen Dank auf jedenfall schonmal für die Hilfe - wenn ich weiter bin werde ich das reineditieren.

Sorry für den Doppelpost, allerdings kann ich den obigen nicht mehr editieren.

Also, nun sind die Typen alle gleich (Ich verwende jetzt den IntegerDynArray) und das dividen der Listen funktioniert super. Nun geht es allerdings auf den essentiellen Teil des Mergens zu und da meckert er schon wieder. An den zwei markierten Stellen im Code gibt er mir einen ERangeError, bzw. einen Fehler bei der Bereichsüberprüfung, aus.
Da an den markiertenn Stellen aber nur eine procedure aufgerufen wird, die ein Element löscht, indem es die anderen Elemente über der Liste herunterzieht und die Listenlänge um eins verkleinert, verstehe ich den Fehler nicht so ganz. Bei der Procedure habe ich die Bereiche schon mehrmals überprüft.
Was ich auch überlegt hatte wäre, ob die Listen dann vielleicht schon leer sind und er dennoch ein Element entfernen will - aber das kann ich wegen der while-Schleife drumherum ausschließen.

Ich hoffe, hier könnt mir nochmal helfen^^

zusammenfalten · markieren

Delphi-Quellcode:

function Tsortalgo.Merge(llst, rlst: TIntegerDynArray): TIntegerDynArray;
var
  n: integer;
  lst: TIntegerDynArray;
begin
  SetLength(lst,High(llst)+High(rlst));
  n := 0;
  while (High(llst)>=0) and (High(rlst)>=0) do
    begin
      if llst[0] <= rlst[0]
        then
          begin
            lst[n] := llst[0];
            n := n+1;
            llst := RemoveItem(llst, 0); <--- Fehler
          end
        else
          begin
            lst[n] := rlst[0];
            n := n+1;
            rlst := RemoveItem(rlst, 0); <--- Fehler
          end;
    end;
  while High(llst)>0 do
    begin
      lst[n] := llst[0];
      n := n+1;
      llst := RemoveItem(llst, 0);
    end;
  while High(rlst)>0 do
    begin
      lst[n] := rlst[0];
      n := n+1;
      rlst := RemoveItem(rlst, 0);
    end;
  result := lst;
end;

function Tsortalgo.RemoveItem(lst: TIntegerDynArray; n: integer): TIntegerDynArray;
var
  i: integer;
begin
  for i := n to High(lst)-1 do
    begin
      lst[i] := lst[i+1];
    end;
  SetLength(lst, High(lst)-1);
  result := lst;
end;

Wo in der Funktion RemoveItem tritt der Fehler auf?
Übergebe besser Low(<array>) statt 0

Das ist es ja - in RemoveItem tritt gar kein Fehler auf sondern in der Merge-Routine, wo RemoveItem auftreten soll. Das mit Low() versuche ich mal.

Danke schonmal^^

Hier würde sich vielleicht auch eine Liste statt einem Array anbieten

Listen wollte ich ursprünglich auch nutzen, allerdings kommen diese nur mit Pointern aus - zumindest weiß ich nicht, wie ich das Objekt Liste mit Integern verwenden soll. Bei Suchen im Internet und zB auf delphi-treff.de und ähnlichen gab es immer nur die Variante, eine Liste als Pointer-Liste zu verwenden (Vielleicht habe ich auch irgendwas übersehen - lasse mich gerne belehren^^).