In der objektorientierten Programmierung ist Maschinenbediener, der — weniger allgemein bekannt als Maschinenbediener ad hoc polymorphism überlädt — ein spezifischer Fall von polymorphism, wo verschiedene Maschinenbediener verschiedene Durchführungen abhängig von ihren Argumenten haben. Maschinenbediener, der überlädt, wird allgemein durch die Sprache, den Programmierer oder beide definiert.

Wie man

fordert, ist Maschinenbediener, der überlädt, nützlich, weil es dem Entwickler dem Programm mit der Notation erlaubt, die "am Zielgebiet näher ist", und benutzerbestimmten Typen ein ähnliches Niveau der syntaktischen Unterstützung als in die Sprache eingebaute Typen erlaubt. Damit kann mit Funktionsanrufen leicht wettgeeifert werden; für ein Beispiel, denken Sie die ganzen Zahlen a, b, c:

+ b * c

Auf einer Sprache, die Maschinenbediener unterstützt, der überlädt, und '*' annimmt, hat Maschinenbediener höhere Priorität als '+', das ist effektiv eine kürzere Weise zu schreiben:

tragen Sie bei (a, multiplizieren Sie (b, c))

Beispiele

In diesem Fall wird der Hinzufügungsmaschinenbediener überladen, um Hinzufügung auf einem benutzerbestimmten Typ "Time" (in C ++) zu erlauben:

Zeitmaschinenbediener + (const Time& lhs, const Time& rhs)

{\

Zeitzeitsekretärin = lhs;

temp.seconds + = rhs.seconds;

wenn (temp.seconds> = 60) {\

temp.seconds - = 60;

temp.minutes ++;

}\

temp.minutes + = rhs.minutes;

wenn (temp.minutes> = 60) {\

temp.minutes - = 60;

temp.hours ++;

}\

temp.hours + = rhs.hours;

geben Sie Zeitsekretärin zurück;

}\

</Quelle>

Hinzufügung ist eine binäre Operation, was bedeutet, dass sie abreist und Recht operands. In C ++ sind die Argumente, die passieren werden, der operands, und der Gegenstand ist der zurückgegebene Wert.

Die Operation konnte auch als eine Klassenmethode definiert werden, durch das verborgene Argument ersetzend; jedoch zwingt das den linken operand, des Typs zu sein, und denkt, um ein potenziell modifizierbarer lvalue zu sein:

Zeitzeit:: Maschinenbediener + (const Time& rhs) const

{\

Zeitzeitsekretärin = *this;/*-Kopie 'das', das * / nicht modifiziert werden

soll temp.seconds + = rhs.seconds; wenn (temp.seconds> = 60) {\ temp.seconds - = 60; temp.minutes ++; }\ temp.minutes + = rhs.minutes; wenn (temp.minutes> = 60) {\ temp.minutes - = 60; temp.hours ++; }\ temp.hours + = rhs.hours; geben Sie Zeitsekretärin zurück;}\</Quelle>

Bemerken Sie, dass ein unärer Maschinenbediener definiert hat, weil eine Klassenmethode kein offenbares Argument erhalten würde (sie arbeitet nur von):

Bool-Zeit:: Maschinenbediener! const

{\

kehren Sie ((Stunden == 0) && (Minuten == 0) && (Sekunden == 0)) zurück;

}\</Quelle>

Kritiken

Maschinenbediener, der überlädt, ist häufig kritisiert worden, weil es Programmierern erlaubt, Maschinenbedienern völlig verschiedene Semantik abhängig von den Typen ihres operands zu geben. Zum Beispiel der Gebrauch in C ++ 's:

a

wechselt die Bit in der durch 1 Bit verlassenen Variable aus, wenn von einem Typ der ganzen Zahl ist, aber wenn ein Produktionsstrom dann ist, wird der obengenannte Code versuchen, "1" dem Strom zu schreiben. Weil Maschinenbediener, der überlädt, dem ursprünglichen Programmierer erlaubt, die übliche Semantik eines Maschinenbedieners zu ändern und irgendwelche nachfolgenden Programmierer unerwartet zu fangen, wird es gewöhnlich als gute Praxis betrachtet, um Maschinenbediener zu verwenden, der mit der Sorge überlädt.

Die allgemeine Antwort zu dieser Kritik besteht darin, dass dasselbe Argument für die Funktion gilt, die ebenso überlädt. Außerdem, sogar ohne Überbelastung, kann ein Programmierer eine Funktion definieren, etwas völlig Verschiedenes davon zu tun, was von seinem Namen erwartet würde. Ein Problem, das bleibt, ist, dass Sprachen wie C ++ einen beschränkten Satz von Maschinenbediener-Symbolen zur Verfügung stellen, so von Programmierern die Auswahl umziehend, ein passenderes Maschinenbediener-Symbol für ihre neue Operation zu wählen.

Ein anderer ist das feinere Problem mit Maschinenbedienern, dass bestimmte Regeln von der Mathematik falsch erwartet oder unabsichtlich angenommen werden können. Zum Beispiel gilt der commutativity + (d. h. dass) nicht immer; ein Beispiel davon kommt vor, wenn die operands Schnuren sind, da + allgemein überladen wird, um eine Verkettung von Schnuren durchzuführen (d. h. Erträge, der von Erträgen verschieden ist). Ein typischer Schalter zu diesem Argument kommt direkt aus der Mathematik: Während + auf ganzen Zahlen auswechselbar ist (und im Allgemeinen irgendwelche reellen Zahlen), ist es für andere "Typen" der Variable nicht auswechselbar. Es kann weiter bemerkt werden, dass + auf Schwimmpunkt-Werten in der Praxis wegen Rundungsfehler nicht sogar assoziativ ist. Ein anderes Beispiel: Binär * (Multiplikation) ist für ganze Zahlen auswechselbar, aber im Falle der Matrixmultiplikation nicht auswechselbar.

Katalog

Eine Klassifikation von einigen allgemeinen Programmiersprachen dadurch, ob ihre Maschinenbediener overloadable durch den Programmierer sind, und ob die Maschinenbediener auf einen vorherbestimmten Satz beschränkt werden.

Zeitachse des Maschinenbedieners, der überlädt

Die 1960er Jahre

Das Algol 68 Spezifizierung hat Maschinenbediener erlaubt, der überlädt.

Der Extrakt vom Algol 68 Sprachspezifizierung (Seite 177), wo die überlasteten Maschinenbediener ¬, =,  und abs definiert werden:

10.2.2. Operationen auf Boolean Operands

a) op  = (bool a, b) bool: (| wahr | b);

b) op  = (bool a, b) bool: (| b | falsch);

c) op ¬ = (bool a) bool: (| falsch | wahr);

d) op = = (bool a, b) bool: (ab)  (¬ b  ¬ a);

e) op  = (bool a, b) bool: ¬ (a=b);

f) op abs = (bool a) interne Nummer: (| 1 | 0);

Bemerken Sie, dass keine spezielle Behauptung erforderlich ist, einen Maschinenbediener zu überladen, und der Programmierer frei ist, neue Maschinenbediener zu schaffen.

Die 1980er Jahre

Unterstützungsüberbelastung von Ada von Maschinenbedienern von seinem Beginn, mit der Veröffentlichung der Adas 83 Sprachstandard. Jedoch beschließen die Entwerfer der Sprache, die Definition von neuen Maschinenbedienern nicht zu erlauben: Nur die vorhandenen Maschinenbediener auf der Sprache können überladen werden (indem sie neue Funktionen mit Bezeichnern solcher als "+", "*", "und" usw. definieren). Nachfolgende Revisionen der Sprache (1995 und 2005) erhalten die Beschränkung aufrecht, vorhandener Maschinenbediener zu überladen.

C ++ 's Maschinenbediener, der überlädt, wird weiter von diesem von Algol-68 raffiniert.

Die 1990er Jahre

Sonne beschließt, Maschinenbediener nicht einzuschließen, der in Java überlädt

Sprache.

Rubin erlaubt Maschinenbediener, der als syntaktischer Zucker für einfache Methode-Anrufe überlädt.

Lua erlaubt Maschinenbediener, der als syntaktischer Zucker für Methode-Anrufe mit dem Komfortmerkmal überlädt, dass, wenn der erste operand diesen Maschinenbediener nicht definiert, die Methode für den zweiten Maschinenbediener verwendet wird.

Die 2000er Jahre

Microsoft schließt Maschinenbediener ein, der für C# 2001 überlädt.

Scala erlaubt Maschinenbediener, der über die vielfache Absendung überlädt.

Siehe auch

• Funktion, die überlädt
• Polymorphism (Informatik)
• Unterprogramm
• Maschinenbediener, der (programmiert)
• Maschinenbediener in C und C ++