Inkompatible Datentypen in Procedures bei Arrays mit Double bzw. Extended

[enigma]

Hallo zusammen,

ich habe ein kleines Verständnisproblem bei der Kompatibilität der Datentypen
bei den Parametern:

Und zwar liegen in meinem Programm folgende Procedures vor:

Delphi-Quellcode:

procedure procExtended(AExt: Extended);  //2022-01-24
begin
  ShowMessage('procExtended');
end;

procedure procDouble(ADouble: Double);  //2022-01-24
begin
  ShowMessage('procDouble');
end;

procedure procArrDouble(AArrDouble: Array of Double);  //2022-01-24
begin
  ShowMessage('procArrDouble');
end;

procedure procArrExtended(AArrExt: Array of  Extended);  //2022-01-25
begin
  ShowMessage('procArrExtended');
end;

Die Datenlage ist folgende:

Delphi-Quellcode:

  varDouble := 1.2;
  varExt := 7.3;
  arrDouble: array[0..2] of Double = (1.1, 2.2, 3.3);
  arrExt: array[0..2] of Double = (1.0, 2.0, 3.0);

Beim Aufrufen der Procedures klappt es mit den Datentypen bei folgendem:

Delphi-Quellcode:

  procExtended(varDouble);
  procDouble(varExt);

Bei den Arrays kommt aber die Meldung "Inkompatible Typen":

Delphi-Quellcode:

  procArrExtended(arrDouble);
  procArrDouble(arrExt);

Ich freue mich über jeden Hinweis

[KodeZwerg]

definiere deine array typen außerhalb, in der proc nimmst du dann diese definition. sollte funktionieren.

falls das unverständlich war ->

Delphi-Quellcode:

type
  TMyArr: Array of WasAuchImmer;


...


procedure Tada(AArr: TMyArr);

[enigma]

Hallo KodeZwerg,

danke für deinen Tipp mit der externen Typdefinition
Ich brauche aber keine speziellen Typen, sondern einfach
Array of Double bzw. Array of Extended.
Meine procedure soll beide, also Double und Extended akzeptieren,
was ja bei normalen Parametern klappt.

Was meinst du zu meiner Aussage?

[KodeZwerg]

Ich meine das es nur so funktionieren kann.

Delphi-Quellcode:

type
  TExtArr: Array of Extended;
  TDblArr: Array of Double;

...


procedure ExtArr(AArr: TExtArr);
begin
end;

procedure DblArr(AArr: TDblArr);
begin
end;

...

var
  MeinExt: TExtArr;
  MeinDbl: TDblArr;
begin
  SetLength(MeinExt, 1);
  SetLength(MeinDbl, 1);
  MeinExt[0] := 0.0;
  MeinDbl[0] := 0.0;
  ExtArr(MeinExt);
  DblArr(MeinDbl);

[Andreas13]

Hallo Enigma,
als Ergänzung zur korrekten Lösung von KodeZwerg nur so viel: Für den strengen Delphi-Compiler sind zwei Typendeklarationen nicht dann gleich, wenn sie auf die gleiche Art deklariert worden sind, sondern nur dann, wenn sie denselben Typen haben. Und das geht nur über eine benannte Typen-Deklaration, die Du verwendest. Mein Tipp dazu: Lege Dir eine globale Unit mit oft verwendeten Typendeklarationen, die Du als eigene Daten-Typen konsequent verwendest.
Beispiel:

Delphi-Quellcode:

Unit My_Types;

interface

uses
 System.Types;

…
Type
  TDynDoubleVektor      = System.Types.TDoubleDynArray; // oder: TArray<Double>;
  TDynExtendedVektor    = TArray<Extended>;

  TDynIntegerVektor     = System.Types.TIntegerDynArray; // oder: TArray<Integer>;
  TDynStringVektor      = System.Types.TStringDynArray; // oder: TArray<String>;
  TDynPAnsiCharVektor   = TArray<PAnsiChar>;

usw.

Implementation

Begin

End.

Gruß, Andreas

[Blup]

Eine Type-Deklaration deklariert ein dynamisches Array.
Wird ein ein Parameter von diesem Typ übergeben, so ist der Parameter in Wirklichkeit ein Zeiger auf das ursprüngliche Array.
Da gibt es keine Typumwandlung der Elemente.
Die Direktive "overload" ermöglicht Procedure mit gleichem Namen mit unterschiedlichen Parametern.

Eine direkte Array-Deklaration als Parameter deklariert eine sogenanntes "offenes Array".

Delphi-Quellcode:

procedure procArrDouble(const AArrDouble: Array of Double); 


procedure Test;
var
  a: Double;
  b: Extendet;
  c: Integer;
begin
  procArrDouble([a, b, c]);
end;

Hier wird jeder einzelne Parameter in den Zieltyp umgewandelt und in ein offenes Array gepackt.

[Andreas13]

Von der Verwendung von "offenen Arrays" möchte ich warnen: Dem Vorteil, daß man mit derselben Routine sowohl statische (1-basierte Zählung), wie auch dynamische Arrays (0-basierte Zählung) bearbeiten lassen, steht der gravierende Nachteil entgegen, daß z.B. das 5-te Element in beiden Fällen verschiedene Inhalte bezeichnet. Damit kann man bei direktem Zugriff auf ein bestimmtes Element ziemlich schnell durcheinanderkommen.
Gruß, Andreas

[bcvs]

Zitat von enigma:

Meine procedure soll beide, also Double und Extended akzeptieren,
was ja bei normalen Parametern klappt.

Ich denke, das ist mit Arrays nicht möglich. Bei der Übergabe von Einzelparametern baut der Compiler eine Typumwandlung ein, sofern die Parameter zuweisungskompatibel sind. Da bei Arrays aber nur Zeiger übergeben werden, funktioniert das nicht mit der Typumwandlung.

[Andreas13]

Zitat von bcvs:

Zitat von enigma:

Meine procedure soll beide, also Double und Extended akzeptieren,
was ja bei normalen Parametern klappt.

Ich denke, das ist mit Arrays nicht möglich. Bei der Übergabe von Einzelparametern baut der Compiler eine Typumwandlung ein, sofern die Parameter zuweisungskompatibel sind. Da bei Arrays aber nur Zeiger übergeben werden, funktioniert das nicht mit der Typumwandlung.

Das geht nur, wie bereits gesagt, wenn man Overlaod verwendet: Selber Prozedurname, verschiedene Datentypen.
Andreas

[KodeZwerg]

Zitat von Andreas13:

wenn man Overlaod verwendet: Selber Prozedurname, verschiedene Datentypen.

Beispiel:

Delphi-Quellcode:

type
  TExtArr = array of Extended;
  TDblArr = array of Double;

...

procedure AcceptMe(s: string); overload;
begin
end;
procedure AcceptMe(i: Integer); overload;
begin
end;
procedure AcceptMe(i64: Int64); overload;
begin
end;
procedure AcceptMe(AArr: TExtArr); overload;
begin
end;
procedure AcceptMe(AArr: TDblArr); overload;
begin
end;

nun kannst du "AcceptMe" mit vielen verschiedenen typen aufrufen und der name der procedure bleibt immer gleich.