Autor Beitrag
Der Blaue Gott Balmung
Hält's aus hier
Beiträge: 13

WinXP

BeitragVerfasst: Sa 24.09.05 19:07 
Hi,

Wie programmiert man solche überladenen Funktionen? Hab schon überall nachgeguckt, wo's nicht steht ;(
Könnt ihr mir 'nen Tipp, Link o.ä. posten wie es geht oder wie ich es herausfinde?

Beispiel:
Zitat:
Syntax


[Delphi] function Format(const Format: string, var Args: array of TVarRec): string;



[Delphi] function Format(const Format: string, var Args: array of TVarRec, var FormatSettings: TFormatSettings): string;



Das geht aber nur wenn man eine Klasse programmiert, oder?
Gibt es dann auch die Möglichkeit einen Ähnlichen Effekt mithilfe von Compiler-Direktiven zu erreichen?
(Ich will nicht jedesmal 'ne Klasse proggen, wenn ich mal schnell was für die Schule machen muss und zumindest
die Funktionen ausarbeiten will, falls ich sie nochmal in einem anderen Zusammenhang brauche.)

Und dann wäre da noch eine andere Frage, nämlich, wie man eine Funktion mit unendlich vielen Parametern schreibt.
(Da hab ich erst was mit Arrays gefunden, sieht aber nicht sehr sauber aus.)

Ich freue mich über jede Hilfe.
Und schon mal vielen Dank im Vorraus. :)


Moderiert von user profile iconChristian S.: Topic aus Sonstiges verschoben am Sa 24.09.2005 um 20:10
Heiko
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 3169
Erhaltene Danke: 11



BeitragVerfasst: Sa 24.09.05 19:14 
user profile iconDer Blaue Gott Balmung hat folgendes geschrieben:
Wie programmiert man solche überladenen Funktionen?

Wo ist das bei dir eine überladene Funktion? Und ich weiß auch nicht wo dein Problem liegt, kannst du es vlt. besser erklären, oder den genauen Zweck?



user profile iconDer Blaue Gott Balmung hat folgendes geschrieben:
Gibt es dann auch die Möglichkeit einen Ähnlichen Effekt mithilfe von Compiler-Direktiven zu erreichen?

Compilerdirektiven braucht man eigentlich so gut wie nie (ich habe sie bisher nie gebraucht) und wüsste auch nicht wozu du die hier brauchst.

user profile iconDer Blaue Gott Balmung hat folgendes geschrieben:
Und dann wäre da noch eine andere Frage, nämlich, wie man eine Funktion mit unendlich vielen Parametern schreibt.
(Da hab ich erst was mit Arrays gefunden, sieht aber nicht sehr sauber aus.)

Unendlich viele Parameter wäre sinnlos, da Delphi dann nicht weiß wieviel nun kommen. Und wie willst du dann herausbekommen wieviel Parameter nun übergeben wurden und dann diese auch noch einzelnd verarbeiten? Außerdem sind arrays übersichtliger und es lässt sich auch besser damit arbeiten.


user profile iconDer Blaue Gott Balmung hat folgendes geschrieben:
Ich freue mich über jede Hilfe.

darauf setzt man hier im Forum ;)

mfg
Heiko
alzaimar
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 2889
Erhaltene Danke: 13

W2000, XP
D6E, BDS2006A, DevExpress
BeitragVerfasst: Sa 24.09.05 19:38 
user profile iconHeiko hat folgendes geschrieben:
Compilerdirektiven braucht man eigentlich so gut wie nie (ich habe sie bisher nie gebraucht) und wüsste auch nicht wozu du die hier brauchst.

Wenn man Tools schreibt, die für die verschiedenen Delphi-Versionen passen sollen, kommt man nicht ohne Direktiven nicht aus.

_________________
Na denn, dann. Bis dann, denn.
Brueggendiek
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 304

Win 98, Win98SE, Win XP Home
D5 Std
BeitragVerfasst: So 25.09.05 01:55 
Hallo!

user profile iconDer Blaue Gott Balmung hat folgendes geschrieben:
Das geht aber nur wenn man eine Klasse programmiert, oder?


Wie bitte?
Bei meinem D5 Standard funktioniert das mit Overload auch ohne Klassen zu meiner vollsten Zufriedenheit.
Was "unendlich" viele Parameter betrifft: Da hilft nur ein Array.

Gruß

Dietmar Brüggendiek
Der Blaue Gott Balmung Threadstarter
Hält's aus hier
Beiträge: 13

WinXP

BeitragVerfasst: Mo 26.09.05 17:01 
Hi,

Ok, dann habe ich das wohl falsch erklärt. Also nochmal:
Die Besonderheit von format() liegt doch darin, dass unterschiedliche Parameter übergeben werden können. Ich weiß nicht, ob der letzte Wert ein Standartwert ist, aber in dem Beispiel sollte es kein Standartwert sein *g* also wenn's sein muss die Fantasie anstrengen.

Das heißt ich brauche eine Funktion, die ich jeweils mit unterschiedlichen Parametern aufrufen kann. Diese Parameter sollen keine Standartwere sein.

Wenn die Frage nach der Anwendung laut wird:
Eine Vorstellbare Funktion ToString(x) könnte x egal zu welchem Typ es gehört zu einem String konvertieren.

So viel ich weiß gibt es dieses Konzept in Java (aber Objektabhängig) und ich hab mich halt gefragt ob das in Delphi nicht auch (und sogar Objektunabhängig mit Compiler-Direktiven) geht.

Und zum letzten Punkt mit den unendlichen Parametern hab ich nochmal die Funktion
Concat(var1,var2,...,varn : string) : string; ausgegraben, die ihre Parameter zu einer Kette verknüpft.
(Mit der Array alternative sähe die Funktion so aus :
MyConcat([var1,var2,...,varn]) : string; also mit hässlichen Klammern und der Typ wäre nicht vorgegeben, was ein Problem betreffend der Kapselung darstellt)

Heiko hat folgendes geschrieben:
Der Blaue Gott Balmung hat folgendes geschrieben:

Ich freue mich über jede Hilfe.

darauf setzt man hier im Forum ;)


Klar, ich wollte es nur nochmal betonen :)

@Brueggendiek: Kannst du mir das mit dem Overload bitte nochmal erklären
(Ich gehe gerade davon aus, dass du unwahrscheinlicherweise die erste Erklärung richtig verstanden hast)

Hab ich das jetzt verständlich ausgedrückt?
und wieder mal vielen Dank im Vorraus. ;)
Sprint
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 849



BeitragVerfasst: Mo 26.09.05 17:31 
user profile iconDer Blaue Gott Balmung hat folgendes geschrieben:
Das heißt ich brauche eine Funktion, die ich jeweils mit unterschiedlichen Parametern aufrufen kann. Diese Parameter sollen keine Standartwere sein.

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
unit Unit2;

interface

uses
  SysUtils;

function MyFunction(const AValue: String): String; overload;
function MyFunction(AValue: Integer): String; overload;

implementation

function MyFunction(const AValue: String): String; overload;
begin
  Result := AValue;
end;

function MyFunction(AValue: Integer): String; overload;
begin
  Result := IntToStr(AValue);
end;


MyFunction kannst du dann entweder mit MyFunction('abc') oder mit MyFunction(123) aufrufen.

Andere alternative wäre per array of const und dann nur den ersten Parameter auswerten.

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
unit Unit2;

interface

uses
  SysUtils;

function MyFunction(const AValue: array of const): String;

implementation

function MyFunction(const AValue: array of const): String;
begin
  Result := '';
  if Length(AValue) > 0 then
  begin
    with TVarRec(AValue[0]) do
    begin
      case VType of
        vtInteger: Result := IntToStr(VInteger);
        vtAnsiString: Result := AnsiString(VString);
      end;
    end;
  end;
end;

end.


Aufrufen dann über MyFunction(['abc']) oder MyFunction([123])

_________________
Ciao, Sprint.
Grishnak
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 221

Windows XP Home
Delphi 7 PE, Delphi 2005 PE
BeitragVerfasst: Mo 26.09.05 17:36 
1.) Eine Funktion/Prozedur zu überladen geht ungefähr so:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
interface

function toString(I: integer): string; overload;
function toString(S: string): string; overload;
function toString(B: boolean): string; overload;

[...]

implementation

function toString(I: integer): string;
begin
  Result:=IntToStr(I);
end;

function toString(S: string): string;
begin
  Result:=S;
end;

function toString(B: boolean): string;
begin
  if B
    then Result:='true'
    else Result:='false';
end;


Wichtig dabei ist, dass 1.) alle überladene Funktionen/Prozeduren per 'overload' deklariert werden müssen (also auch die Erste!); 2.) die einzelnen Funktionen/Prozeduren anhand der übergebenen Variablen eindeutig erkennbar sein müssen!

2.) Unendlich viele Parameter (verschiedenen Typs):

Such mal nach dem Stichwort "array of const" in der Delphi-Hilfe!

_________________
Mach' etwas idiotensicher und irgendjemand erfindet einen besseren Idioten!
Der Blaue Gott Balmung Threadstarter
Hält's aus hier
Beiträge: 13

WinXP

BeitragVerfasst: Di 27.09.05 16:11 
Hi,

Vielen Dank Grishnak und Sprint. Die Erklärungen hab ich verstanden. Kann ich gut gebrauchen :)

@Brueggendiek: Sorry, dass ich deine Antwort nicht gleich weiterverfolgt habe. Ich hätte danach ja bloß nach Overload suchen müssen :autsch: , war grad bisschen im Stress

Ok, wenn das 2. nur mit dem array of const geht find ich mich halt damit ab :(

Cu
UGrohne
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Veteran
Beiträge: 5502
Erhaltene Danke: 220

Windows 8 , Server 2012
D7 Pro, VS.NET 2012 (C#)
BeitragVerfasst: Di 27.09.05 18:39 
Eine kleine Anmerkung an den Thread-Autor: Ich lasse das hier jetzt mal stehen, aber normalerweise sollte in jedem Topic nur eine Frage gestellt werden. Fuer Deine Frage nach unendlichen Parametern solltest Du in Zukunft also einen zweiten Thread aufmachen, damit die Uebersicht gewahrt bleibt.

Der Thread wurde zu spaet entdeckt, daher lass ich das aber jetzt mal so, ansonsten waere er schon gesperrt worden ;)