Adresse eines dynamischen typisierten Arrays als Parameter

[dizzy]

Zitat:

Zitat von Thomas233

Ich schätze mal das geht so nicht, oder?

Korrekt. Hab ich befürchtet dass du das so meintest ;). Der Typ der übergebenen Variable muss mit dem im Prozedurkopf übereinstimmen. Das geht sogar so weit, dass ein und die selbe Deklatation in 2 unterschiedlichen Units nicht den selben Typ darstellen!

Bei deinem Vorhaben würdest du glaub ich um untypisierte Pointer nicht umher kommen. Dann wird das ganze ähnlich unschön wie in C :D
Wird auch viel Casterei...

@Chewie: Stümmt ja... Fixe Arrays, Records und generische Typen sind per Standard Call-by-Value, und Dyn. Arrays und Objekte sind immer Call-by-Reference.
Wie es bei Records aussieht, die Objekte und dyn. Arrays beinhalten aussieht weiss ich es nicht genau. Das gibt u.U. ein heiloses Durcheinander :).

Zusätzlich werden Objekte und dyn. Arrays immer im Heap angelegt, und lok. Variablen und fixe Arrays gewöhnlich auf dem Stack.

@sniper_w: Bitte einen eigenen Thread auf machen ;)

[dizzy]

Zitat:

Zitat von Oxmyx

Zitat:

Zitat von dizzy

Nope, durch Angabe des Schlüsselwortes "var" wird vom Compiler nur ein Pointer auf das Array übergeben. Du brauchst dich aber, anders als bei C, nicht in der procedure drum zu kümmern; du kannst alles so schreiben wie mit für Kopien. Das ist imho das hauptsächliche was Delphi im Vergleich zu C so schön und lesbar macht :)

\\edit: Es ist also dann ein Call-by-Reference, während ohne "var" ein Call-by-Value gemacht wird.

Äh, sicher? Mit dem Schlüsselwort var wird doch überhaupt kein Wert mehr übergeben (auch kein Zeiger), da es ja eine Referenz darstellt. D.h. es wird kein neuer Zeiger auf dem Stack angelegt, der auf das Array zeigt, sondern die Funktion "kennt" das ursprüngliche Array einfach.

Na, du musst doch aber die Adresse zumindest in einem Register hinterlegen. Weil "einfach so" kennt die das Array bestimmt nicht, wär ja nen Dingen ;)
Einen ganz neuen Zeiger wird man, je nach Parameteranzahl, wohl nicht benötigen.
\\edit: Die ersten 3 Paramenter werden imho in Delphi via Register übergeben (wenn möglich), und alle weiteren werden auf den Stack gepackt. Und ein Pointer ist ja im Grunde erstmal nix anderes als ein Integer.

[Chewie]

Zitat:

Zitat von dizzy

Wie es bei Records aussieht, die Objekte und dyn. Arrays beinhalten aussieht weiss ich es nicht genau. Das gibt u.U. ein heiloses Durcheinander :)

Eigentlich nicht ;) Du darfst immer nur die benachbarte Indirektionsebene betrachten. Ein dyn. array liegt erstmal auf dem Heap. Dort sind die Daten, die wiederum Zeiger auf woanders hin sein können etc.
Das ist kein Durcheinander, sondern eine logische Hierarchie - man muss nur vorne anfangen ;)

[Thomas233]

Hi @ all,

um nochmal auf das obige Beispiel zurück zu kommen, ohne das Array habe ich es durchaus geschafft eine abgewandelte Klasse anstatt einer Basisklasse einer Funktion als Parameter zu übergeben obwohl in der Deklaration der Funktion die Basisklasse verlangt war und zwar so:

Delphi-Quellcode:

type
    PMyClass=^TBasicClass;

procedure Foo(Class:PMyClass)
begin
.....
end;

procedure Tuwas;
var MyClass:TDerivedClass;
begin
Foo(@MyClass);
end;

Ich weiss zwar nicht so genau warum es so ging, aber es ging immerhin ;-)

Mit freundlichen Grüßen,
Thomas Tschofenig

[Sprint]

Aus objektorientierter Sicht, benutzt man zum Verwalten von Klassen kein Array, sondern TObjectList. TList kannst du natürlich auch nehmen.

[Thomas233]

Hi Sprint,

da hast du sicherlich recht, aber dann müssen die ganze Zeit wieder die Typecasts herhalten wenn ich mehrere Klassen in einer Liste habe :-(

Mit freundlichen Grüßen,
Thomas Tschofenig

[Sprint]

Zitat:

Zitat von Thomas233

da hast du sicherlich recht, aber dann müssen die ganze Zeit wieder die Typecasts herhalten wenn ich mehrere Klassen in einer Liste habe

Aber nicht wenn deine Klasse von TObject abgeleitet ist und du TObjectList verwendest.


Edit: \\ Sorry. Natürlich musst du ein Typcast machen.

[dizzy]

Zitat:

Zitat von Thomas233

Hi @ all,

um nochmal auf das obige Beispiel zurück zu kommen, ohne das Array habe ich es durchaus geschafft eine abgewandelte Klasse anstatt einer Basisklasse einer Funktion als Parameter zu übergeben obwohl in der Deklaration der Funktion die Basisklasse verlangt war und zwar so:

Delphi-Quellcode:

type
    PMyClass=^TBasicClass;

procedure Foo(Class:PMyClass)
begin
.....
end;

procedure Tuwas;
var MyClass:TDerivedClass;
begin
Foo(@MyClass);
end;

Ich weiss zwar nicht so genau warum es so ging, aber es ging immerhin ;-)

Mit freundlichen Grüßen,
Thomas Tschofenig

Klar, das geht. Das "Gehampel" mit dem Pointer könntest du dir sogar sparen.

Delphi-Quellcode:

procedure Foo(Class: TBasicClass);
begin
...
end;

procedure Tuwas;
var MyClass:TDerivedClass;
begin
  Foo(MyClass);
end;

Geht genau so, und das deshalb, weil in Delphi ohnehin alle Objekte Pointer in den Heap sind, und das weiss der Compiler, und macht es dir deshalb einfach/lesbarer :)

Aber bei der Sache mit dem Array übergibst du ja keine Variable vom Typ "Klasse", sondern "Array". Ein Array weiss aber rein garnichts von Ableitung o.ä., und schon garnichts darüber was es im einzelnen für Werte beinhaltet. Für den Compiler sind das dann grundverschiedene Typen, da das eine Array ja nicht vom anderen Abgeleitet ist/sein kann. Was in den Arrays steht ist ihm wurscht ;).

TList mit etwas Casterei (lässt sich mit ein paar Hilfsvariablen der möglichen Typen evtl. etwas einschränken) ist aber, wie Sprint richtigerweise sagt, "runder". Das denke ich auch.

Gruss,
Fabian

[Thomas233]

Hi Fabian,

sicherlich ist es auch in meinem Fall besser TObjectlist oder änhliches zu verwenden, ich würds ja auch gerne verwenden, nur die Typcasterei geht mir auf die Nerven.

Gibt nicht eine Möglichkeit mit der man sowas wie den folgenden Block vereinfachen könnte ??

Delphi-Quellcode:

if Class is TBaseClass then 
   (Class as TBaseClass).Tuwas
else if Class is TDerivedClass then
   (Class as TDerivedClass).Tuwas;

Liebe Grüße und vielen Dank,
Thomas

[dizzy]

Naja, so richtig nicht. Man kann es in der Laufzeit etwas optimieren, da der "as"-Operator nochmals eine "is"-Prüfung macht. So wie du es machst, bist du zum Zeitpunkts des Casts ja schon sicher die richtige Klasse in der Hand zu haben -> direkt casten:

Delphi-Quellcode:

if Class is TBaseClass then 
   TBaseClass(Class).Tuwas
else if Class is TDerivedClass then
   TDerivedClass(Class).Tuwas;

Ich hab mir, wenn ich sehr viel so zugreifen musste, immer für jeden Typ eine lokale Variable angelegt, und dieser dann das gefundene zugewiesen. Dann kann man mit der ja weiter machen. Für so kurze Dinger wie oben gibt es imho keinen komfortableren Weg. (Wäre aber auch daran interessiert :))

Gruss,
Fabian