Object dynamisch in einem Array erzeufen

[gangs-taas]

soo ich hab dann jetzt noch einmal ein paar frage :

1) OOP beduetet doch, dass ich die einzellnen Procedures und Properties "fest in ein objekt binde, so dass sie nach außen gekapselt erscheinen und nicht manipuliert werden können" (sinngemäß nach wikipedia)
ich versteh nicht warum ihr meint, dass die Array nicht OOP seien. Schließlich verwaltet das Array doch nur OBJEKTE (=> es gibt objekte => oop)
Was ist daran jetzt so falsch ? oder was hab ich noch nicht verstanden ?

2) zu dem code von shmia :
du schreibst, du würdest die Komponenten erzeugen und in die Liste packen
aber ich sehe einfach nicht, warum deine mehtode jetzt unbedigt so viel einfacher oder so wäre ...


lg

[Sir Rufo]

OOP fängt bei Delphi mit TObject an und baut sich darauf auf
Keine Arrays (das war damals) sondern TList (kommt von TObject) oder von TList abgeleitet.

Ein Großer Vorteil von OOP ist die Vererbung und das geht bei Array nicht

[David Martens]

Also ich finde Templates nicht schwierig.

Im Bezug auf mein voriges Posting:

- das erste Listing 1 zu 1 übernehmen
- der zweite Listing ist das Objekt das in der Liste gespeichert werden, ein ganz normales Objekt. Das hat nichts mit dem Template zu tun.
- das dritte Listing macht jetzt den Trick, dazu kann man einfach mein Listing nehmen und an den entscheidenden Stellen ändern. (Bei uses die Unit angeben und beim 1. type die Klasse angeben, ab dem 2. type KANN der Name der Liste geändert werden.)

Benutzung wie normales TList mit Typisierung.

Delphi-Quellcode:

  ObjectX := TObjectX.Create(...);
  ObjectXList := TObjectXList.Create(...);

  ObjectX.blabla := ....
  ...

  ObjectXList.Add(Object);

  ...
  ...

  ObjectXList.Items[i].blaba.....   (und nicht TObjectX(ObjectXList.Items[i]).blaba) oder
  ObjectXList[i].blaba.....         (und nicht TObjectX(ObjectXList[i]).blaba)

Hat den entscheidenden Vorteil, daß in der Liste immer Objekte vom gewünschten Typ sind und keine Fehler produziert wenn ein falsches typecasting (weil nicht nötig :-D) gemacht wird.

[shmia]

zu 1.)
Arrays sind relativ primitive Datentypen.
Das heisst jetzt nicht das an Arrays irgendetwas schlecht wäre;
es ist nur so, dass es Bausteine (Klassen und Objekte) auf höherer (Abstraktions-)Ebene gibt,
mit denen man bestimmte Dinge einfacher, besser und verständlicher lösen kann.

Man könnte eine Rangfolge (von primitiv bis abstrakt) der Datentypen aufstellen
1) char, integer, double, cardinal,...
2) array mit festen Grenzen, Aufzählungstypen
3) dynamische Arrays, Strings, Mengen
4) Records, Listen
5) Klassen
6) Templates
7) Zusammenarbeit mehrerer Klassen / Designpattern
OOP spielt sich hauptsächlich bei 5),6) und 7) ab.


zu 2.)
* ist dir aufgefallen, dass du Komponenten ganz einfach in "FMyList" packen kannst?

Delphi-Quellcode:

// Label erzeugen und an "FMyList" anhängen
lbl := TLabel.Create(FMyList {<== hier});

Einfacher geht's ja wohl nicht.
Dadurch das du FMylist als sogannten Owner (Besitzer) im Create angegeben hast,
landet das neue Label in FMyList.
* ist dir aufgefallen, dass du dir keinerlei Gedanken machen musst,
auf welcher Position das Label, Editfeld gespeichert wird?
Bei einem Array müsstest du a.) immer aufpassen dass das Array groß genug ist und b.)
immer mitzählen.
* ist dir aufgefallen, dass du deine Komponenten nirgends freigeben musst?
Weil FMyList dem Formular gehört wird FMyList und alles was darunter hängt AUTOMATISCH freigegeben.
Bei einen Array müsstest du in einer Schleife über alle Objekte gehen und jedes einzeln freigeben.

[stahli]

Um Deine Objekte nur in einer Liste zu speichern kannst Du im Grunde beides nutzen (ist quasi Geschmackssache).
Mit einer TList oder TObjectList ist es aber insgesamt komfortabler.

Arrays würde ich nur bei sehr kleinen Mengen oder im Gegenteil bei größeren, mehrdimensionalen Mengen nutzen.

Wenn eine Sammlung von Objekten gespeichert werden, bietet sich eine TObjectList ideal an.
Das geht so weit, dass beim Löschen eines Objekts aus der Liste dieses auch automatisch freigegeben werden kann.

...

Vielleicht verwirrt Dich das o.g. Beispiel der geschätzten Kollegen :wink: mit dem "FMyList" etwas... (könnte ich mir zumindest vorstellen).
"FMyList" ist von der Klasse TComponent.
Diese verwaltet wiederum intern eine Liste von allen Komponenten, die ihr untergeordnet sind.
Auf diese könnte man z.B. in einer Schleife auch zugreifen z.B. durch

Delphi-Quellcode:

  I: Integer;
  C: TComponent;
begin
  for I := 0 to MyList.ComponentCount - 1 do
  begin
    C := MyList.Components[I];
    C.TuWas;
  end;
end;

Du kannst jedoch auch eine "richtige" TList oder TObjectObjectList verwenden und dann direkt damit arbeiten.

Die Beizeichnung "FMyList" ist also vielleicht etwas verwirrend, da ja keine TList benutzt wird.

[gangs-taas]

hey,
noch einmal vielen dank für eure vielen antworten.
Leider muss ich zugeben, dass ich bei der Hälfte nur Bahnhof versteh.

z.B. was Templates sind versteh ich nicht wirklich. Bzw. nicht ihren nutzen
auf der einzigen deutschen Internetseite (diei ch gefunden hab) steht zu Templates : [QUOTE = http://www.dummzeuch.de/delphi/objec...tsch.html]Dies ist eine Klasse mit einem Array, die beim Zugriff ueberprueft, ob der Index innerhalb der Arraygrenzen liegt.[/QUOTE]
okay heißt ein Template hilft also bei einem Array keine Elemente anzusprechen, die nich existieren.

kann ich nicht einfach überprüfen, ob das Array Element existiert und fertig ?

von dem Code den David Martens auf der ersten seite gepostet hat versteh ich ehrlich gesagt fast nichts.

So dann habt ihr von der ObjectList gesprochen. Das hinzufügen sieht ja ganz einfach aus, aber ich finde wenn ich ein Elemt ansprechen will und dafür jedesmal

Delphi-Quellcode:

TKlasse(ObjectList.last).methode;

schreiben muss, ist das ganze irg. umständlich.

Das was David Martens geschriebne hat :

Zitat:

Zitat von David Martens (Beitrag 1055642)

Delphi-Quellcode:

  ObjectX := TObjectX.Create(...);
  ObjectXList := TObjectXList.Create(...);

  ObjectX.blabla := ....
  ...

  ObjectXList.Add(Object);

  ...
  ...

  ObjectXList.Items[i].blaba.....   (und nicht TObjectX(ObjectXList.Items[i]).blaba) oder
  ObjectXList[i].blaba.....         (und nicht TObjectX(ObjectXList[i]).blaba)

sieht ja wieder relativ einfach aus, aber wenn sich das immer noch auf Templates bezieht fürchte ich, dass ich damit nicht sonderlich viel machen kann, da ich die irg. nicht verstanden hab

Die Internetseite Link spricht davon, dass man TObjectList's so typisieren kann, dass man Elemente ähnlich Wie David M. das macht ansprechen kann.
Leider steht da auch nur ein haufen Code und keine Erklärung und ich versteh nicht wikrlich was sie wieso machen ...

[Jens01]

@David Martens
Ich wollt hier mal kurz in die Diskussion springen und sagen, dass dies Objectlist-Template eigentlich sehr gut funktioniert. :thumb:
Es sieht zwar etwas ungewöhnlich aus, da man dies Templete 2x geteilt in die Unit einfügen muß, ansonsten spart es viel Platz/ Code.
Ein Nachteil habe ich aber ausgemacht, man kann dies Template nur einmal in eine Unit einfügen. Wenn man mehrere Listen -der Code ist jetzt ja schön kurz- in einer Unit verarbeiten will, funktioniert das nicht -jedenfalls bei mir-.

Gruss Jens

[Sir Rufo]

Zitat:

Zitat von gangs-taas (Beitrag 1055648)

... was Tamplates sind versteh ich nicht wirklich

nur so am Rande es heißt Templates

Zitat:

Zitat von gangs-taas (Beitrag 1055648)

okay heißt ein Tamplate hilft also bei einem Array keine Elemente anzusprechen, die nich existieren.

Nein, das ist nur ein Beispiel wie man Templates verwenden kann

Zitat:

Zitat von gangs-taas (Beitrag 1055648)

So dann habt ihr von der ObjectList gesprochen. Das hinzufügen sieht ja ganz einfach aus, aber ich finde wenn ich ein Elemt ansprechen will und dafür jedesmal

Delphi-Quellcode:

TKlasse(ObjectList.last).methode;

schreiben muss, ist das ganze irg. umständlich.

Dafür nimmt man das Template von David Martens denn dann entfällt dieses umfudeln (nennt man Typecast)
Ohne Templates muss man halt den Typecast machen

Wenn du ein neueres Delphi hast (ab D2009) dann gibt es die Generics und da geht das dann ganz einfach

Delphi-Quellcode:

Type
  TFoo = class
   Data : string;
  end;

  TFooList = TObjectList<TFoo>;

Dieser Code ab D2009 bringt im Ergebnis den gleichen Effekt wie das Template von David Martens

[Chemiker]

Hallo,

die TList, TObectlist usw. arbeitet aber intern auch mit einem Pointer-Array.

Bis bald Chemiker

[stahli]

Also der arme gangs-taas tut mir leid.
Er wollte doch nur wissen, was sich für den Einstieg am einfachsten anwenden lässt...