Einen Keller in Delphi Programmieren

[Christian18]

Hallo,

ich möchte mir einen Keller programmieren. Die Keller, die ich bisher in der Programmiersprache JAVA entwickelt habe, hatten einen unabhänigen Datentyp. Meine Frage nun, gibt es den auch in Delphi? Oder muss ich für String, Integer, Float, Real, ... extra Keller programmieren.

Ich meine mich erinnern zu können, dass es in JAVA eine Art Element gab. Damit waren dann alle Datentypen abgedeckt. Sogar Objekte konnte man dann in diesen Keller speichern.

MfG Christian18

[mkinzler]

Such mal nach TStack

[Phoenix]

Ab Delphi 2009 gibt es Generika / Generische Datentypen.

Dort kannst Du einen Keller<T> implementieren. Damit kannst Du einen Keller<String> und ein Keller<TButton> deklarieren und dieser Keller lagert dann nur den angegebenen Typen ein. Mit Delphi-Versionen vor 2009 geht das nicht so elegant.

[Christian18]

Ok,

das ist ein fertiger Keller. Ich möchte bzw. soll ihn selber entwickeln. Zugriffsmethoden kenne ich, was diese tun sollen weiss ich auch. Ich bin nur noch auf der suche nach den richtigen Datentyp.

MfG Christian18

[mkinzler]

Datentyp für was? :gruebel:

[Christian18]

Naja ich wollte den Keller mit einem Array realisieren. Und das Array müsste dann ja auch einen Typ haben. Und wir sollen einen allgemeinen nehmen, womit man alle möglichen Datentypen abbilden kann. Ich kenne in Delphi habe keinen der das kann.

[mkinzler]

Doch Variant oder ab D2009 hat generisch

[Phoenix]

Er will einen Keller (also eigentlich einen Stack) für verschiedene Datentypen haben. Also einen wo man Integer einlagern kann, einen wo man Strings einlagern kann, einen wo man Objekte (eines bestimmten Typs) einlagern kann.

Es gibt also drei Möglichkeiten:
1.) Delphi 2009 - Nutzen von Generics.
2.) Delphi < 2009: Einen Stack implementieren der Pointer speichert. Hier kannst Du dann Pointer auf Strings, Integer, TMyClass, whatever reinpacken.
3.) Delphi < 2009: Den Stack aus 2 implementieren und davon für die spezifischen Typen jeweils eine Ableitung erstellen, die dann das jeweilige Objekt bzw. den jeweiligen Datentyp annehmen und dessen Pointer dann intern einkellern.

Edit Nachtrag: Okay... variant ginge auch.. finde ich persönlich aber unschön. Man weiss nie was drinsteckt.

[Medium]

Zitat:

Zitat von Phoenix

Ab Delphi 2009 gibt es Generika / Generische Datentypen.

Dort kannst Du einen Keller<T> implementieren. Damit kannst Du einen Keller<String> und ein Keller<TButton> deklarieren und dieser Keller lagert dann nur den angegebenen Typen ein. Mit Delphi-Versionen vor 2009 geht das nicht so elegant.

Dieses ist die korrekte und vollständige Antwort auf deine Frage.

Als Behelf könnte man evtl. auf Variants zurück greifen, wobei die eben auch nicht alles beinhalten können, und mehr eine Flickerei sind da das eigentlich DAS klassische Anwendungsbeispiel für Generics ist.

Edit: Whoa, da hätte ja sogar nen doppelt roter Kasten kommen müssen :>

[seim]

Was ist ein emm "Keller" manche Leute haben sowas zu hause ich weis aber..

[Mithrandir]

Du kennst vermutlich das englische Wort dafür: Stack ;)

[mkinzler]

Keller ist eine Stack Datenstruktur ( LIFO: Last in First Out)

[quendolineDD]

Entweder über Pointer, dann musst du aber auch den Typen mitgeben, der an diesem Pointer steht. Oder Variant.
Mit C# wär's hier ganz einfach, weil alles die Oberklasse Object hat ;-)
Edit:
Aber er will ja kein Keller<T> sondern ein Keller.Push(obj : <T>)
Man konnte doch auch die Variablen einer funktion mit Generics realisieren ...
Edit2:
Geht mein obiges überhaupt? Hab Generics selber bisher nur in Java benutzt

[mkinzler]

Er kann ja auch in Delphi eine Klasse verwenden, diese ist dann immer ein TObject :zwinker:

[quendolineDD]

Dann müsste er aber für jeden Datentyp, den er in den Keller legen will eine eigene Kapselung schaffen.

[Dust Signs]

Zitat:

Zitat von Daniel G

Du kennst vermutlich das englische Wort dafür: Stack ;)

[OT]Korrigiert mich, wenn ich falsch liege, aber ich war immer der Meinung, Stack stünde für Stapel. Was hat ein Stapel mit einem "Kellerspeicher" gemein und woraus leitet sich das Wort Keller hier ab (augenscheinlich nicht aus einer direkten Übersetzung)?[/OT]

Dust Signs

[mkinzler]

Ein Stack stapelt ja nicht nach oben, sondern nach unten, deshalb nennt man ihn auch Keller

[Dust Signs]

Zitat:

Zitat von mkinzler

Ein Stack stapelt ja nicht nach oben, sondern nach unten, deshalb nennt man ihn auch Keller

Danke für die Information, das war mir neu. Bei uns in der Schule/an der FH hießen diese Speicher immer nur Stapelspeicher oder (ohne Übersetzung) Stacks :). Wieder was gelernt... :)

Dust Signs

[Mithrandir]

Schön dich mal wieder hier zu lesen. Hab eben erst deinen "Complex Calculator" in der c't entdeckt. ;)

[Meflin]

Zitat:

Zitat von mkinzler

Ein Stack stapelt ja nicht nach oben, sondern nach unten, deshalb nennt man ihn auch Keller

Hä? Elemente werden doch oben auf den Stack gelegt und wieder weggenommen :gruebel: (Deswegen ja auch "Stapel")

[mkinzler]

Im Speicher werden die Elemente aber nach unten gestapelt.

[Phoenix]

Du stellst etwas in den Keller. Und nochwas. Du musst das letzte Teil erst wieder aus dem Keller holen bevor Du das erste rausholen kannst. Ist doch egal ob man hoch oder tief stapelt - letztlich isses das gleiche :)

[Medium]

Die Begriffe sind nur deswegen in ihrer Übersetzung unterschiedlich, weil das Konzept sowohl von Englisch- als auch Deutschsprachigen Leuten unabhängig voneinander entwickelt wurde. Gemeint ist genau das selbe: Stack = Stapel = Keller. Rein historisch bedingt.

[himitsu]

was willst du denn alles in deinem Keller/Stack lagern?

eventuell reicht es schon, wenn du dir mal den Typ Variant anschaust, da kann man recht viel Verschiedenes drin ablegen :angel2:

[stoxx]

Zitat:

Naja ich wollte den Keller mit einem Array realisieren. Und das Array müsste dann ja auch einen Typ haben. Und wir sollen einen allgemeinen nehmen, womit man alle möglichen Datentypen abbilden kann. Ich kenne in Delphi habe keinen der das kann.

Anforderungen;
Du willst folgendes?


Keller.push( myData );


myData kann sein,
ein Integer?
ein TObject?
eine TStringlist?
Ein TForm?
ein Double?
ein String?


oder sogar ein anderer Record wie ein TRect?

das würde sehr einfach zu realisieren sein, wenn es ein Record gäbe..

Delphi-Quellcode:

TDataConverter = packed record
  FType : TDataType;
  FIntegerValue : Integer;
  FTRectValue : TRect;

  usw ...
  // plus ein paar Pointer falls es ein Object oder anderes Object ist

private

public

     class operator Implicit(const AValue: String): TDataConverter;
     class operator Implicit(const AValue: Double): TDataConverter;
     class operator Implicit(const AValue: TObjecct): TDataConverter;
     class operator Implicit(const AValue: Integer): TDataConverter;
     class operator Implicit(const AValue: TRect): TDataConverter;



end;

und dann definierst Du

Delphi-Quellcode:

TKeller = class(TObject)

  procedure Push(const aData : TDataConverter);
end;

bei der impliziten Typumwandlung (danach lässt sich suchen im Forum) .. müsstest Du Dir dann merken, welchen Typ aData darstellen soll, müsstest dann den Integer speichern oder eben auch den Pointer auf die TStringlist .. je nach Datentyp .. und je nach Datentypen, die Du unterstützen möchtest.
Aber die paar Grunddatentype und TObject sollte reichen.

und wenn die procedure Push aufgerufen wird, dann steht in aData drin, was es für ein Typ ist, den Du speichern musst ...
So würde ich das machen, wenn ich in Zukunft nie wieder Arbeit haben will und nicht mehr nachdenken möchte :-)

[Tyrael Y.]

Es geht dem Threadersteller wohl um das Prinzip aufzuzeigen, wenn ich das richtig verstehe.
In diesem Fall würde ich eigene Datentypen Kreieren und als Stack eine TObjectList nehmen.

Delphi-Quellcode:

type TDataType =(dtObject, dtString, dtInteger, ....);

type  
 TBaseType = class
   property Value: Pointer ....
   property DataType: TDataType .... 
end;

[himitsu]

Zitat:

Zitat von stoxx

Und das Array müsste dann ja auch einen Typ haben.

joar, drinnen muß man dann natürlich speichern was es ist.

statt TDataConverter könnte man auch überladene Funktionen/Prozeduren nutzen,
dieses würde dann auch unter älterten Delphi-Versionen (vor TD/D2006) laufen, wo es noch keine Operatoren gab.

Delphi-Quellcode:

TDataType = (dtInteger, dtRect, dtObject, usw.);
TData = record
  FType : TDataType;
  FIntegerValue: Integer;
  FTRectValue: TRect;
  Object: TObject; 

  usw ...
end;

TKeller = class(TObject)

  procedure Push(const aData: Integer); Overload;
  procedure Push(const aData: TRect);   Overload;
  procedure Push(const aData: TObject); Overload;
  ...
  procedure Pop(const aData: Integer); Overload;
  procedure Pop(const aData: TRect);   Overload;
  procedure Pop(const aData: TObject); Overload;
end;

[olee]

Zitat:

Delphi-Quellcode:

...
  procedure Push(const aData: Integer); Overload;
  procedure Push(const aData: TRect);   Overload;
  procedure Push(const aData: TObject); Overload;
  ...
  procedure Pop(const aData: Integer); Overload;
  procedure Pop(const aData: TRect);   Overload;
  procedure Pop(const aData: TObject); Overload;
end;

Mit dem oberen stimme ich dir ja zu nur das untere?!?!


Ich würde es mal so versuchen:

Delphi-Quellcode:

  TDataType = (vString,vInteger,...);

  TData = record
    case DataType: TDataType of
      vString  : (vString : PAnsiString);
      vInteger : (vInteger: Integer);
      vSingle  : (vSingle : Single);
  end;

MFG

[himitsu]

Zitat:

Zitat von olee

nur das untere?!?!Ich würde es mal so versuchen:

vom Prinzip her würde ich es auch so machen, aber gerade wegen des Strings hatte ich lieber erstmal das Andere vorgeschlagen ... nicht daß er sich da dann noch ein Speicherleck einbaut ... dieses ganze Rumgepointere ist nicht immer so vorteilhaft.
(und wenn man das Ganze auf weniger einheitliche Basistypen runterkürzt, dann wäre de Record auch nicht sooo groß)