Gleiche Prozedur mit verschiedenen Parametertypen aufrufen

[FriendOfDelphi]

Hallo Allerseits,

gibt es eigentlich eine Möglichkeit, eine Prozedur mit verschiedenen Parametertypen aufzurufen?
Also eine Prozedur, die z.B. einmal mit einem Parameter vom Typ array of Double, und ein anderes Mal mit einem Typ array of Integer usw. aufgerufen wird.

Das Problem ist, dass die Prozedur eigentlich immer das gleiche macht. Nur mit verschiedenen Arrays.

Delphi-Quellcode:

MeineProzedur(Meinparameter: array of Double);
begin
  //tue was
end;

MeineProzedur(Meinparameter: array of Integer);
begin
  //tue das gleiche
end;

Es wäre doch naheliegend, dass mit einer Prozedur zu machen, der ein "Universaltyp" übergeben wird.

Delphi-Quellcode:

MeineProzedur(Meinparameter: array of "Universal");
begin
  //tue das gleiche
end;

Gibt es da eine Möglichkeit?
Oder muss man damit leben, dass man ein- und dieselbe Prozedur mehrfach für die unterschiedlichen Parametertypen implementiert?

[chaosben]

Der älteste Weg das zu erreichen, ist einen untypisierten Pointer zu übergeben.
Alternativ ein Record, das alle versch. Typen kennt und ein Feld hat, was angibt, welcher Typ benutzt werden soll.
Alternativ ein Variant.
Alternativ eine Array of Variant.
Alternativ eine Basisklasse und Ableitungen davon.

:-D

[sirius]

Irgendwo muss die Funktion ja wissen, was du da für Datentypen hast. Auch wenn es für dich in der Hochsprache Pascal gleich aussieht, was du da machst, so ist es im Maschinencode teilweise Welten auseinander. Grade wenn du mit Double oder Integer einfache Rechnenaufgaben löst. Bei Double geht alles durch die FPU, während bei Integer die CPU ausreicht. Es ist also weit unten komplett verschiedener Code.
Jetzt kannst du natürlich verlangen, dass diese Unterscheidung auch noch von der Hochsprache übernommen wird. Das kann man so machen, die meisten Interpretersprachen machen das so. Dazu brauchst du aber trotzdem eine Information über den eigentlichen Variablen-Typ. Dafür wäre Variant (also array of Variant) geeignet. Geht aber mit Performanceeinbußen daher.

s.

[himitsu]

Es gibt

Delphi-Quellcode:

array of const

, also offener und fast untypisiertes Open-Array-Parameter (siehe Format)
oder

Delphi-Quellcode:

array of variant

.

Für Beides brauchst du nur eine Prozedur zusammen ... kommt aber darauf an, wie die Parameter übergeben werden sollen.

Werden aber Array-Variablen übergeben, dann kannst/mußt du die beiden Prozeduren so lassen und Diese nur als

Delphi-Quellcode:

overload

deklarieren.

[Uwe Raabe]

Wenn wirklich das gleiche gemacht wird (was eigentlich?), würde sich eine generische Methode anbieten (ich weiß, Delphi 5, aber darunter geht ja sowieso fast gar nichts).

Delphi-Quellcode:

type
  TMyClass = class
  public 
    procedure MeineProzedur<T>(Meinparameter: TArray<T>);
  end;

procedure TMyClass.MeineProzedur<T>(Meinparameter: TArray<T>);
var
  myVar: T;
begin
  for myVar in Meinparameter do
    { tue was auch immer mit myVar }
end;

[jaenicke]

Was machen denn die Funktionen konkret? Vielleicht gibt es ja eine andere Lösung.

Mit Generics ließe sich sicher viel machen, aber da im Profil D5 steht, fällt das ja flach...

[FriendOfDelphi]

Zitat:

Zitat von chaosben (Beitrag 1119295)

Der älteste Weg das zu erreichen, ist einen untypisierten Pointer zu übergeben.
Alternativ ein Record, das alle versch. Typen kennt und ein Feld hat, was angibt, welcher Typ benutzt werden soll.
Alternativ ein Variant.
Alternativ eine Array of Variant.
Alternativ eine Basisklasse und Ableitungen davon.

:-D

Die Idee mit dem untypisierten Zeiger gefällt mir am besten.
Nur habe ich ein Problem mit der Typisierung des übergebenen Zeiger.

Ich übergebe einen Zeiger auf eine Variable vom Typ record.
Der Record sieht so aus:

Delphi-Quellcode:

type
  TMeinTyp = record
             Var1: Array [0..10] of SmallInt;
             Var2: Integer;
end;

//...

var
  MeineVar : TMeinTyp;

//...

//Aufruf der Prozedur mit:
MeineProzedur(MeineVar);

//Prozedur
procedure TForm1.MeineProzedur(aArray: Pointer);
begin
  TMeinTyp(aArray^).Var1[index]:=1;  //so funktioniert es

  //der Typ "TMeinTyp" ist aber in einer anderen Unit deklariert, die ich nicht verwenden will
  //ich möchte daher direkt auf den "SmallInt"-Teil des Records zugreifen
  //geht das?
  Array [0..6] of SmallInt(aArray^).Var1[index]:=1; //so funktioniert es nicht. Der Compiler meldet: "Anweisung erwartet, aber 'ARRAY' gefunden"
  //mache ich etwas falsch (Syntax), oder funktioniert das nicht?
end;

[jaenicke]

Das ist doch wohl Blödsinn. Du willst einen allgemeinen Typen übergeben und castest dann doch wieder auf SmallInt?!

Deshalb meine Frage: Was hast du konkret mit den übergebenen Werten vor? An andere Funktionen übergeben, damit rechnen, ...

[Uwe Raabe]

Du solltest das Design deiner Anwendung überdenken!

[FriendOfDelphi]

Zitat:

Zitat von jaenicke (Beitrag 1119336)

Das ist doch wohl Blödsinn. Du willst einen allgemeinen Typen übergeben und castest dann doch wieder auf SmallInt?!

Deshalb meine Frage: Was hast du konkret mit den übergebenen Werten vor? An andere Funktionen übergeben, damit rechnen, ...

Na ja ganz so einfach ist es nicht.
Es existieren insgesamt 5 verschiedene Records.

Der Prozedur werden zwei weitere Parameter übergeben:
2.Parameter: eine(Objekt-)Liste und
3.Parameter: Name des übergebenen Tys ("TMeinTyp1", "TMeinTyp2", "TMeinTyp3" usw.)

In dieser Liste werden Werte verwaltet.
In den einzelnen Einträgen der Liste ist gespeichert, aus welchem Rekord(typ) dessen Wert ausgelesen werden soll.

Innerhalb der Prozedur werden nun alle Einträge durchlaufen.
Im jeweiligen Listeneintrag wird verglichen, ob der übergebene Rekord(typ) für den aktuellen Eintrag gültig ist.
Wenn ja, sollen die einzelnen Teile aus dem übergebenen Rekord in dem zugehörigen Listeneintrag gespeichert werden.
Wenn nein, wird die Schleife fortgesetzt.

Wenn für jeden Record eine eigene Prozedur existiert funktioniert das.
Ich möchte aber eine Prozedur für alle Recordtypen haben.

Was ist jetzt daran Blödsinn?