Function mit mehreren Rückgabewerten

[Dennis07]

Wäre natürlich schön, wenn Delphi nativ Tupel unterstützen würde. Python kann das sehr schön:

Code:

def give_two:
  return 1, 2

one, two = give_two()

In Delphi gibt es da nur drei möglichkeiten:

1. Du gibst ein Array oder IEnumerable-Objekt zurück
2. Du deklarierst die einen Record und gibst ihn zurück
3. Du verwendest out- (oder var-) Parameter

[freimatz]

Zitat von Dennis07:

... nur drei ...

Nein.

[Blup]

Zitat von freimatz:

Zitat von Elvis:

Gibt es eigentlich irgendeinen speziellen Grund, warum es hier normal zu sein scheint, reine Ausgabeparameter als "var" anstatt als "out" zu deklarieren?

das out wurde erst später in Delphi implementiert. Also ich vermute eines dieser drei: Gewohnheit, Faulheit und/oder Ignoranz.

Man muss nur wissen das Delphi für gemanagte Typen out tatsächlich als var implementiert.
Das bedeuted der Parameter wird immer vor dem Aufruf (zumindest leer bzw. nil) initialisiert, nicht innerhalb.
Eine Eigenheit die man bei Verwendung anderer Programmiersprachen berücksichtigen muss.

[Stevie]

Zitat von Blup:

Das bedeuted der Parameter wird immer vor dem Aufruf (zumindest leer bzw. nil) initialisiert, nicht innerhalb.

Eigentlich sogar beides - siehe https://delphisorcery.blogspot.com/2...t-bad-var.html

[himitsu]

Noch besser ... das Result, wird bei "Managed Types" und für Typen größer der CPU-RegisterGröße (Record und Static-Array) intern als VAR-Parameter behandelt,
womit das Result nicht innerhalb der Funktion initialisiert wird, sondern beim Aufrufer, was in einer Schleife echt wunderschöne Ergebnisse liefert.

Delphi-Quellcode:

funtion Test: string
begin
  Result := Result + 'a';
end;

var
  S: string;
begin
  for var i := 1 to 3 do begin
    S := Test;
    ShowMessage(S);
  end;
end;

Besonders praktisch, da es für Result (wenn managed) keine Meldung gibt, dass Dieses nicht initialisiert sei (was ja prinzipiell "eigentlich" auch richtig ist, aber logisch nicht wirklich verständlich)

[Sinspin]

Zitat von Dennis07:

Wäre natürlich schön, wenn Delphi nativ Tupel unterstützen würde. Python kann das sehr schön:

Code:

def give_two:
  return 1, 2

one, two = give_two()

In Delphi gibt es da nur drei möglichkeiten:

1. Du gibst ein Array oder IEnumerable-Objekt zurück
2. Du deklarierst die einen Record und gibst ihn zurück
3. Du verwendest out- (oder var-) Parameter

Wärend die Schlange nur zischt, hat das Orakel Antworten.

Ich finde Python hier unscharf und unklar.
Die Optionen die Delphi einem gibt bedeuten mehr Schreibaufwand aber auch deutlich bessere Lesbarkeit.
Gerade durch die Rückgabe oder Verwendung eines Interfaced Objektes bekommt man unendliche Freiheit. Und, das sogar ohne sich auf die Anzahl der Parameter festlegen zu müssen.
Natürlich kann sowas in Speicherverschwendung ausarten. Jede Münze hat halt zwei Seiten.

[Stevie]

Tuple unpacking ist ein ziemlich klares und verständliches Konzept.

Was an dem Code oben etwas ungewohnt ist, ist die Typinferenz bei der give_two Funktion.
Aber wenn man klareren Code schreiben will, dann kann man auch Type Hints (seit Python 3.9) und den Tuple Konstructor explizit nutzen:

Code:

def give_two() -> tuple[int,int]:
  return (1, 2)

[Rollo62]

Zitat von himitsu:

Für sowas nutze ich dann einfach Attribute oder Kommentare, als "Dokumentation".

Delphi-Quellcode:

procedure GibMir([out] Variable: string);

procedure GibMir({out} Variable: string);

/// <summary> gibt mir eine Variable </summary>
/// <param name="Variable"> [OUT] hier rein </param>
procedure GibMir(Variable: string);

Ja, sehr schön.

Zusätzlich bin ich ein großer Freund sprechender Variablen, also könnte das auch in den meisten Fällen reichen:

Delphi-Quellcode:

procedure GibMir( AInput, AOutput: string);
begin
    AOutput := AInput + '...';
end;

Das hat sogar den schönen Vorteil, dass ich auch innerhalb der Funktion sofort weiss, was die Parameter so machen sollen.