unbestimmter Datentyp deklarieren

[vsilverlord]

Hallo, ich möchte eine Klasse deklarieren, die einen array von unbestimmten Datentypen hat. Später dann möchte ich dann z.b. Integer oder tvector zuweisen können.(Natürlich bevor dem array Werte zugewiesen wurden). Wie kann ich das machen?

Delphi-Quellcode:

tbuffer = class
private
items: array of tunbestimmterdatentyp; //ttrait als unbestimmter Datentyp
...
public
...
procedure setbestimmterdatentyp(bestimmterdatentyp: ???)

so ungefähr soll das aussehen.

[himitsu]

Wenn es unbeding ein Array sein soll, dann garnicht.

Du kannst nur einen Typen nehmen, wo die beiden anderen Wunschtypen reinpassen.

z.B.:

Delphi-Quellcode:

tunbestimmterdatentyp = record
  case integer of
    0: (i: Integer);
    1: (v: tvector);
end;

[jfheins]

Evtl. mit dem Typ Variant ?

Und in neuen Delphi-Versionen auch Generics ...

[Jaynder]

Variant ist gut, aber ungemütlich zu handlen. Generics helfen hier gar nicht. himitsu's Lösung passt.

[himitsu]

@jfheins: Generics helfen, wenn man den Typ erst zur Kompilierungszeit festlegen möchte, aber hier soll es erst zur Laufzeit passieren.

Variants und Records vertragen sich nicht sonderlich.

[implementation]

Wie wärs mit nem unbestimmten Pointer?

Delphi-Quellcode:

type
  TAnyArray = array of Pointer;
  PInteger = ^Integer;
  PVector = ^TVector;
var
  AnyArray: TAnyArray;

...

New(PInteger(AnyArray[i]));
PInteger(AnyArray[i])^ := 89;

New(PVector(AnyArray[i]));
PVector(AnyArray[i])^.IrgendeinFeld := 34;

Und Dispose nicht vergessen, sonst schaffst du 'nen Speicherleck. :angel2:

[Jaynder]

:gruebel: Und wer soll das später noch mal verstehen?
himitsu's record mit varianten sind die sauberste Lösung. :thumb:

[implementation]

Natürlich könnte man auch von allen Datentypen Container-Klassen basteln, und dann einen Array of TObject draus machen... :twisted:

[Uwe Raabe]

Ab Delphi 2010 könnte man es auch mit

Delphi-Quellcode:

array of TValue

versuchen.

[vsilverlord]

hm.
hier mal der Quelltext wie es bisher aussieht, so gefällt es mir halt überhaupt nicht:

Delphi-Quellcode:

unit uBuffer;

interface

uses
uvektor;

Type

// Pointer auf array mit extended
tarrayextended = record
  items:array of extended;
end;
  parrayextended=^tarrayextended;

// Pointer auf array mit tvektor3
tarraytvektor3 = record
  items:array of tvektor3;
end;
  parraytvektor3=^tarraytvektor3;

...

////////// TBuffer ///////////////
TBuffer = class
    public

        constructor create;virtual;
        destructor destroy;virtual;

        procedure SetSlotlength(Slotlength:integer);virtual;abstract;
end;
  pBuffer=^TBuffer;

/////////TBufferextended//////////
TBufferextended = class(TBuffer)
     protected
        fparts:tarrayextended;
        //getter setter methoden
        function getparts:parrayextended;
        procedure setparts(nitems:parrayextended);

     public
        // create / destroy
        constructor create;virtual;
        destructor destroy;virtual;
        //propertys
        property parts:parrayextended read getparts write setparts;
        procedure SetSlotlength(Slotlength:integer);override;
end;
pBufferextended=^TBufferextended;

//////////TBuffertvektor3/////////
TBuffertvektor3 = class(TBuffer)
      protected
        fparts:tarraytvektor3;
        //getter setter methoden
        function getparts:parraytvektor3;
        procedure setparts(nitems:parraytvektor3);

      public
      // create / destroy
        constructor create;virtual;
        destructor destroy;virtual;
        //propertys
        property parts:parraytvektor3 read getparts write setparts;
        procedure SetSlotlength(Slotlength:integer);override;
end;

implementation

...
end.

Ich denke ihr wisst am besten wir man das hier verbessern kann, wenigstens funktioniert es so, auch wenn es hässlich ist.
Das Ziel hier ist, dass ich TBuffer benutzen kann, ohne gleich den Typ angeben zu müssen. Den kann ich nun später angeben.
//edit: gekürzt, um Übersichtlichkeit zu schaffen

[vsilverlord]

später benutz ich das so, indem ich TBuffer deklariere und im tieferen Klassen die Variable als Tbufferextended erzeuge. Somit lege ich praktisch erst später den Typ fest und kann flexibel agieren. Das Problem ist, dass ich das bei jedem Datentyp eine neue Klasse erstellen muss, die völlig analog zu den anderen ist (siehe oben, das einzige, wo sich TbufferTvektor3 und TBufferextended unterscheiden ist die deklaration der Variable)

[implementation]

Dann könnten dir Generics doch helfen. :feuerchen:

[vsilverlord]

hi, ich lese mich gerade ein. Du meinst generische Klassen? :bouncing4:

[implementation]

Genau.

[vsilverlord]

hallo, wie genau definiere ich das jetzt, geht das so:

Delphi-Quellcode:

type
 werte<T> = array of T;

tbuffer = class
private
items: werte<T>; //ttrait als unbestimmter Datentyp
...
public
...
procedure setbestimmterdatentyp(bestimmterdatentyp: AnyType);

wie sage ich jetzt, dass <T> zb integer annehmen soll?

[himitsu]

Das T ist in diesem Fall der Platzhalter für den Typ in der Generic-Deklaration.
Wenn du es jetzt so schreibst,

Delphi-Quellcode:

items: werte<Integer>;

dann heißt das, daß überall, wo im Generic "T" vorkommt, "Integer" eingesetzt werden soll;