Stack-Grund-Klasse

[Corelgott]

Hi @ all,

ich habe mal ein kleine frage zu stacks... bzw. zu so watt in der art:
Habe das hier mal gebastelt.. funzt auch ast rein

Code:

unit untClientStack;

interface

Type TICQClientData = record
    UIN : Integer;
    Name: String;
end;

type TICQContactList = class
    published
        constructor create();
    private
        myData : array of TICQClientData;
        myCount : integer;
    public
        procedure push(item : TICQClientData);
        procedure pop(indx : integer);

        property count : integer read myCount;
        property data[indx : integer] : TICQClientData read myData;
end;

implementation

constructor TICQContactList.create();
begin
    inherited create();
    myCount := 0;
    setlength(myData, 0);
end;

procedure TICQContactList.push(item : TICQClientData);
begin
    setlength(data, myCount + 1);
    data[myCount] := item;
    inc(myCount);
end;

procedure TICQContactList.pop(indx : integer);
var
    i : integer;
begin
    for i := myCount - 1 downto indx + 1 do
        myData[i - 1] := data[i];
    setlength(data, myCount);
    dec(myCount);
end;


end.

So das teil verwaltet ja datensätze vom typ TICQClientData...
Ich brauche aber genau das gleiche teil nochmal für ne anderen datentyp...

Also wie muss ne vernünftige grundklasse aussehen, damit ich das anständlich vererben kann.. und ich möglichst nur den typ ändere...

Hatte schon überleget ob mal da so was wie nen varaint typen einpuzzel könnte....
Aber was ist hier am geschicktesten, schönsten und ordentlichsten??

ps.: das mit dem pop muss so noch nicht funzten... da habe ich aber auch nicht groß drüber nachgedacht ^^

cya & thx
Corelgott

[shmia]

In der Unit contnrs gibt es die Klasse TObjectStack.
Diese Klasse ist von TStack abgeleitet.
Du kannst nun ebenfalls von TStack ableiten oder änderst deine Records in Klassen und nimmst
TObjectStack.
Ich würde die 2. Variante empfehlen.
Mit zunehmendem Funktionsumfang merkst du immer deutlicher, dass TICQClientData besser ein Klasse
sein sollte.

[Corelgott]

hmm ok... thx das ist echt ne sehr code-sparende variante... ^^
*geil*

ich habe da nur noch ne kleine denkblockade...
Also nu habe ich:

Code:

type TICQClientData = object
    UIN : Integer;
    Name: String;
end;

tmp : TICQClientData;
contacts : TObjectStack;

procedure foo()
begin
    contacts.push(tmp)
end;

wie muss da der type-cast aussehen?
bzw. habe ich das teil eigeltlich gerade so benutzt wie du das meintest?

thx
Corelgott

[Dax]

Nimm statt object(ist veraltet) mal class(TObject), dann sollte es funktionieren.

Und zum Typecasten: Du musst nur Typecasten (hier auf TICQClientData), wenn du Objekte vom Stack abrufst. Weil der Stack alle TObjects und deren Nachfahren akzeptiert, musst du beim Pushen nicht Casten.

[Corelgott]

Perfekt... Nu funzt datt ^^

THX an euch beide!!

cya
Corelgott

[Corelgott]

ouch ich depp!

Ich habe gerade nen logischen Fehler bei mir entdeckt...
Ein Stack speichert ja nur pointer auf die daten? Oder?
Ich bräuchte aber eher ne art verketteste liste.. Etwas was die daten komplett hält und nciht nur pointer auf die selbigen...

Also eher ein dynamisches array...
Gibts da auch ne delphi klasse die die arbeit abmimmt? (Weil push & pop ist ja recht praktisch ^^)
Oder muss ich das dann doch per hand machen??

Corelgott

[shmia]

Zitat von Corelgott:

Ich habe gerade nen logischen Fehler bei mir entdeckt...
Ein Stack speichert ja nur pointer auf die daten? Oder?
Ich bräuchte aber eher ne art verketteste liste.. Etwas was die daten komplett hält und nciht nur pointer auf die selbigen...

Na, des basst scho. Du musst aber auf das Erzeugen und Zerstören der Objekte achten:

Delphi-Quellcode:

type TICQClientData = class(TObject)
   public
    UIN : Integer; 
    Name: String;
end; 

contacts : TObjectStack; 

procedure foo;
var
   tmp : TICQClientData; 
begin 
   tmp := TICQClientData.Create;  // erzeugen
   // befüllen
   tmp.Name := 'DP';
   tmp.UIN :='3456345646';
   // und ab auf den Stack
   contacts.push(tmp) 
end;

procedure popey; 
var
   tmp : TICQClientData; 
begin
   tmp := contacts.Pop as TICQClientData; // vom Stack runter

   // vor dem "Tod" noch benachrichtigen
   SendMessageTo(tmp.UIN, 'You are killed now!'); 
   // Object zerstören
   tmp.Free;
end;

Du kannst deine ICQClientData Objekte auch in einer TObjectList halten;
kommt immer drauf an, was du vorhast.

[Corelgott]

insgesammt habe ich das vor:
ne XML-Datei auslesen... Sie im Stack ab zu legen
und dann in ein tree zu pusten....

Code:

    for i := 0 to clientNodes.count - 1 do
    begin
        client.UIN := strToInt(clientNodes[i].AttributeNodes['uin'].Text);
        client.Name := clientNodes[i].AttributeNodes['name'].Text;
        clients.push(client);
    end;

und das ist auch das prob.. die var client die ich pushe... ist immer die selbe... blos der inhalt ändert sich..
Ist ja auch klar! ist ja nur ein objekt, dass nach und nach unterschiedliche werte durchläuft...

wenn der da nur nen pointer rein packt... Oo
Hab ich pech gehabt!
deswegen hatte ich das auch urgsprünglich als record...
Ich vermute immer mehr und mehr, dass ich den begriff Stack falsch benutzt habe...

cya
Corelgott

:edit

die lösung dafür wäre dann recht einfach:

Code:

        client := TICQClientData.create();
        client.UIN := strToInt(clientNodes[i].AttributeNodes['uin'].Text);
        client.Name := clientNodes[i].AttributeNodes['name'].Text;
        clients.push(client);

Einfach ne ganze menge instanzen...
Der nachteil ist aber dennoch, das ich die liste dann nur einmal ausgeben kann...
Weil danach ist sie ja weg-ge-popt... ^^

Corelgott