TObjectList prüfen ob Index exitstiert

[Alexander Roth]

Hi,

also ich habe eine Objekt list und erstelle da Objekte rein. Die Indizes der Objekte sind aber nicht in einer bestimmten Reihenfolge sondern sie haben durchaus Lücken (also 5, 8,9,10,12). So wie kann ich prüfen ob ein Element mit einem bestimmten Index schon vorhanden ist?

So klappt es jedenfalls nicht: :? (beste ist vom Typ TObjectList, schritte hat hier den Wert 1 und anscheinend ist der index 1 noch nicht vergeben.)

Delphi-Quellcode:

if  beste.Items[schritte]=nil then

Da meldet er den Fehler:

Zitat:

---------------------------
Benachrichtigung über Debugger-Exception
---------------------------
Im Projekt ReaktioneXX.exe ist eine Exception der Klasse EListError aufgetreten. Meldung: 'Listenindex überschreitet das Maximum (1)'. Prozess wurde angehalten. Mit Einzelne Anweisung oder Start fortsetzen.
---------------------------
OK Hilfe
---------------------------

[Der_Unwissende]

HI,
wie genau fügst du denn etwas in die Liste ein, so dass dort Lücken entstehen können? Eigentlich ist der Sinn der TObjectList ja gerade, dass man Lücken vermeidet.

Gruß Der Unwissende

[Edit]Zu der Fehlermeldung:
Nicht vergeben ist schon irgendwie richtig, aber es gibt dann auch kein Element an einer Stelle > 0, liegt nicht daran dass du hier eine Lücke hast. Prüfen kannst du dass auch ganz leicht

Delphi-Quellcode:

if schritte < beste.Count then
begin
  if  beste.Items[schritte]=nil then
  ....
end
else
begin
  // ups, so viele Elemente hast du noch gar nicht eingefügt, 
  // natürlich darf Schritte auch nicht kleiner 0 werden
end;

[alcaeus]

Moin,

wenn du 5 Elemente in der Liste hast, dann sind die Indize 0-4. Wenn du in der Mitte ein Element rausnimmst, dann geht der Rest einfach "nach vorne", d.h. du hast nie Luecken in der Liste. Pruefen kannst du es also so (ich gehe davon aus, dass auch "schritt" 0-basiert ist:

Delphi-Quellcode:

if (schritt >= 0) and (schritt < liste.count)

Die zweite Pruefung ist, ob du ueberhaupt ein Objekt da drin stehn hast. Nur weil der Index da ist, heisst noch lange nicht dass dort das drinsteht, was du erwartest. Ich kann ja auch einen Integer auf TObject casten und den reinschreiben; bei einem Objektzugriff auf dieses Element wuerde es dann dementsprechend krachen, genauso bei nil. Das hat aber nichts damit zu tun, ob der Index da ist ;)

Greetz
alcaeus

[Alexander Roth]

Hi,

ja das war mein Fehler :wall: ,dass es garkeine Lücken geben kann.

Eigentlich schade. :(

Danke für eure Hilfe.


Wisst ihr vielleicht irgendein Objekt, dass so ähnlich wie Tobjectlist arbeitet, aber Lücken zulässt? Das wäre nämlich richtig praktisch :?:

[alcaeus]

:gruebel: Wozu brauchst du Luecken?

Und sonst: array of TObject; ;)

Greetz
alcaeus

[Alexander Roth]

Zitat:

Zitat von alcaeus

:gruebel: Wozu brauchst du Luecken?

Also, ich habe bestimme Elemente und die müssen in Kategorien von zahlen eingeordnet werden:
Also eigentlich will ich eine Klasse erstellen. In der sind mehrere Rubriken, die durch eine Zahl zugänglich sind.
Diese Rubriken enthalten ein array.

Ich habe natürlich ein paar Ideen um das zu verwirklichen. Aber meistens ist eine schlechter als die andere.
Eine Idee ist: Ich erstelle eine Klasse, darin ist ein 2-d array; eine set of byte; und ein paar procedures und properties.
Dann werde ich die Elemente in dem Set of mit den Elementen im array verknüpfen. Und so eine nach aussen hin lückenhafte Arrays erstellen.

Ich hatte gehofft eine TobjectList nimmt mir diese Arbeit ab. Aber das ist ja genau das gleiche wie ein array.

:hi: Tschüss :hi:

[Hawkeye219]

Hallo,

wo steht, daß eine TObjectList keine Lücken zuläßt?

Delphi-Quellcode:

List := TObjectList.Create;

List.Add (TObject.Create);
List.Add (TObject.Create);
List.Add (TObject.Create);
List.Add (TObject.Create);
List.Add (TObject.Create);
Count := List.Count;  // Count=5

List[3] := NIL;
Count := List.Count;  // Count=5

List.Pack;
Count := List.Count;  // Count=4

List.Free;

Gruß Hawkeye

[Der_Unwissende]

Zitat:

Zitat von Hawkeye219

Hallo,

wo steht, daß eine TObjectList keine Lücken zuläßt?

Das steht nirgendwo, aber es macht keinen Sinn. Steht die Anzahl der Elemente fest (oder ändert sich nur selten) lohnt sich wohl eher der Einsatz eines dynamischen Arrays. Wenn man mit einer Liste arbeitet dann sicherlich nicht um die mit Lücken zu füllen um über einen Index wahlfrei zugreifen zu können (oder wo liegt der Unterschied zu Arrays?)

Aber ja, möglich ist es

[pszopp]

Zitat:

Zitat von Der_Unwissende

Steht die Anzahl der Elemente fest (oder ändert sich nur selten) lohnt sich wohl eher der Einsatz eines dynamischen Arrays.

Weißt du denn ob sich die Anzahl der Elemente bei "Alexander Roth"s Vorhaben selten ändert?!?
Wenn sich die Anzahl oft ändert ist die ObjectList doch besser :-D

Gruß,
pszopp

[Der_Unwissende]

Gut, angenommen die Anzahl der Elemente ändert sich häufig, wie genau möchte ich denn dann einen direkten Zugriff auf einen Index ermöglichen?
Einfachste Möglichkeit, ich lege ein Array an, dass von Anfang an sehr groß gewählt wird. Ok, jetzt können wir über die Speicherverschwendung reden, die liegt dann bei 4 Byte pro unbenutztem Feld, dass mein dyn. Array zu groß wäre, dürfte in den meisten Fällen also nur ein paar kByte max. ausmachen (zu vernachlässigen).
Was macht nun eine TObjectList intern? Natürlich genau das gleiche, nur dass diese sich halt selbst um ihre Vergrößerung/Verkleinerung kümmert.

Wenn ich aber auf einen beliebigen Index zugreifen will, ist es einfacher das per Hand und dyn. Arrays zu machen.

Wenn sich die Anzahl der Elemente stark ändert (überhaupt nichts zum Anfang hin fest steht, so eignen sich nebenbei bemekrt Bäume deutlich besser)

[Hawkeye219]

Hallo,

der große Vorteil der TObjectList liegt wohl in erster Linie darin, daß sie sich auch um die Freigabe der enthaltenen Objekte kümmern kann. Eventuelle Lücken lassen sich durch einen einfachen Aufruf der Methode Pack wieder schließen. Bei einem dynamischen Array muß ich als Programmierer darauf achten, alle Objekte freizugeben. Das Entfernen von NIL-Zeigern ist hier deutlich aufwendiger.
Ob Alexander für die Lösung seines Problems nun ein Array oder ein Listenobjekt nimmt, muß er selbst entscheiden. Offensichtlich ist die Unterstützung von NIL-Zeigern für ihn wichtig. Durch alcaeus' Post konnte aber der Eindruck entstehen, daß TObjectList keine Lücken zuläßt. Dies wollte ich durch meinen vorigen Beitrag richtigstellen.

Gruß Hawkeye

[alcaeus]

TObjectList laesst keine Luecken zu, glaub mir. Machen wir mal so was:

Delphi-Quellcode:

var
  MyList: TObjectList;
  MyObject: TObject;
begin
  MyList := TObjectList.Create();
  MyList.Add(TObject.Create());
  MyList.Add(TObject.Create());
  MyList.Add(TObject.Create());
  MyList.Add(TObject.Create());
  MyList.Add(TObject.Create());
  
  // Nun setzen wir das Element mit dem Index 1 auf NIL
  MyList.Items[1] := nil;
  
  // Und jetzt sehen wir uns mal den Inhalt davon an:
  MyObject := MyList.Items[1];
  
  MyList.Free();
end;

Und, kommt beim Zugriff auf MyList.Items[1] eine AV? Nein: Das Element mit dem Index 1 existiert; es ist aber 0. Das heisst, dass dort keine Luecke ist, es steht nur eben Schwachsinn in der Liste. Du kannst Elemente, die nil sind, als Luecken betrachten, es sind aber nicht wirklich Luecken, schliesslich kannst du auch direkt aufs Element zugreifen. Wenn der Index nicht existieren wuerde, dann waers ne Luecke, aber so nicht ;)

Das ist jetzt allerdings Wortklauberei ;)

Greetz
alcaeus

[Alexander Roth]

Hi, also erstmal riesen Dank für eure Hilfe :!:

Besonders der Code ist sehr aufschlussreich. Habe noch ein bisschen rumexperimentiert und habe mich noch nicht entschieden, da array und TobjectList sehr sehr ähnlich sind.
Der wichtigste Punkt war mit ja dass man über einen festgelegten Index (mit Lücken) darauf zugreifen kann und dass glaube ich kriege ich nur hin indem ich es dann wahrscheinlich so wie oben beschrieben mache. (wenn mir nix besseres einfällt)


Danke für eure Hilfe :!: :!: :!:

:hi: Tschüss (fahre jetzt auf Kursfahrt nach Italien Toskana :dancer: )

[Hawkeye219]

Zitat:

Zitat von alcaeus

Du kannst Elemente, die nil sind, als Luecken betrachten

Genau das war meine Definition von "Lücke". Natürlich sind bei einer Liste mit 10 Elementen alle Plätze vorhanden. Einige können eben den Wert NIL enthalten.

Zitat:

Zitat von alcaeus

Wenn du in der Mitte ein Element rausnimmst, dann geht der Rest einfach "nach vorne", d.h. du hast nie Luecken in der Liste.

Diesen Satz habe ich wegen meiner Definition von "Lücke" offensichtlich falsch verstanden. Ich dachte nämlich, du wärest von einem automatischen Packen der Liste (also dem Entfernen der NIL-Zeiger) in allen Fällen ausgegangen. Dies geschieht ja nur beim Aufruf der Methode Delete, nicht aber beim Setzen einzelner Listenelemente auf den Wert NIL.

Jetzt sollten aber alle Klarheiten beseitigt sein :wink:

Gruß Hawkeye