Einen Keller in Delphi Programmieren

[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ß)