Adresse eines dynamischen typisierten Arrays als Parameter

[Thomas233]

Guten Abend,

ich würde gerne ein dynamisches Array als Parameter übergeben.
Was mir Schwierigkeiten bereitet ist die Tatsache das ich nicht will das die Funktion der das Array übergeben wird mit einer Kopie des übergebenen Arrays arbeitet (also das Array nochmals am Stack anlegt wird und dann deren Inhalte ins neue Array kopiert werden) da dies bei größeren Arrays ein zu großer zeitlicher Aufwand wäre.
Am optimalsten wäre es die Startadresse des dynamischen Arrays als Parameter zu übergeben und dann in der Funktion mit der Startadresse zu arbeiten (wobei es schon recht toll wäre mit einem typisierten Pointer zu arbeiten). In C geht das eben mit typisierten Pointern.

Wie mache ich das in Delphi?

Vielen Dank im Vorraus für eure Hilfe !

Mit freundlichen Grüßen,
Thomas

[dizzy]

Mit eine var-Parameter wird automatisch die Adresse übergeben, und keine Kopie angelegt.

Delphi-Quellcode:

procedure(var DeinArray: TDeinArrayTyp);
begin
.
.
.
end;

Du musst dir nur einen Type für das dyn. Array machen

Delphi-Quellcode:

type
  TDeinArrayTyp = array of Integer;

Der übergebene Parameter muss dann auch vom Typ TDeinArrayTyp sein.

Gruss,
Fabian

[Thomas233]

Hi Fabian,

danke für die rasche Antwort.

Aber: Wird so nicht das Array bei der Übergabe (in den Stack) kopiert ?

Mit freundlichen Grüßen,
Thomas Tschofenig

[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.

[Thomas233]

Oh, sorry, das hatte ich nicht gewusst.

Und wenn ich jetzt z.b. eine Basisklasse habe und ich will der Funktion aber eine Abwandlung der Basisklasse übergeben (bzw. ein Array vom Typ der abgewandelten Klasse) geht das dann auch wenn man nur ein Array vom Typ der Basisklasse deklariert hat (in der Unit wo die Funktion drinnen ist) ?

Vielen Dank !

Mit freundlichen Grüßen,
Thomas Tschofenig

[dizzy]

Ich schreibe mal, wei ich das jetzt verstanden habe

Delphi-Quellcode:

type
  TBaseClass = class(TObject);
  .
  .
  end;
  
  TDerived = class(TBaseClass);
  .
  .
  end;

  TMyArray = array of TBaseClass;
end;

.
.

procedure Foo(var v: TMyArray);
begin
.
.
end;

var
  arr: TMyArray;
begin
  SetLength(arr, 1);
  arr[0] := TDerived.Create;
  Foo(arr);
end;

So ginge das. Allerdings hat das weniger mit Arrays an sich zu tun, als viel mehr mit OOP. Das hat auch zur Folge, dass du über "arr" nur die Felder der Klassen erreichst, die auch in TBaseClass deklariert sind. Ansonsten musst du casten: TDerived(arr[0]).FunktionInDerived;

Ich hoffe ich hab das jetzt richtig verstanden

Gruss,
Fabian

[Chewie]

Bei dynamischen Arrays kann man sich in diesem Fall die var-Angabe sparen, da dynamische Arrays von sich aus Referenztypen sind, ähnlich wie die C-Arrays (nur dass diese u.U. auf dem Stack liegen, Delphi dyn. Arrays aber immer auf dem Heap).

[Thomas233]

Hi dizzy,

fast

Delphi-Quellcode:

type 
  TBaseClass = class(TObject); //In BaseClass.pas deklariert
  . 
  . 
  end; 
  
  TDerived = class(TBaseClass); //In DerivedClass.pas deklariert
  . 
  . 
  end; 

  TMyArray1 = array of TBaseClass; // Vorsicht: Ist deklariert in der Unit in welcher die Funktion "Foo" vorkommt, in Unit1.pas
  TMyArray2 = array of TDerived; // Ist deklariert in der Unit in der die Funktion "Foo" aufgerufen wird, also in Unit2.pas
end; 

. 
. 

// In Unit1.pas
procedure Foo(var v: TMyArray1); 
begin 
. 
. 
end; 

// In Unit2.pas
procuedre TuWas;
var 
  arr: TMyArray2; 
begin 
  SetLength(arr, 1); 
  Foo(arr); 
end;

uses-Klausel von Unit1.pas:
BaseClass.pas

uses-Klausel von Unit2.pas:
DerivedClass.pas
Unit1.pas

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

Mit freundlichen Grüßen,
Thomas Tschofenig

[sniper_w]

Zitat:

Bei dynamischen Arrays kann man sich in diesem Fall die var-Angabe sparen, da dynamische Arrays von sich aus Referenztypen sind, ähnlich wie die C-Arrays (nur dass diese u.U. auf dem Stack liegen, Delphi dyn. Arrays aber immer auf dem Heap)

Was ist Heap?

[Oxmyx]

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.