Two Fer

Anleitung

Deine Aufgabe ist es, zu entscheiden, was du sagst, wenn du den zusätzlichen Keks verschenkst.

Wenn du den Namen der Person kennst (z. B. wenn sie Do-yun heißt), sagst du:

One for Do-yun, one for me.

Wenn du den Namen der Person nicht kennst, sagst du stattdessen you.

One for you, one for me.

Hier sind ein paar Beispiele:

Odin-spezifische Anweisungen

Odin unterstützt Standardargumente. Standardargumente sind ein nützliches Feature: Sie erlauben es, eine Prozedur mit unterschiedlichen Parametersätzen aufzurufen, wenn du verwandte, aber unterschiedliche APIs brauchst.

Ohne Standardargumente kann die Zahl der Prozeduren, die deine API braucht, geradezu explodieren. Sprachen, die keine Standardargumente unterstützen, wie Java, erreichen denselben Effekt mit Methodenüberladung (und mehr Code) oder müssen Prozeduren mit potenziell vielen Argumenten anbieten.

Nehmen wir als Beispiel eine Prozedur greeting, bei der wir die Sprache angeben können wollen, außerdem ob der Name in Großbuchstaben geschrieben wird und ob am Ende der Begrüßung ein Ausrufezeichen stehen soll. Nach einer Analyse haben wir festgestellt, dass die größte Gruppe der Nutzer Englisch als Sprache angibt, den Namen nicht in Großbuchstaben schreibt und kein Ausrufezeichen am Ende möchte; die zweitgrößte Gruppe hängt ein Ausrufezeichen an das Ende der Begrüßung.

Wir könnten eine einzige Prozedur mit allen Argumenten schreiben:

greeting :: proc(name: string, language: Language, do_uppercase: bool, add_exclamation: bool) {
	...
}

Das würde alle Nutzer zwingen, die Dokumentation für alle Argumente zu lesen und sie immer zu belegen.

Ohne Standardargumente könnten wir auch mehrere Prozeduren mit unterschiedlichen Parametersätzen definieren:

greeting_common :: proc(name: string) {...}

greeting_with_exclamation :: proc(name: string) {...}

greeting_general :: proc(name: string, language: Language, do_uppercase: bool, add_exclamation: bool) {...}

// Odin supports overloading but it has to be explicitly defined
greeting :: proc {
	greeting_common,
	greeting_with_exclamation,
	greeting_general,
}

Wenn deine Sprache Standardargumente unterstützt, so wie Odin, kannst du den am wenigsten genutzten Argumenten einfach sinnvolle Standardwerte geben. Aufrufer können die Standardargumente weglassen, dann verwendet die Prozedur die hinterlegten Standardwerte, oder sie überschreiben sie.

greeting :: proc(name: string, language: Language = Language.English, do_uppercase : bool = false, add_exclamation: bool = false) {...}

// Note: because Odin supports type inference, we can simplify the interface.
greeting :: proc(name: string, language:= Language.English, do_uppercase := false, add_exclamation:= false) {...}

Die Prozedur lässt sich mit lauter Standardargumenten aufrufen:

greeting("John Doe")

Argumente, die dem Aufrufer wichtig sind, kann er überschreiben:

greeting("John Doe", Language.Spanish)

Wenn die Argumente, die du brauchst, in der richtigen Position stehen, wie im Beispiel oben, musst du sie nicht benennen; wenn du aber welche überspringen willst, musst du die Argumente nach dem ersten übersprungenen benennen.

greeting("John Doe", add_exclamation=true)

Speicherverwaltung

In dieser Übung implementierst du eine Prozedur, die den String, den sie zurückgibt, allozieren soll. Die Freigabe des Strings liegt in der Verantwortung des Aufrufers der Prozedur.

// The procedure will be called like that:
str := two_fer("Alice")
// ...
// and eventually the caller will delete the string
delete(str)

Vielleicht interessiert dich auch die offizielle Odin-Dokumentation zu Standardargumenten und zu benannten Argumenten in Odin.