Variable Argumente

[Lucaito]

So, ich wollt mal von euch wissen, ob folgendes vllt möglich ist:

Ich will eine Funktion, die ein Argument erwartet. Das Argument wird in einer Case-Verzweigung ausgewertet...
Bei einem bestimmten Argument soll dann allerdings noch ein zweites mitgegeben werden, was ich dann brauche, allerdings nur bei diesem bestimmten.

Hoffe meine Frage is verstaendlich und nich zu kompliziert formuliert. :)

Im hoffen auf Antworten, Luc~

PS: Und nein, ich meine keine Variable langen Argumentlisten, das würde nämlich nich damit gehn, da meine Argumente verschiedene Typen ham ;(

[quendolineDD]

Dein Stichwort ist Overload. Damit kannst du gleichnahmige Funktionen mit unterschiedlichen Parametern definieren.

Delphi-Quellcode:

  function MachWas(i : Integer) : Boolean; overload;
  function MachWas(p : Pointer; l : Integer) : Boolean; overload;

[DeddyH]

Meinst Du so etwas (sinnfreies Beispiel)?

Delphi-Quellcode:

function EineFunction(intvar: integer; stringvar: string = ''): integer;
begin
  case intvar of
    0: Result := 0;
    1: if stringvar = 'Wuppdi' then
         Result := 1
       else
         Result := -1;
    else
      Result := 2; 
  end;
end;

[leddl]

Zitat:

Zitat von quendolineDD

Dein Stichwort ist Overload.

Nö, das hilft doch hier gar nichts. Interessanter sind da Standardparameter ;)

Delphi-Quellcode:

function NeFunktion(parameter1 : String; parameter2 : String = '') : Boolean

Der zweite Parameter muss nicht angegeben werden und wäre in dem Fall dann ein leerer String.

[jaenicke]

Zitat:

Zitat von Lucaito

PS: Und nein, ich meine keine Variable langen Argumentlisten, das würde nämlich nich damit gehn, da meine Argumente verschiedene Typen ham ;(

Das ginge auch, siehe den Befehl Format z.B., sowas kann man als array of const zum Beispiel lösen. Ob es hier eine passende Lösung ist, musst du selbst überlegen. ;-)

[Lucaito]

Hui das ging mal wieder schnell. :D

Zitat:

Zitat von quendolineDD

Dein Stichwort ist Overload.

Gute Idee... xD
Wollt zwar eig alles in eine Function packen, sollte aber auch damit wunderbar funzen, danke dafür! :)

Zitat:

Zitat von leddl

Delphi-Quellcode:

function NeFunktion(parameter1 : String; parameter2 : String = '') : Boolean

Der zweite Parameter muss nicht angegeben werden und wäre in dem Fall dann ein leerer String.

D.h. ich kann die Funktion dann auch mit

Delphi-Quellcode:

NeFunktion('blub');

aufrufen?
Wär natürlich perfekt :)

Zitat:

Zitat von jaenicke

Zitat:

Zitat von Lucaito

PS: Und nein, ich meine keine Variable langen Argumentlisten, das würde nämlich nich damit gehn, da meine Argumente verschiedene Typen ham ;(

Das ginge auch, siehe den Befehl Format z.B., sowas kann man als array of const zum Beispiel lösen. Ob es hier eine passende Lösung ist, musst du selbst überlegen. ;-)

Ich denk ich werd ich einem der andern beiden Beispiele bedienen, dennoch danke für die antwort! :)

[himitsu]

Das mit den Const-Parametern entspricht mehr einem dynamischen Array of Variant, was einen etwas höheren Verwaltungsaufwand bedeutet.

beim Overload kannst du auch einfach den Aufruf weiterleiten (in der einen Funktion die Andere, mit dem ergänztem Parameter, aufrufen)

und zu den Default-Parametern:
das wäre die effektivste Variante, denn dort setzt der Compiler bei nicht angegebenen Parametern direkt den Defaultwert ein.

Delphi-Quellcode:

// die Definition:
function NeFunktion(parameter1 : String; parameter2 : String = '') : Boolean

// du programmierst das so
NeFunktion('blub');

// und nach dem kompilieren steht effektiv dieses in der EXE
NeFunktion('blub', '');

also JA, du kannst es so machen

[Lucaito]

Gut, danke für die Hilfe, ich denke ich werd die Sache mit den Standardargumenten nehmen. ^^

Greetz, Luc~

[hoika]

Hallo,

eine andere, aufwendigere Methode wäre die Verwendung
einer Parameter-Klasse, also einer eigenen Klasse für
die verschiedenen Parameter.

Vorteil ist die einfache Erweiterbarkeit,
wenn neue Parameter hinzukommen sollen.


Heiko