Konstante mit dynamischem Array?

[himitsu]

Gehe ich recht der annahme, dass es leider keinen Weg bit, um ein dynamisches Array mit einem bestimmten Wert vorzubelegen?


Mein Problem ist volgendes:
ich habe einige Proceduren, denen ich auch mal eine Konstante mit einem Array übergeben möchte.

Und mir ist auch bewußte, das es ja normaler Weise möglich ist, ein statisches Array an eine Prozedur zu übergeben, welche ein dynamisches Array (kein Var-Parameter) empfängt.

Nur liegt bei mir das Array nicht direkt, sondern innerhalb eines Records vor,
wodurch ich ja einen neuen Typ, mit statischem Array für die Konstante, erstellen müßte.

Allerdings meckert ja dann der Compiler über die inkompatieblen Typen :cry:



Natürlich könte man ja statt der Konstanten einige Variablen nehmen, welche beim Start, über eine Prozedur, belegt werden ... aber genau dieses möchte ich nicht, da nicht immer alle Konstanten benötigt werden und in solchen Fällen ja Speicher verschwenden.




Statisch geht da ja ganz gut:

Delphi-Quellcode:

Type T1 = Record
    a: Integer;
    b: Integer;
    c: Array[0..2] of Integer;
  End;

Const x: T = (a: 0;  b: 1;  c: (2, 3, 4));

aber dynamisch kann ich das Array nicht belegen.

Delphi-Quellcode:

Type T2 = Record
    a: Integer;
    b: Integer;
    c: Array of Integer;
  End;

Const y: T2 = (a: 0;  b: 1;  c: (2, 3, 4));

Und T1 ist natürlich (leider) nicht mit T2 kompatiebel.

[Dax]

Wie sieht denn deine Prozedur aus? Falls es etwas in der Art von Foo(Params: array of ...) sein sollte, dürfte der Compiler bei einer Übergabe des Arrays im Record nicht meckern. Etwas Code könnte helfen :zwinker:

[himitsu]

Die Procedure ist ja egal

Delphi-Quellcode:

Procedure xyz(Const p: T2);

ich könnte es ja auch mal ohne Const versuchen, aber ändern dürfte das ja eh nichts, außer dass dann der Parameter vorher noch kopiert wird, was ich eigentlich nicht will.

Delphi-Quellcode:

Procedure xyz(p: T2);

Und den allgemeinen Aufbau der Records habe ich oben auch noch nachgetragen.

[Dax]

Das kann ja nicht funktionieren... Wenn du explizit angibst, das die Funktion einen Record T1 erwartet, wird der Compiler nie aufhören zu meckern, wenn du einen T2 übergibst.

Edit: Was du aber tun könntest, wäre den Record als Pointer zu übergeben und der Funktion dann per Parameter zu sagen, welchen Typ Array sie vorfindet, weil dynamische Arrays nicht wie die statischen gleich mit dem ersten Wert anfangen.

[himitsu]

Das es nicht klappt, war/ist mir auch so schon klar ... brauchte es ja nichtmal zu versuchen.

Pointer kommen aber nicht in Frage ... das hat interne/funktionelle Gründe.

Die Konstanten müssen also den selben Typ wie der Parameter haben ... wodurch ja das Problem mit dem vorbelegen der dynamischen Arrays auftritt :wall:

[opfer.der.genauigkeit]

Schon mal an diese Form der Deklaration gedacht?

Delphi-Quellcode:

procedure test(var test);

[himitsu]

Zitat:

Zitat von opfer.der.genauigkeit

Schon mal an diese Form der Deklaration gedacht?

Delphi-Quellcode:

procedure test(var test);

Bei Var-Parametern wird das mit der kompatibilität von Parametern ja noch viel schlimmer -.-''

dort muß der Parameter ja genau überainstimmen ... dort geht ja noch nichtmal die übergabe von statischen an dynamischen Arrays.

Sonst geht das ja, bei mir ist halt nur das Problem, dass die Arrays in Records eingebettet sind.

[Dax]

Dann nimm doch Klassen mit Get/Set-Properties, aber das bbelegt dir dann wieder zu viel Speicher... :roll:

[NicoDE]

Zitat:

Zitat von himitsu

Bei Var-Parametern wird das mit der kompatibilität von Parametern ja noch viel schlimmer -.-''

dort muß der Parameter ja genau überainstimmen ...

Ähm, untypisierte Variablen?

@topic:

Delphi-Quellcode:

type
  TFoo = record
    a: Integer;
    b: Integer;
    c: array of Integer;
  end;

const
  EmptyDynArray = nil;
  Foo: TFoo = (
    a: 42;
    b: 0;
    c: EmptyDynArray;
  );

Wenn das nicht reicht mach ein Objekt daraus un initialisiere es im Contructor.

[himitsu]

Auch keine Klassen, ich bin froh, dass das bis jetzt nur als Record habe und nicht als Klasse.

Wie gesagt, es ist genau so gewollt, dass es als Record und nicht über Pointer und Klassen abläuft.

[NicoDE]

Zitat:

Zitat von himitsu

Wie gesagt, es ist genau so gewollt, dass es als Record und nicht über Pointer und Klassen abläuft.

Array of Integer ist ein Pointer :)

[himitsu]

Ich weiß, dass Array of ... ein Pointer ist

Ich meinte aber die Art der Übergabe des gesamten Records an die Prozedur.

Und untüpisiert ist auch so ein Problem ... es gibt da manchmal noch überladene Proceduren ... es gibt ja unterschiedliche Records.

Es gibt insgesamt 4 Records ... jeweil 2 mit 'nem dynamischem Array und dann nochmal von diesen jeweile eine spezielle Version mit statischem Array.

Und einige Konstanten ab ich auch schon mit Hilfe der statischen Versionen definieren können, aber derzeit gibt es auch zwei Konstanten, deren Datenmenge leider nicht in diese statischen Versionen reinpasst.

[opfer.der.genauigkeit]

Zitat:

Zitat von himitsu

Bei Var-Parametern wird das mit der kompatibilität von Parametern ja noch viel schlimmer -.-''

dort muß der Parameter ja genau überainstimmen ... dort geht ja noch nichtmal die übergabe von statischen an dynamischen Arrays.

Wo muß da der Parameter übereinstimmen, wenn der Parameter keinen Typen besitzt?
Vielleicht übersehe ich da ja irgendwas, aber bei der Deklaration:

Delphi-Quellcode:

var aTest

Kann ich fast alles übergeben.. Sollte eben ein var- Parametersein. :)

Delphi-Quellcode:

procedure Test(var aTest);
var
  a: T1 absolute aTest;
begin
  a.a := 1;
  a.b := 2;

...
end;

Das Einzige, was du dort rauskriegen mußt, ist ob nun T1 oder T2 übergeben wurde.

[himitsu]

@Opfer:

Ja Intern ist das sogut wie Egal, aber aber von Außerhalb nicht.


Ich brauche ja keine "interne" Umwandlung, sondern ich habe externe Übergabeprobleme.

Delphi-Quellcode:

Procedure Test(Var i: Integer);


Var i1: Integer;
  i2: Type Integer;

Test(i1);
Test(i2); << Probleme

Also es git sozusagen keine (für meine Zwecke) passende Möglichkeit, um zwei unterschiedliche Typen zu übergeben.

Und derzeit gibt es eben diese Probeme, um ein Dynamisches Array als Konstante zu definieren und entsprechend vorzubelegen.

Und nur für diese zwei Konstanten jetzt nochmal einen neuen Type mit noch größerem statischem Array und dann noch die hunderten dazupassenden Prozeduren/Funktionen (was ja massig Arbeit macht) anzulegen ist auch nicht so gut.


Aber mir ist gerade was eingefallen ... mal sehn, ob ich nicht mit ASM ein dynamisches Array vorbelegen kann ... werd' es heute Abend mal versuchen.

[himitsu]

OK, ich hab jetzt 'ne "gute" Lösung gefunden.

Im Grunde genommen definiere ich jetzt selber die interne Datenstruktur der dynamischen Arrays (dieses kann man ja überall und in jedem anderem beliebigem Datentyp erledigen ... ASM, Stream ... aber ich hab's der Einfachheit halber über Statische Arrays gemacht, do ich dort ja die Datenwerte im selben Format angeben kann) und weises den Arrays dann nur noch den Zeiger darauf zu.


PS: wer kennt nicht diesen Referenzen (RefCount) und ElementAnzahl bei Strings.
Intern sind Strings und Arrays ja gleich aufgebaut und wie ich jetzt mitbekommen hab, gibt es nicht nur dieses Zwei werte, sondern unter Umständen noch einen 3. Wert und RefCount ist nicht immer RefCount...
Aber genaueres dazu werde ich demnächst mal Veröffentlichen ... erstmal sehn, obs da nicht noch mehr gibt :mrgreen:

[hardy1234]

Doch gibt es, mit sogenannten varianten records. Der Tip mit:

Delphi-Quellcode:

  
  procedure yxz(var Buf);

war übrigens für sowas goldrichtig. Das ist ein untypisierter Puffer, der jeden beliebigen Typ aufnimmt. Nun kommt es halt auf die Struktur an die ankommt. Man könnte folgendes machen:

Delphi-Quellcode:

type

  TMyStruct = record
    case StructDef: integer of
      1:(Feld1_1: string; Feld2_1: integer; Feld3_1: array of real);
      2:(Feld1_2: string; Feld2_2: integer; Feld3_2: real);
    end;
  end;

procedure xyz(var Buf);
var
  a: TMyStruct;
begin
  a:= TMyStruct(Buf);
  {*** und nun kannste anfangen das abzuarbeiten ***}
  case a.StructDef of
    1: begin
    end;
    2: begin
    end;
  end; // of case
end; // of procedure xyz(var Buf);

Der Trick besteht darin, das variante Records so ziemlich alles aufnehmen können. Sie belegen gerade soviel Platz wie nötig. Nachteil ist, das strings nur maximal 255 Zeichen haben dürfen. Das läßt sich aber mit PChar ebenfalls umgehen.

Beachten mußt du lediglich, das die Feldnamen eindeutig sein müssen. Du darfst nicht 2mal den gleiche Variablennamen verwenden. Deswegen im Beispiel die Indizierung, damit sind sie dann eindeutig und können trotzdem ähnlich sein.

Die records sind für manche Sachen immer noch 1. Wahl, wie man an dem Bsp. sehen kann. Ich würde mir die Dinger mal genauer ansehen, da kann man im Zusammenhang mit strukturierten Konstanten noch erheblich mehr rausholen.