Gleiche Prozedur mit verschiedenen Parametertypen aufrufen

[FriendOfDelphi]

Zitat von 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.

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

[FriendOfDelphi]

Zitat von 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, ...

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?

[jaenicke]

Also ich kann mir zwar noch nicht 100%ig vorstellen was du da machst, aber es hört sich so an als ob du mit Klassen und Vererbung weiterkommen solltest.

Dann kannst du konkrete Klasse einfach als Typ der Basisklasse übergeben. Und du kannst in den abgeleiteten Klassen bestimmte abweichende Funktionalitäten implementieren (überschriebene Methoden, ...), die dann über die Basisklasse aufgerufen werden kann.

Aber wie Uwe Raabe schon sagte:
Ich glaube auch das Problem ist eher das Gesamtkonzept...

Zitat von FriendOfDelphi:

Was ist jetzt daran Blödsinn?

Damit meinte ich verschiedene Typen zu übergeben und dann den Typ doch wieder zu unterscheiden. Wenn, dann macht eine gemeinsame Prozedur nur Sinn, wenn der größte Teil der Prozedur auch unabhängig vom konkreten Typ funktioniert.

[FriendOfDelphi]

Zitat von jaenicke:

Also ich kann mir zwar noch nicht 100%ig vorstellen was du da machst, aber es hört sich so an als ob du mit Klassen und Vererbung weiterkommen solltest.

Dann kannst du konkrete Klasse einfach als Typ der Basisklasse übergeben. Und du kannst in den abgeleiteten Klassen bestimmte abweichende Funktionalitäten implementieren (überschriebene Methoden, ...), die dann über die Basisklasse aufgerufen werden kann.

Aber wie Uwe Raabe schon sagte:
Ich glaube auch das Problem ist eher das Gesamtkonzept...

Zitat von FriendOfDelphi:

Was ist jetzt daran Blödsinn?

Damit meinte ich verschiedene Typen zu übergeben und dann den Typ doch wieder zu unterscheiden. Wenn, dann macht eine gemeinsame Prozedur nur Sinn, wenn der größte Teil der Prozedur auch unabhängig vom konkreten Typ funktioniert.

Das Problem ist, dass ich mein Programm mit dem eines Kollegen zusammenführen muss. Und der arbeitet halt mit diesen Records, die ich nun benutzen muss.
Um nochmal auf das ursprüngliche Problem zurück zu kommen:
Kann ich denn über ein typcasten auf die einzelnen Teile des Records zugreifen?
Wenn ja, wie ist die richtige Syntax.

[hoika]

Hallo,

Delphi-Quellcode:

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

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

Tue das gleiche kann nicht sein,
es sind 2 verschiedene Arrays.


Heiko

[jaenicke]

Zitat von FriendOfDelphi:

Kann ich denn über ein typcasten auf die einzelnen Teile des Records zugreifen?
Wenn ja, wie ist die richtige Syntax.

Ich habe ein wenig gezögert, weil ich nicht sicher bin, ob es sinnvoll ist einen derart grausamen Hack für diesen Fall zu posten... aber ist ja nicht mein Code, in den der Schrott eingebaut wird...

Delphi-Quellcode:

type
  TTestA = record
    a, b: LongInt;
  end;

  TTestB = record
    a: string;
    b: LongInt;
  end;

procedure Test(Value: Pointer);
begin
  ShowMessage(IntToStr(PLongInt(Integer(Value) + 4)^));
end;

var
  a: TTestA;
  b: TTestB;
begin
  a.b := 777;
  b.b := 666;
  Test(@a);
  Test(@b);
end;

[Uwe Raabe]

Du solltest das Design deiner Anwendung überdenken!