array mit unterschiedl. "variablentypen" ?!?

[heiopei]

abend,

also ich hab ja letztens schon was gepostet wegen dem definieren eines variablen records (mit case), um meinen code zu optimieren.

jetzt hab ich mir aber noch was gedacht - geht zwar wahrscheinlich nich, aber naja:

ich möchte ein statisches array festlegen, wobei ich jedem feld einen anderen variablentyp zuweisen möchte: also
data: array [1..5] of weisnichwieweiter;

data[1] => vom typ1
data[2] => vom typ2
...

ich würde es gern deshalb verwenden, da ich dann mit indizehs arbeiten könnte (wasn satz)

wie kann ich dieses problem lösen - ist das so überhaupt mögl.? - fürchte nicht - des wär doch zu schön

mfg,
heiopei

[Niels]

Hi,

es gibt in Delphi den Datentyp Variant. Soweit ich weiß, ist der aber extrem langsam. Da es dir um Optimierung geht, würde ich das nicht empfehlen. Andererseits weiß ich ja nicht was du damit machst und vielleicht bringt es in dienem Fall ja doch eine Verbesserung.

MfG Niels

[axelf98]

Nimm eine TList und füll die entweder mit eigegen Objekten oder Records, die die Typen, die du brauchst als Eigenschaften haben. Dann noch einen Index für den Typ des Records/Objekts, damit du nicht lange nach den Daten suchen musst. Die leeren Einträge brauchen kaum Speicherplatz, während die Gesamtperformance hoch ist.
Ist zwar verwaltungstchnisch schwieriger als ein Array of Variant, aber der Aufwand lohnt sich IMHO

Also lieber als am Ende

[dizzy]

Ansonsten ginge es auch mit einem varianten Record, allerdings musst du dann immer im Hinterkopf behalten welches Array-Element von welchem Typ sein soll, oder du führst es explizit im Record mit. (Ist dann ähnlich wie Variants, aber mit etwas weniger Overhead.)

Delphi-Quellcode:

type
  TTypeInfo = (tWord, tInteger, tChar, ...);

  TMyType = record
    RecType: TTypeInfo;
    case x:Byte of
      0: (EinWord: Word);
      1: (EinInt: Integer);
      2: (EinChar: Char);
      3: .... ... .. .
  end;

.
.
.
  MyArray: array[0..N] of TMyType;

Jedoch wäre es moderner sich dort einer Liste zu bedienen .

[heiopei]

hallo,
ja dann werd ich wohl die tlist-version mal ausprobieren!
(wahrscheinlich lass ichs dann wohl aber doch beim alten )

noch zu der case-variante:
hab ich mir auch schon überlegt, aber da kann ich ja nich mit indizehs auf die einzelnen typen zugreifen.
weil: array mit variablen vom selben typ: dings: array [1..4] of Shortstring;

ich möchte jetzt allerdings auch per indizeh auf die einzelnen felder zugreifen können, was mit dem case record ja ihmo nicht mögl. ist!

naja das mit variant schau ich mir auch noch an, klingt aber nicht sehr vielversprechend und ich meine schon was darüber in dem zusammenhang gesehen zu haben - wurst, wenns was is, werd ichs posten

mfg,
heiopei

[heiopei]

hallo,
hab mir in der hilfe + buch jetzt mal das mit variant angeschaut
ABER: 1. sehr langsam
2. nicht für strukturierte typen - aber das wäre dass, was ich brauche

dann hab ich mir das mit tlist angeschaut - soweit ich das jetzt gesehen hab, arbeitet die kompo mit pointern (also die item-inhalte sind pointer). da mein array aber statisch ist brauch ich ja gar keine kompo mit mords funktionen... ich brauch doch nur son array oder:

sammlung: array [1..3] of pointer; dann kann ich doch jedem feld ein anderen typ zuweisen - oder?

also dann etwa so:

Delphi-Quellcode:

sammlung[1] := @typ1;
sammlung[2] := @typ2;
...

nur stellen sich mir jetzt dazu noch son paar fragen:

(1.geht das wirklich so?)
2. kann ich auch arrays (+ dynamisch) als pointer übergeben?
3. wenn ja, wie greife ich auf die einzelnen variablen inerhalb eines arrayfeldes ( + "unterfeld")
zu? (ich weiss, sollten eigentlich pointerbasics sein, aber ich checks einfach net )
4.weis keine weiteren gründe

mfg,
heiopei

[dizzy]

Zitat von heiopei:

noch zu der case-variante:
hab ich mir auch schon überlegt, aber da kann ich ja nich mit indizehs auf die einzelnen typen zugreifen.
weil: array mit variablen vom selben typ: dings: array [1..4] of Shortstring;

ich möchte jetzt allerdings auch per indizeh auf die einzelnen felder zugreifen können, was mit dem case record ja ihmo nicht mögl. ist!

Warum sollte das nicht gehen?

Um beim Beispiel von oben zu bleiben:

Delphi-Quellcode:

  // Zugriff:
  MyArray[0].EinInt := 10;
  MyArray[0].RecType := tInteger;

  MyArray[1].EinChar := 'x';
  MyArray[1].RecType := tChar;
  .
  .

Wenn du es mit einem Array of Pointer machst, dann arbeitest du völlig ohne Netz und doppeltem Boden - d.h. all die Typsicherheit die dir Delphi bietet, mit all dem Komfort drumherum schießt du in den Wind. (Die o.g. Recordvariante ist diesbezüglich im Übrigen auch nicht der Weisheit letzter Schluss .)

Wenn du es aber unbedingt so willst:

Delphi-Quellcode:

var
  MyArray: array[0..N] of Pointer;
  i: Integer;
  x: Integer;
begin
  MyArray[0] := @i;
  x := MyArray[0]^; // => x=i
end;

Aber das ist unsicher, unschön da schwer lesbar, und eher unsauber. Mit einer vernünftigen Liste kommst du auf Dauer sicher besser weg.

Zitat von heiopei:

2. nicht für strukturierte typen - aber das wäre dass, was ich brauche

Was meinst du damit? File of XXX, oder Records, oder Klassen?

Gruss,
Fabian

[maximov]

Wenn du es wirklich statisch machen willst, dann hat der dizzy dir eine prima möglichkeit genannt wie du es realisieren kannst und das völlig ohne pointer, die hier vermutlich überflüssig sind. Über den recType hast du dann eine prima möglichkeit zu differenzieren. Ich hätte allerdings den Enum-typ dann auch als recType äh case-dings benutz:

Delphi-Quellcode:

type 
  TFieldType = (tWord, tInteger, tChar, ...); 

  TMyType = record 
    RecType: TTypeInfo; 
    case TFieldType of 
      tWord: (EinWord: Word); 
      1tInteger: (EinInt: Integer); 
      tChar:(EinChar: Char); 
    end; 

var
  MyArray: array[0..3] of TMyType;

// und zugriff ist auch klar
case MyArray[2].RecType of
  tChar: HabEinenCharGefunden(MyArray[2].EinChar);
  ...
end;

oder so ähnlich. Is natürlich nicht gerade sehr generisch. Dafür würde man dann lieber klassen nehmen.