Unendlich Parameter

[DarkItachi]

Hallöchen!

Wie kann man eine Procedure mit unendlich Parametern schreiben? Also wie ist die Syntax dafür?
WriteLN() hat das ja, aber ich finde WriteLN() nicht in der System-Unit...

Könnte mir das jemand erklären?

Dankeschön:-D

[Klaus01]

Hi Julian,

unendliche Anzahl an Parametern verschiedener Typen,
oder unendliche Anzahl eines Typs?

Grüße
Klaus

[DarkItachi]

In meinem Falle: Unendliche Anzahl von Strings;
Dabei soll das kein StringArray oder ähnliches sein...
Denn das wüsste ich ja schon... Ich will ja alles wissen ;)


BTW:
Ahhh. Auszug aus System.pas:

Code:

{ Predefined constants, types, procedures, }
             { and functions (such as True, Integer, or }
             { Writeln) do not have actual declarations.}
             { Instead they are built into the compiler }
             { and are treated as if they were declared }
             { at the beginning of the System unit.     }

[rollstuhlfahrer]

Die Format-Funktion nimmt "unendlich viele" Parameter entgegen, allerdings brauchst du dann ein

Delphi-Quellcode:

array of const

.

Bernhard

[DarkItachi]

gibt es dann noch eine andere Möglichkeit?

Ich möchte nämlich eine procedure schreiben, die öffentlich zugänglich ist, und kein User die Procedure ändern muss, damit er sie nutzen kann...

Ein Beispiel wäre eine ListView.Items.Add procedure:

Code:

procedure sProc1(a: TListView; [P1; [..., PN]]);
begin
 With a.Items.Add do begin

 end;
end;

Also wie die WriteLN procedure

[Klaus01]

.. bei WriteLn ist das Compiler Magic.
Ein Beispiel mit array of const kannst Du hier finden.

Grüße
Klaus

[himitsu]

bei einem Typ:

Delphi-Quellcode:

array of ...

(dieses muß aber in der Prozedur und nicht alseigentständiger Typ deklariert sein, also als Open-Array)
bei unbestimmten/gemischten Typen:

Delphi-Quellcode:

array of const

.
ansonsten gibt es noch die vordefinierten Parameter und überladene Prozeduren.

Delphi-Quellcode:

// beliebig viele Integer
procedure Test(Params: array of integer);

// beliebig viele gemischte Typen
procedure Test(Params: array of const);

// vordefiniert, mit einem Festen und 2 dynamischen Parametern, welche man setzen kann oder auch nicht
procedure Text(Param1: Integer; Param2: Integer = 0; Param3: Integer = 0);

// überladen (1 bis 3 Parameter)
procedure Text(Param1: Integer); overload;
procedure Text(Param1, Param2: Integer); overload;
procedure Text(Param1, Param2, Param3: Integer); overload;

Sowas wie WriteLn kann man leider nicht selber deklarieren :cry:

[mkinzler]

Oder lege ein Funktion mit sehr vielen vorbelegten Parametern an

Delphi-Quellcode:

  function MachWas( a: string; b: string = ''; c: string = ''; ...): string;

  ...

implementation


function MachWas( a: string; b: string = ''; c: string = ''; ...): string;
begin
    Result := a+b+c+...;
end;

[Aphton]

Zitat:

Zitat von Klaus01 (Beitrag 1070890)

.. bei WriteLn ist das Compiler Magic.

Kannst du das genauer erläutern? Evt. kann man da ja mit einem kleinen Hack etwas draus machen?!

MfG

[mkinzler]

Wenn du dir einen eigenen Compiler schreibst :green:
Compiler magic bedeutet dass es keine normale Funktion ist sondern von Compiler direkt umgesetzt wird