implementation-teil einer Array-Routine?

[3_of_8]

Hallo! Ich habe ein Array, das Prozeduren enthält. Jetzt die Frage: Wie kann ich die implementieren?

Geht das z.B. so (bei statischen Arrays):

Delphi-Quellcode:

procedure TMyClass.procedures[0](bla: String);
begin

end;

Wahrscheinlich nicht.

Muss ich da wirklich eine Nicht-Array Prozedur deklarieren und implementieren, und nachher ihren Zeiger der Array-Prozedure zuweisen?

[Der_Unwissende]

Hi,
also wenn du ein Array von Proceduren hast, dann benutzt du (imho) kein Delphi. Du hast höchstwahrscheinlich nur ein Array von Prozedurzeigern.
Denke mal, damit ist dir schon klar was der richtige Weg ist, du nennst ihn ja auch schon. Du musst alle Proceduren ganz normal (ohne Array) implementieren und speicherst nur einen Zeiger auf die Funktion (oder schöner gesagt eine Referenz).
Der Aufruf sähe dann so aus, wie du es stehen hast:

Delphi-Quellcode:

var bla : String;
begin
  bla := 'Blubb'
  self.procedures[0](bla);
end;

Gruß Der Unwissende

[3_of_8]

Ich habe ein array of TMyEvent; wobei TMyEvent=procedure(arguments: array of TVariable); ist.

Dass das natürlich nur Routinenzeiger sind, ist mir schon klar. Aber du sagst ja auch nicht "ein Zeiger auf ein Memo" sondern "ein Memo".

[Phistev]

Zitat von 3_of_8:

Aber du sagst ja auch nicht "ein Zeiger auf ein Memo" sondern "ein Memo".

Na und? Objekte sind auch "nur" Zeiger auf (spezielle) Records. Der Rest ist Compiler-Magic.

[Der_Unwissende]

Zitat von 3_of_8:

Dass das natürlich nur Routinenzeiger sind, ist mir schon klar. Aber du sagst ja auch nicht "ein Zeiger auf ein Memo" sondern "ein Memo".

Nun ja, tue ich das? Ich sage ein Memo statt TMemo, dass schon. Aber zu dem was übergeben wird würde ich Referenz auf ein Memo sagen (ok, wahrscheinlich auch manchmal nur Memo), ist halt kontextsensitiv.
In dem geg. Kontext wollte ich auch nicht dich diskreditieren, wollte nur sagen warum du es so nicht implementieren könntest. Ein Array ist halt nur eine Struktur.
Ein sehr einfacher Nachbau eines Arrays (entspricht nicht mehr der Strucktur heutiger Arrays) ist es, dass du dir einfach nur die Position des ersten Elementes PFirst merkst (als Zeiger) und wie groß jedes Element ist. Dann kannst du an der Adresse PFirst + (i*SizeOf(Element)) das i-te Element des Typs Element abgreifen.

So ist es halt auch mit Funktionszeigern, du hälst nur Zeiger auf die Funktion. Du kannst nur direkt einen Zeiger auf die entsprechende Funktion an einer Stelle speichern, aber eben nicht mehr machen (also gut, den Zeiger ändern oder auslesen). Du kommst also nicht darum herum die Methode an einer anderen Stelle zu implementieren.

Gruß Der Unwissende

[3_of_8]

Das habe ich verstanden und mir ja auch schon gedacht.

Und ich meinte oben, dass du ja, wenn du ein TMemo instantiierst kein direktes TMemo hast, sondern einen Zeiger auf eben jenes. Und trotzdem sagst du TMemo bzw. Memo dazu.

Und genauso sage ich auch nicht "Zeiger auf eine Routine" sondern "Routine".

[Der_Unwissende]

Zitat von 3_of_8:

Und ich meinte oben, dass du ja, wenn du ein TMemo instantiierst kein direktes TMemo hast, sondern einen Zeiger auf eben jenes.

Nun ja, wenn ich ein Memo instanziiere, dann hab ich natürlich auch ein TMemo Schon klar was du meinst.

Zitat von Phistev:

Na und? Objekte sind auch "nur" Zeiger auf (spezielle) Records. Der Rest ist Compiler-Magic.

Na und? Zeiger und Records sind auch nur im Speicher liegende Bits. Der Rest ist Compiler-Magic. Ist in beiden Fällen komplett falsch, könnte man aber so formulieren, was möchtest du damit sagen?