Teile einer beliebeigen Array lückenlos löschen

[Konny]

Hallo Leute,
Ich wollte mir für mein Programm mal eine kleine procedure schreiben, mit der ich aus jeder Array an einer beliebigen Stelle etwas rauslöschen kann. Es funktioniert auch fast, nur irgendwie kommt die Meldung Inkompatible Typen in der letzten Zeile. Kann mir jemand sagen, was ich falsch gemacht habe?
Vorher sei noch gesagt:
1. Ja, meine Formatierung ist....ähem...sagen wir unpraktisch....
2. Ich weiß, dass vielleicht schon jemand so einen Algorhythmus zur Perfektion gebracht hat und man sich diesen runterladen kann, mir gings aber ums Prinzip :P

Also hier der Quelltext:

Delphi-Quellcode:

procedure CutArray(Start,Finish:integer; var Arr:array of TObject);
var
a1:word;
begin
 if Start>Finish then Change(Start,Finish); //Change tauscht einfach die beiden Zahlen
 for a1:=Finish to High(Arr) do Arr[Start+a1]:=Arr[Finish+a1];
 SetLength(Arr, High(Arr)-(Finish-Start)+1);
end;

Ich hoffe, jemand von euch kann mir helfen, Danke im Vorraus! :)

[Medium]

Ich vermute ganz stark, dass SetLength() nicht mit der offenen Array-Deklaration kann. (Meistens wird Array übrigens als Neutrum gesehen.)

Grund: Du könntest deine Funktion mit diesem Parameter theoretisch so aufrufen:

Delphi-Quellcode:

CutArray(1, 3, [SomeObject, SomeOtherObject, HappyObject, FrustratedObject, SillyObject, TooManyObjects]);

Nur wohin würde die Änderung dann übergeben werden?

Ich vermute, dass die Lösung folgendermaßen aussehen dürfte (mangels IDE nicht zu testen gerade hier):

Delphi-Quellcode:

type
  TObjectArray = array of TObject;

.
.
.
procedure CutArray(Start, Finish: Integer; var Arr: TObjectArray);
...

Allerdings wundert es mich etwas, dass Delphi nicht schon dabei meckert, wenn ein offener Array-Parameter als "var" deklariert wird. Weil schon das macht, wegen der o.g. Aufrufmöglichkeit, eigentlich ein Problem. Ich hätte dort schon den Compiler stoppen vermutet, nicht erst bei dem SetLength(), dem es ja eigentlich egal sein kann ob jetzt var oder nicht var oder offen oder begrenzt. Etwas seltsam. Sonst sehe ich aber erstmal keinen Fehler in der Zeile, aber ich gucke eh nur noch aus Schlitzen. Junge, ist das spät!

(Pro-Tipp: Wenn du deinen Code in [delphi ] [/delphi ] Tags (ohne die Leerzeichen) einpackst, wird er besser lesbar. Vorausgesetzt natürlich er ist überhaupt formatiert - deiner sieht ja sogar in echt so aus :shock: (sieht man wenn man mit Zitat antwortet).)

Edit: Und du solltest unbedingt die Grenzen prüfen!! Sonst wirbelst du im Speicher mit dieser Funktion potenziell richtig was durcheinander, und sowas ist dann richtig hart zu finden. (Man könnte sogar negative Werte für Start und Finish angeben.)
Noch eine Kleinigkeit: Statt High(Arr)+1 könntest du auch Length(Arr) nehmen. Zumindest bei 0-basierten Arrays, die du mit dieser Deklaration ja zwangsweise hast.
(Und die Funktion Change() würde ich eher Exchange() nennen.)

[Jumpy]

- Ich fänd Switch() einen noch besseren Namen, aber ist halt geschmacksache.
- Auch sehe ich das wie Medium, dass du die Grenzen Start/Finish noch mehr prüfen musst, dass sie nicht z.B. ausserhalb der Array-Grenzen liegen.
- Und last but not least kann ich mir nicht vorstellen, dass das richtig ist, aber ich hatte heute auch noch keinen Kaffee:

Delphi-Quellcode:

for a1:=Finish to High(Arr) do Arr[Start+a1]:=Arr[Finish+a1];
//

Array 1 bis 10. Start 3. Finish 5.:
Schleife von 5 bis 10.
1 Durchlauf: a1=5 => Arr[3+5]=Arr[8]:=Arr[5+5]=Arr[10]
2 Durchlauf: a1=6 => Arr[3+6]=Arr[9]:=Arr[5+6]=Arr[11] !Out of Bounds!


Schleife müsste sowas sein wie
for a1:=1 to (High(Arr)-Finish)

[Jasocul]

Der Fehler dürfte die Funktion "High" sein.
Wenn ich mich richtig erinnere, gibt diese nicht die "Größe" des Arrays zurück, wenn das Array nicht als dynamisch erkannt wird, sondern den größten Inhalt anhand des Indexes.

Aber das ist wirklich nur aus dem Gedächtnis gekramt. Ich habe gerade kein Delphi zur Verfügung. Vielleicht kann ja mal Jemand in der DOH nachsehen.

[mkinzler]

Ja High() liefert den höchsten Index, Low() den niedrigsten, nicht die Anzahl der Elemente!

[Mavarik]

Zitat:

Zitat von Konny (Beitrag 1313364)

Delphi-Quellcode:

procedure CutArray(Start,Finish:integer; var Arr:array of TObject);
var
a1:word;
begin
 if Start>Finish then Change(Start,Finish); //Change tauscht einfach die beiden Zahlen
 for a1:=Finish to High(Arr) do Arr[Start+a1]:=Arr[Finish+a1];
 SetLength(Arr, High(Arr)-(Finish-Start)+1);
end;

Also

Delphi-Quellcode:

if Start>Finish then Change(Start,Finish);

Ich glaube das ist das letzte was ich abgetestet hätte... Dann schon eher die Arraygrenzen...

Klar kann man auch mit Start, Finish arbeiten aber ich hätte eher Start und Count genommen... Aber das ist Geschmacksache

Delphi-Quellcode:

for a1:=Finish to High(Arr) do 
  Arr[Start+a1]:=Arr[Finish+a1];

Starten bei Finish? das ist doch das letzte Element welches Du löschen willst...

Delphi-Quellcode:

Arr[Start+A1]:=

ist das Element das Anzahl(Start) Felder hinter deinem Finish liegt...

Delphi-Quellcode:

:= Arr[Finish+A1]

ist 2xFinish sicherlich auch nicht richtig.

Delphi-Quellcode:

 SetLength(Arr, High(Arr)-(Finish-Start)+1);

High ist das letzte Element was Du suchst ist

Delphi-Quellcode:

length(Arr)

Am besten löschen und nochmal nach einem Kaffee neu überlegen.

Du willst ja die Element nach vorne verschieben...

1 2 3 4 5 6 7 8 9
Cutarray(4,5,arr)
1 2 3 6 7 8 9

also must die 6 an die Stelle von 4, 7 an 5 usw.

Was ist aber mit
Curarray(2,8,arr)

Ich würde sagen, da muss noch ein If in die For-Schleife....

[Jumpy]

Es sollen ja alle Elemente ab Finish nach Start+ff verschoben werden. Die Schleife müsste um #3 zu konkretisieren demnach so sein galub ich:

Delphi-Quellcode:

for a1:=1 to (High(Arr)-Finish) do
  Arr[Start+a1-1]:=Arr[Finish+a1]; 
SetLength(Arr, Length(Arr)-(Finish-Start+1));

[Mavarik]

Zitat:

Zitat von Jumpy (Beitrag 1313411)

demnach so sein galub ich:

Und was lernen wir daraus? Auf jeden Fall der TE nix...