Variadische Funktion

Im Mathematik und in Computerprogrammierung, a Variadische Funktion ist ein Funktion von unbestimmt Arity, d.h. eine, die eine variable Anzahl von akzeptiert Argumente. Die Unterstützung für variadische Funktionen unterscheidet sich stark zwischen stark Programmiersprachen.

Der Begriff variadisch ist ein Neologismus, aus dem Jahr 1936–1937.^[1] Der Begriff wurde erst in den 1970er Jahren weit verbreitet.

Überblick

Es gibt viele mathematische und logische Operationen, die natürlich als variadische Funktionen auftreten. Zum Beispiel die Summierung von Zahlen oder die Verkettung von Strings oder anderen Sequenzen sind Operationen, die für eine beliebige Anzahl von Operanden als anwendbar angesehen werden können (obwohl in diesen Fällen formell die assoziatives Eigentum wird angewandt).

Ein weiterer Vorgang, der in vielen Sprachen als variadische Funktion implementiert wurde, ist die Ausgabeformatierung. Das C Funktion printf und die Common Lisp Funktion format sind zwei solche Beispiele. Beide nehmen ein Argument an, das die Formatierung der Ausgabe angibt, und irgendeine Nummer von Argumenten, die die zu formatierten Werte liefern.

Variadische Funktionen können entlarvt werden Typ-Safety Probleme in einigen Sprachen. Zum Beispiel c's printf, wenn es unvorsichtig verwendet wird, kann zu einer Klasse von Sicherheitslöchern führen Format -String -Angriffe. Der Angriff ist möglich, da die Sprachunterstützung für variadische Funktionen nicht vom Typ Typ ist: Es ermöglicht die Funktion, zu versuchen, mehr Argumente aus dem Stapel als dort platziert, den Stapel korrumpiert und zu unerwartetem Verhalten führte. Infolgedessen die Zertifikatkoordinierungszentrum betrachtet variadische Funktionen in C als ein hochwertiges Sicherheitsrisiko.^[2]

In funktionalen Sprachen können Variadike als komplementär an die angesehen werden anwenden Funktion, die eine Funktion und eine Liste/Sequenz/ein Array als Argumente nimmt und die Funktion mit den in dieser Liste angegebenen Argumenten aufruft, wodurch eine Variable Anzahl von Argumenten an die Funktion weitergegeben wird. In der funktionalen Sprache Haskell, variadische Funktionen können durch Rückgabe eines Wertes von a implementiert werden Geben Sie Klasse ein T; Wenn Fälle von T sind ein endgültiger Rückgabewert r und eine Funktion (T t) => x -> tDies ermöglicht eine beliebige Anzahl zusätzlicher Argumente x.^{[Weitere Erklärung erforderlich]}

Ein verwandtes Thema in Begriff umschreiben Forschung wird genannt Hecken, oder Heckevariablen.^[3] Im Gegensatz zu Variadikern, die Funktionen mit Argumenten sind, sind Absicherungen selbst Sequenzen von Argumenten. Sie können auch Einschränkungen (z. B. nicht mehr als 4 Argumente annehmen) bis zu dem Punkt aufweisen Variadien kann irreführend sein. Sie beziehen sich jedoch auf dasselbe Phänomen, und manchmal wird die Phrasierung gemischt, was zu Namen wie wie Variadische Variable (Synonym für Hecke). Beachten Sie die doppelte Bedeutung des Wortes Variable und der Unterschied zwischen Argumenten und Variablen in der funktionalen Programmierung und dem Umschreiben. Beispielsweise kann ein Begriff (Funktion) drei Variablen haben, eine davon eine Absicherung, sodass der Begriff drei oder mehr Argumente (oder zwei oder mehr, wenn die Absicherung leer sein darf).

Beispiele

In c

Portierbar variadische Funktionen in der implementieren C Programmiersprache, Der Standard stdarg.h Die Header -Datei wird verwendet. Die älteren varargs.h Header war gewesen veraltet zugunsten stdarg.h. In C ++ die Header -Datei cstdarg wird genutzt.^[4]

#enthalten  #enthalten  doppelt Durchschnitt(int zählen, ...) {   va_list AP;   int j;   doppelt Summe = 0;   va_start(AP, zählen); / * Erfordert den letzten festen Parameter (um die Adresse abzurufen) */   zum (j = 0; j < zählen; j++) {   Summe += va_arg(AP, int); /* Erhöht AP zum nächsten Argument. */   }   va_end(AP);   Rückkehr Summe / zählen; } int hauptsächlich(int argc, verkohlen Const *argv[]) {   printf("%f\n", Durchschnitt(3, 1, 2, 3));   Rückkehr 0; } 

Dies wird den Durchschnitt einer willkürlichen Anzahl von Argumenten berechnen. Beachten Sie, dass die Funktion die Anzahl der Argumente oder deren Typen nicht kennt. Die obige Funktion erwartet, dass die Typen sein werden intund dass die Anzahl der Argumente im ersten Argument verabschiedet wird (dies ist eine häufige Verwendung, aber keineswegs durch die Sprache oder den Compiler durchgesetzt). In einigen anderen Fällen zum Beispiel printfDie Anzahl und Arten von Argumenten stammen aus einer Formatzeichenfolge. In beiden Fällen hängt dies davon ab, dass der Programmierer die richtigen Informationen liefert. (Alternativ a Sentinel -Wert wie NULL kann verwendet werden, um die Anzahl anzuzeigen.) Wenn weniger Argumente übergeben werden als die Funktion, die glaubt, oder die Argumente nicht falsch sind, kann dies dazu führen Format -String -Angriff.

stdarg.h deklariert einen Typ, va_listund definiert vier Makros: va_start, va_arg, va_copy, und va_end. Jede Berufung von va_start und va_copy muss durch eine entsprechende Aufklärung von angepasst werden va_end. Bei der Arbeit mit variablen Argumenten deklariert eine Funktion normalerweise eine Variable des Typs va_list (ap im Beispiel), das von den Makros manipuliert wird.

1. va_start nimmt zwei Argumente ein, a va_list Objekt und ein Verweis auf den letzten Parameter der Funktion (der vor der Ellipsis; das Makro verwendet dies, um seine Lager zu erhalten). Es initialisiert die va_list Objekt für die Verwendung durch va_arg oder va_copy. Der Compiler gibt normalerweise eine Warnung aus, wenn die Referenz falsch ist (z. B. eine Referenz auf einen anderen Parameter als der letzte oder eine Referenz auf ein völlig anderes Objekt), verhindern jedoch nicht, dass die Kompilierung normal abgeschlossen wird.
2. va_arg nimmt zwei Argumente ein, a va_list Objekt (zuvor initialisiert) und ein Typ -Deskriptor. Es erweitert das nächste Argument für variable und hat den angegebenen Typ. Aufeinanderfolgende Aufrufe von va_arg Ermöglichen Sie die Verarbeitung jedes der variablen Argumente nacheinander. Nicht spezifiziertes Verhalten tritt auf, wenn der Typ falsch ist oder es kein nächstes variables Argument gibt.
3. va_end nimmt ein Argument, a va_list Objekt. Es dient zum Aufräumen. Wenn man beispielsweise die variablen Argumente mehr als einmal scannen wollte, würde der Programmierer Ihre erneut initialisieren va_list Objekt durch Aufrufen va_end und dann va_start wieder darauf.
4. va_copy nimmt zwei Argumente an, beide va_list Objekte. Es kloniert den zweiten (was initialisiert worden sein muss) in die erste. Zurück zum "scannen Sie die variablen Argumente mehr als einmal". Dies kann durch Aufrufen erreicht werden va_start Bei einem ersten va_list, dann verwendet va_copy Um es in eine Sekunde zu klonen va_list. Nach dem Scannen der variablen Argumente zum ersten Mal mit va_arg und der erste va_list (entsorgen va_end) Der Programmierer könnte die variablen Argumente ein zweites Mal mit Scannen scannen va_arg und der zweite va_list. Vergiss es nicht va_end die geklonten va_list.

In C#

C# beschreibt variadische Funktionen mit der params Stichwort. Für die Argumente muss jedoch ein Typ bereitgestellt werden object[] Kann als All-Cat-All verwendet werden.

Verwendung System; Klasse Programm {   statisch int Foo(int a, int b, Parameter int[] Args)   {  // Gibt die Summe der Ganzzahlen in Args zurück und ignoriert a und b.  int Summe = 0;  für jeden (int i in Args)  Summe += i;  Rückkehr Summe;  }           statisch Leere Hauptsächlich(Saite[] Args)  {   Konsole.Schreiben(Foo(1, 2));  // 0   Konsole.Schreiben(Foo(1, 2, 3, 10, 20));  // 33   } } 

In C ++

Die grundlegende variadische Einrichtung in C ++ ist weitgehend identisch mit der in C. Der einzige Unterschied besteht in der Syntax, wobei das Komma vor der Ellipse weggelassen werden kann.

#enthalten  #enthalten  Leere Simple_printf(Const verkohlen* fmt...)  // C-Stil "const char* fmt, ..." ist ebenfalls gültig {   va_list Args;   va_start(Args, fmt);     während (*fmt ! = '\ 0' ') {   wenn (*fmt == 'd') {   int i = va_arg(Args, int);   std::Cout << i << '\n';   } anders wenn (*fmt == 'c') {   // Beachten Sie die automatische Konvertierung zum Integral -Typ   int c = va_arg(Args, int);   std::Cout << static_cast<verkohlen>(c) << '\n';   } anders wenn (*fmt == 'f') {   doppelt d = va_arg(Args, doppelt);   std::Cout << d << '\n';   }   ++fmt;   }     va_end(Args); } int hauptsächlich() {   Simple_printf("DCFF", 3, 'a', 1.999, 42,5);  } 

Variadische Vorlagen (Parameterpack) kann auch in C ++ mit integriertem Sprache verwendet werden Ausdrücke falten.

#enthalten  Schablone <Modellname... Ts> Leere foo_print(Ts... Args)  {   ((std::Cout << Args << '' '), ...); } int hauptsächlich() {   std::Cout << std::Boolalpha;   foo_print(1, 3.14f); // 1 3.14   foo_print("Foo", 'b', Stimmt, nullptr); // foo b true nullptr } 

Das Zertifizierungscodierungsstandards Für C ++ bevorzugt die Verwendung von stark Variadische Vorlagen (Parameterpack) in C ++ über die Variadiefunktion im C-Stil aufgrund eines geringeren Missbrauchsrisikos.^[5]

In Go

Variadische Funktionen in gehen kann mit einer beliebigen Anzahl von nachfolgenden Argumenten aufgerufen werden.^[6] fmt.Println ist eine häufige variadische Funktion; Es verwendet eine leere Schnittstelle als Catch-All-Typ.

Paket hauptsächlich importieren "fmt" // Diese variadische Funktion nimmt eine willkürliche Anzahl von INTs als Argumente an. Func Summe(nums ...int) { 	fmt.Drucken("Die Summe von ", nums) // auch eine variadische Funktion. 	gesamt : = 0 	zum _, num : = Angebot nums { 		gesamt += num 	} 	fmt.Println(" ist", gesamt) // auch eine variadische Funktion. } Func hauptsächlich() { 	// Variadische Funktionen können auf die übliche Weise mit Individuum aufgerufen werden 	// Argumente. 	Summe(1, 2)  // "Die Summe von [1 2] ist 3" 	Summe(1, 2, 3) // "Die Summe von [1 2 3] ist 6" 	// Wenn Sie bereits mehrere Argumente in einer Scheibe haben, wenden Sie sie auf eine Variadik an 	// Funktion mit Func (Slice ...) wie diesem. 	nums : = []int{1, 2, 3, 4} 	Summe(nums...) // "Die Summe von [1 2 3 4] beträgt 10" } 

Ausgabe:

Die Summe von [1 2] beträgt 3 die Summe von [1 2 3] 6 Die Summe von [1 2 3 4] beträgt 10

In Java

Wie bei C#die Object eintippen Java ist als All-Cat-All erhältlich.

Öffentlichkeit Klasse Programm {  // Variadische Methoden speichern alle zusätzlichen Argumente, die sie in einem Array erhalten.  // Folgen ist "Printargs" tatsächlich eine Methode mit einem Parameter: a  // Array der variablen Länge von `String '.  Privatgelände statisch Leere Printargs(Saite... Saiten) {  zum (Saite Saite : Saiten) {  System.aus.println(Saite);  }  }  Öffentlichkeit statisch Leere hauptsächlich(Saite[] Args) {  Printargs("hallo");  // kurz für Printargs (["Hallo"])  Printargs("hallo", "Welt"); // kurz für Printargs (["Hallo", "Welt"])  } } 

In JavaScript

Funktion Summe(...Zahlen) {  Rückkehr Zahlen.reduzieren((a, b) => a + b, 0); } Konsole.Protokoll(Summe(1, 2, 3)); // 6 Konsole.Protokoll(Summe(3, 2));  // 5 Konsole.Protokoll(Summe());  // 0 

JavaScript kümmert sich nicht um Arten von variadischen Argumenten. Es gibt eine andere Möglichkeit, eine variadische Funktion mit Argumenteobjekten zu erstellen, obwohl sie nur mit Funktionen mit dem Schlüsselwort "Funktion" verwendet werden kann.

Funktion Zusatz(num) {  Lassen Summe=num;  zum(i=1;i<Argumente.Länge;i++) {  Summe+=num+Argumente[i]  }  Rückkehr Summe; } Konsole.Protokoll(Zusatz(5,5,5,5,5)) //25 

Im Pascal

Pascal hat vier integrierte Verfahren, die als variadisch definiert sind, die aufgrund dieser besonderen Erkrankung für den Compiler intrinsisch sind. Dies sind die read, readln, write, und writeln Verfahren. Es gibt jedoch alternative Spezifikationen Ursprünglich Argumente zu Verfahren oder Funktionen, die sie sowohl variadisch funktionieren lassen Polymorphismus Dies ermöglicht eine Prozedur oder Funktion, unterschiedliche Parameter zu haben.

Das read[ln] und write[ln] Verfahren haben alle das gleiche Format:

Lesen Sie [ln] [([Datei,] Variable [, Variable ...])]; schreiben [ln] [([Datei] [, Wert [, Wert ...])];

wo

• file ist eine optionale Dateivariable, die, wenn es weggelassen wird, standardmäßig zu input zum read und readlnoder standardmäßig output zum write und writeln;
• variable ist ein Skalar wie ein Zeichen (Zeichen), Ganzzahl oder real (oder für einige Compiler, bestimmte Datensatztypen oder Array -Typen wie Zeichenfolgen); und
• value ist eine Variable oder eine Konstante.

Beispiel:

var    f: Text;   CH: verkohlen;   n,a,I,B: Ganze Zahl;   S: Saite;  Start   Schreiben("Geben Sie den Namen der Datei ein, um Ergebnisse zu schreiben:");   Readln(s);       zuordnen(f,S);   umschreiben(f);   Schreiben('Wie heißen Sie? '');   Readln(Eingang,S);           Schreiben('Hallo, ',S,'! Geben Sie die Anzahl der Berechnungen ein, die Sie durchführen möchten: ');   Writeln(Ausgang);   Schreiben('? '');   Readln(N);   Schreiben('Für jedes der' ',n,"Formeln, eingeben");   schreiben("Zwei Ganzzahlen, die durch einen oder mehrere Räume getrennt sind");   Writeln;   zum i : = 1 zu N tun   Start      Schreiben('Paar #' eingeben ',i,'? '');   lesen(a,b);   Readln;   Writeln(aus,'EIN [',a,'] + B [',B,'] =',A+B);   Ende;   nah dran(AUS); Ende. 

Im obigen Beispiel sind in Bezug auf den Compiler die Zeilen 9 und 13 identisch, weil input Ist die Dateivariable durch a gelesen? read oder readln Anweisung kann die Dateivariable weggelassen werden. Außerdem betrachtet der Compiler die Zeilen 15 und 20 als identisch, denn wenn die Dateivariable geschrieben wird, ist es outputEs kann weggelassen werden, was bedeutet (in Zeile 20), da keine Argumente an das Verfahren übergeben werden. Die Klammern werden weggelassen werden. Zeile 26 zeigt die writeln Die Anweisung kann eine beliebige Anzahl von Argumenten haben und sie können eine zitierte Zeichenfolge, eine Variable oder sogar ein Formelergebnis sein.

Objektpascal unterstützt polymorph Verfahren und Funktionen, bei denen unterschiedliche Verfahren oder Funktionen (en) denselben Namen haben können, werden jedoch durch die ihnen gelieferten Argumente unterschieden.

Pascal unterstützt auch Ursprünglich Argumente, bei denen der Wert eines Arguments, falls dies nicht vorgesehen ist, einen Standardwert erhalten.

Betrachten Sie zum ersten Beispiel Polymorphismus Folgendes:

Funktion hinzufügen(A1,A2:ganze Zahl):Ganze Zahl; Start hinzufügen : = A1+A2 Ende;                                 Funktion hinzufügen(R1,R2:real):real;  Start hinzufügen : = A1+A2 Ende;                                  Funktion hinzufügen(A1:ganze Zahl;R2:real):real;  Start hinzufügen : = real(A1)+A2 Ende;                                 Funktion hinzufügen(R1:real,A2:ganze Zahl):real;  Start hinzufügen : = A1+real(A2) Ende; 

Im obigen Beispiel, wenn add Wie mit zwei ganzzahligen Werten genannt, würde die in Zeile 1 deklarierte Funktion genannt; Wenn eines der Argumente eine Ganzzahl ist und einer real ist, wird entweder die Funktion in Zeile 3 oder 4 aufgerufen, je nachdem, welche ganzezahl ist. Wenn beide real sind, wird die Funktion in Zeile 2 aufgerufen.

Betrachten Sie für Standardparameter Folgendes:

Const   Drei = 3; var    K: Ganze Zahl;   Funktion hinzufügen(I1: ganze Zahl = 0;    I2: ganze Zahl = 0;   i3: ganze Zahl = 0;    I4: ganze Zahl = 0;    i5: ganze Zahl = 0;    i6: ganze Zahl = 0;     i7: ganze Zahl = 0;     i8: ganze Zahl = 0): ganze Zahl; Start   hinzufügen : = I1+I2+i3+I4+I5+i6+I7+I8; Ende;  Start   K : = hinzufügen; {K ist 0}   K : = hinzufügen(K,1); {K ist 1}   K : = hinzufügen(1,2); {K ist 3}   K : = hinzufügen(1,2,Drei); {K ist 6 usw.} Ende. 

In Zeile 6 (und den folgenden Zeilen) Der Parameter = 0 sagt dem Compiler: "Wenn kein Argument vorgelegt wird, gehen Sie davon aus, dass das Argument Null ist." In Zeile 19 wurden keine Argumente angegeben, daher kehrt die Funktion zurück 0. In Zeile 20 kann entweder eine Zahl oder eine Variable für jedes Argument und wie in Zeile 22 gezeigt eine Konstante geliefert werden.

Im Php

Php kümmert sich nicht um Arten von variadischen Argumenten, es sei denn, das Argument wird tippt.

Funktion Summe(...$ nums): int {  Rückkehr Array_sum($ nums); } Echo Summe(1, 2, 3); // 6 

Und typisierte variadische Argumente:

Funktion Summe(int ...$ nums): int {  Rückkehr Array_sum($ nums); } Echo Summe(1, 'a', 3); // typeerrror: Argument 2 an sum () übergeben () muss vom Typ int sein (da Php 7.3) 

In Python

Python kümmert sich nicht um Arten von variadischen Argumenten.

def Foo(a, b, *Args):  drucken(Args)  # args ist ein Tupel (unveränderliche Sequenz). Foo(1, 2) # () Foo(1, 2, 3) # (3,) Foo(1, 2, 3, "hallo") # (3, "Hallo") 

Schlüsselwortargumente können in einem Wörterbuch gespeichert werden, z. def bar(*args, **kwargs).

In Raku

Im RakuDie Art der Parameter, die variadische Funktionen erzeugen Slurpy Array -Parameter und sie werden in drei Gruppen eingeteilt:

Abgeflachte Schlürker

Diese Parameter werden mit einem einzelnen Sternchen deklariert (*) und sie flachen Argumente ab, indem sie eine oder mehrere Schichten von Elementen auflösen, die überarbeitet werden können (d.h. Iterables).

Sub Foo($ a, $ b, *@Args) { sagen @Args.Perl; }Foo(1, 2) # [] Foo(1, 2, 3) # [3] Foo(1, 2, 3, "hallo") # [3 "Hallo"] Foo(1, 2, 3, [4, 5], [6]); # [3, 4, 5, 6] 

Unerschütterter Slurpy

Diese Parameter werden mit zwei Sternchen () deklariert und verflachen keine iterbaren Argumente in der Liste, sondern halten die Argumente mehr oder weniger als IS:

Sub Bar($ a, $ b, **@Args) { sagen @Args.Perl; }Bar(1, 2); # [] Bar(1, 2, 3); # [3] Bar(1, 2, 3, "hallo"); # [3 "Hallo"] Bar(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6]] 

Kontextbezogene Slurpy

Diese Parameter werden mit einem Plus deklariert (+) Zeichen und sie wenden das an "Einzelargumentregel", was entscheidet, wie das Slurpy -Argument auf der Grundlage des Kontextes umgeht. Einfach ausgedrückt, wenn nur ein einziges Argument übergeben wird und dieses Argument iterbar ist, wird dieses Argument verwendet, um das Slurpy -Parameter -Array zu füllen. In jedem anderen Fall, +@ funktioniert wie **@ (d. h. unerschütterte Schlüritzung).

Sub Zaz($ a, $ b, +@Args) { sagen @Args.Perl; }Zaz(1, 2); # [] Zaz(1, 2, 3); # [3] Zaz(1, 2, 3, "hallo"); # [3 "Hallo"] Zaz(1, 2, [4, 5]); # [4, 5], einzelner Argurent füllt das Array aus Zaz(1, 2, 3, [4, 5]); # [3, [4, 5]], verhalten sich als **@ Zaz(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6]], verhalten sich als **@ 

In Ruby

Rubin kümmert sich nicht um Arten von variadischen Argumenten.

def Foo(*Args)  drucken Args Ende Foo(1) # Drucke `[1] => nil` Foo(1, 2) # Drucke `[1, 2] => nil` 

Im Rost

Rost unterstützt keine variadischen Argumente in Funktionen. Stattdessen verwendet es Makros.^[7]

MACRO_RULES! Berechnung {   // Das Muster für ein einzelnes `eval``   (bewerten $ e:Expr) => {{{{   {   Lassen val: Usize = $ e; // zwingen Typen, um Zahlen zu sein   println!("{} = {}", Stringify!{$ e}, val);   }   }};   // mehrere `evalsive zersetzen   (bewerten $ e:Expr, $ (bewerten $ es:Expr),+) => {{{{   Berechnung! { bewerten $ e }   Berechnung! { $ (bewerten $ es),+ }   }}; } fn hauptsächlich() {   Berechnung! { // sieh ma! Variadic `Calculate!`!   bewerten 1 + 2,   bewerten 3 + 4,   bewerten (2 * 3) + 1   } } 

Rust kann über a mit dem variadischen System von C interagieren c_variadic Feature -Switch. Wie bei anderen C -Schnittstellen wird das System berücksichtigt unsafe rosten.^[8]

In Scala

Objekt Programm {  // Variadische Methoden speichern alle zusätzlichen Argumente, die sie in einem Array erhalten.  // Folgen ist "Printargs" tatsächlich eine Methode mit einem Parameter: a  // Array der variablen Länge von `String '.  Privatgelände def Printargs(Saiten: Saite*): Einheit = {  Saiten.für jeden(println)  }  def hauptsächlich(Args: Array[Saite]): Einheit = {  Printargs("hallo");  // kurz für Printargs (["Hallo"])  Printargs("hallo", "Welt"); // kurz für Printargs (["Hallo", "Welt"])  } } 

In Swift

Schnell kümmert sich um die Art der variadischen Argumente, aber den Fall Any Typ ist verfügbar.

Func grüßen(Tageszeit: Saite, Namen: Saite...) {  // Hier ist Namen [String]       drucken("Sieht so aus, als hätten wir \ (Namen.zählen) Personen")       zum Name in Namen {  drucken("Hallo \ (Name), gut \ (Tageszeit)")  } } grüßen(Tageszeit: "Morgen", Namen: "Joseph", "Clara", "Wilhelm", "Maria") // Ausgabe: // Sieht so aus, als hätten wir 4 Leute // Hallo Joseph, guten Morgen // Hallo Clara, guten Morgen // Hallo William, guten Morgen // Hallo Maria, guten Morgen 

In TCL

A Tcl Prozedur oder Lambda ist variabel, wenn das letzte Argument ist args: Dies enthält eine Liste (möglicherweise leer) aller verbleibenden Argumente. Dieses Muster ist bei vielen anderen verfahrensähnlichen Methoden üblich.^[9][10]

Proc grüßen {Tageszeit Args} {   stellt "Sieht so aus, als hätten wir Leute [length $ args]"   für jeden Name $ args {   stellt "Hallo $ Name, gute $ timeoftheday"   } } grüßen "Morgen" "Joseph" "Clara" "Wilhelm" "Maria" # Ausgabe: # Sieht so aus, als hätten wir 4 Leute # Hallo Joseph, guten Morgen # Hallo Clara, guten Morgen # Hallo William, guten Morgen # Hallo Maria, guten Morgen 

Siehe auch

• Varargs in der Java -Programmiersprache
• Variadische Makro (C -Programmiersprache)
• Variadische Vorlage

Verweise

Externe Links

• Variadische Funktion. Rosetta -Code Aufgabe, die die Implementierung von variadischen Funktionen in über fünfzig Programmiersprachen zeigt.
• Variable Argumentationsfunktionen - Ein Tutorial über variable Argumentfunktionen für C ++
• GNU LIBC -Handbuch