imported>SchlurcherBot: Bot: http → https

2026-04-18T12:02:36Z

Bot: http → https

Neue Seite

Eine '''Signatur''' (oder '''Methodensignatur''') definiert in der [[Programmierung]] die formale Schnittstelle einer [[Funktion (Programmierung)|Funktion]] oder [[Prozedur (Programmierung)|Prozedur]]. Sie besteht aus dem Namen der Funktion sowie der Anzahl, Art und Reihenfolge der [[Zuweisungskompatibilität|zuweisungskompatiblen]] [[Parameter (Informatik)|Parameterdatentypen]], wobei zwischen Eingangs-, Ausgangs- und Durchgangsparametern unterschieden werden kann. Der Typ des Rückgabewerts gehört bei [[Starke Typisierung|stark typisierten]] Programmiersprachen ebenfalls zur Signatur<ref>Björn Kellermann: [https://www.fh-wedel.de/~si/seminare/ss03/Ausarbeitung/9.hxml/haskell/signatur_definition.html 1.3 Signatur, Definition]m Haskell, abgerufen am 3. Februar 2014</ref><ref>Thomas Briner-Lienhard: [http://briner.computerscience.ch/Info1/Oberon_key.pdf Keywords fuer Programmstruktur.] (PDF) Oberon, abgerufen am 3. Februar 2014</ref>, genauso wie die Modifikatoren, die die Regeln für die [[Sichtbarkeit (Programmierung)|Sichtbarkeit]] und die [[Überschreiben (OOP)|Überschreibbarkeit]] einer Methode festlegen.<ref>[https://developer.mozilla.org/en-US/docs/Glossary/Signature/Function Signature (functions)], Mozilla.org, abgerufen am 25. März 2018</ref><ref>[https://introcs.cs.princeton.edu/java/21function/ Static Methods], Computer Science, Princeton University, abgerufen am 25. März 2018</ref>

Unter Signaturvererbung versteht man in der [[Objektorientierte Programmierung|objektorientierten Programmierung]] die Übertragung einer in der Oberklasse definierten (und eventuell implementierten) Methode auf die Unterklasse. Statische Methoden mit sich unterscheidender Signatur können nicht überschrieben werden, sondern können bei weniger streng strukturierten Programmiersprachen gegebenenfalls [[überladen]] werden.

Auch die Menge der Operatoren eines [[Abstrakter Datentyp|abstrakten Datentyps]] wird ''Signatur'' genannt.<ref>R. Dumke: ''{{Webarchiv|url=http://ivs.cs.uni-magdeburg.de/~dumke/EAD/Skript29.html#adt |wayback=20060430040039 |text=Einführung, Algorithmen und Datenstrukturen. |archiv-bot=2019-05-14 01:26:34 InternetArchiveBot }}'' Otto-von-Guericke-Universität Magdeburg</ref>

== Rückgabetyp ==
In Pascal- und C-Abkömmlingen und ähnlichen Sprachen, welche bei [[Überladen|Überladungen]] den Rückgabetyp nicht berücksichtigen, kann nicht unterschieden werden, welche Methode im konkreten Anwendungsfall benutzt werden soll.

'''Beispiel:'''
<syntaxhighlight lang="java">
...
// Deklaration
float teile( int dividend, int divisor); // die Signatur ist hier: teile( int, int )
double teile (int a, int b); // nicht erlaubt, Signatur ist dieselbe wie oben: teile( int, int )
...
</syntaxhighlight>

Beide Methoden bzw. Funktionen oben hätten die gleiche Signatur.

<syntaxhighlight lang="java">
...
// Deklaration
boolean isNegativ( float zahl ); // die Signatur ist isNegativ(float)
boolean isNegativ( double zahl ); // in Ordnung, Signatur ist anders: isNegativ(double)
...
</syntaxhighlight>

Jetzt könnte nicht mehr entschieden werden, welche Funktion teile (int, int) im konkreten Anwendungsfall benutzt werden soll:
<syntaxhighlight lang="java">
...
// Die obigen Funktionen sollen hier benutzt werden:
boolean b = isNegativ( teile(x,y) ); // float teile(..) oder double teile(..) ?
...
</syntaxhighlight>

Im Gegensatz dazu kann die Möglichkeit gegeben werden, in Ausdrücken explizit einen Typ anzugeben. Dadurch kann das Aufrufziel eindeutig angegeben werden. [[Haskell (Programmiersprache)|Haskell]] macht hiervon Gebrauch. Beispielsweise ergeben die Ausdrücke
<syntaxhighlight lang="haskell">
read "42" :: Integer
</syntaxhighlight>
und
<syntaxhighlight lang="haskell">
read "42" :: Double
</syntaxhighlight>
verschiedene Werte unterschiedlichen Typs.

== Objektorientierung ==
In der [[Objektorientierte Programmierung|objektorientierten Programmierung]] ist eine Signatur die formale Schnittstelle einer [[Methode (Programmierung)|Methode]].<ref>Rebecca Wirfs-Brock, Brian Wilkerson, Lauren Wiener: ''Objektorientiertes Software-Design.'' Carl Hanser Verlag, München 1993, ISBN 3-446-16319-0</ref>

Signaturen spielen eine Rolle bei der [[Polymorphie (Programmierung)|Polymorphie]], einem der grundlegenden Konzepte der [[Objektorientierung]]. In vielen Programmiersprachen kann eine Methode einer abgeleiteten Klasse die Methode einer Basisklasse genau dann [[Überschreiben (Programmierung)|überschreiben]], wenn die Signaturen der beiden Methoden identisch sind.

=== Überschriebene Methoden ===

Im folgenden [[Java (Programmiersprache)|Java]]-Beispiel scheinen die Methodensignaturen aus Oberklasse und abgeleiteter Klasse gleich zu sein: <code>String redeMit( String )</code>. Für den Compiler haben die Methoden jedoch unterschiedliche Signaturen, da er noch die zugehörigen Namensräume und Klassentypen berücksichtigt.
Die Methode der abgeleiteten Klasse hat hier die Methode der Basisklasse ''überschrieben'' (englisch ''override'').
Hier ein Beispiel:
<syntaxhighlight lang="java">
// Superklasse
class Person {
String redeMit( String name ) {
return "Hallo " + name;
}
}

// Abgeleitete Klasse. Superklassenrelation impliziert Supertyprelation.
class NettePerson extends Person {
// Methode redeMit(String) wird überschrieben
String redeMit( String name ) {
return "Schön Dich zu sehen, " + name;
}
}

public class Main {
public static void main( String[] args ) {
Person p;

// Hier kann erst zur Laufzeit entschieden werden, welche Methode genommen werden soll.
if ( 0.5 < Math.random() ) {
p = new Person(); // originale Person p
} else {
p = new NettePerson(); // Person p wird mit "nettem" Verhalten instanziert.
}

for ( String name: args ) {
System.out.println( p.redeMit( name ) + "." );
}
}
}
</syntaxhighlight>
Zur Laufzeit führt jedes Objekt einen Zeiger auf eine [[Tabelle virtueller Methoden]] mit, die für jede Klasse existiert. Dieser Zeiger wird bei der [[Objekt (Programmierung)#Instanziierung|Objekt-Instanziierung]] initialisiert und ermöglicht so [[Polymorphie (Programmierung)|Polymorphie]], also überschreibbares Verhalten.

Unterklasse-Instanzen können gegebenenfalls noch mittels sogenannter Superzeiger auf die überschriebenen Methoden ihrer Superklassen zugreifen.

=== Klassensignatur ===

Die Menge aller öffentlichen Signaturen definiert die Schnittstelle einer Klasse.

== Interne Repräsentation in Programmiersprachen ==
Viele [[C++]]-[[Compiler]] bilden aus dem Namen einer Funktion oder [[Methode (Programmierung)|Methode]] und der kodierten Signatur einen sogenannten ''dekorierten Funktionsnamen'' ({{enS|mangled name}}). Dieser zusammengesetzte Name bildet das [[Linker (Computerprogramm)|Linkersymbol]]. Damit kann verhindert werden, dass Funktionen mit gleichem Namen, aber unterschiedlicher Signatur durch den Linker fälschlicherweise miteinander verknüpft werden.
Die Namen von Methoden enthalten zusätzlich noch den Klassennamen. Allerdings sind die ''dekorierten Funktionsnamen'' nur für den passenden Compiler bzw. Linker zu interpretieren, wie folgendes Beispiel zeigt:
?seekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE?AV?$fpos@H@2@V32@H@Z
?seekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE?AV?$fpos@H@2@V32@H@Z

In der Programmiersprache [[Java (Programmiersprache)|Java]] existiert ebenfalls eine interne Repräsentation von Methodennamen, der sogenannte ''method descriptor''. Im Gegensatz zu C++ ist dieser Teil der Sprachspezifikation und somit für alle Compiler und [[Java Virtual Machine|virtuellen Maschinen]] identisch. Das folgende Beispiel zeigt die interne Form der Signatur der Methode „<code>Object meineMethode(int i, double d, Thread t)</code>“.<ref>Tim Lindholm, Frank Yellin: {{Webarchiv|url=http://docs.oracle.com/javase/specs/jvms/se5.0/html/ClassFile.doc.html#7035 |wayback=20130708144648 |text=''The Java<sup>TM</sup> Virtual Machine Specification: Second Edition.'' Abschnitt 4.3.3 ''Method Descriptors.'' |archiv-bot=2019-05-14 01:26:34 InternetArchiveBot }}</ref>
(IDLjava/lang/Thread;)Ljava/lang/Object;

== Siehe auch ==

* [[Funktionsprototyp]]

== Einzelnachweise ==
<references />

[[Kategorie:Programmierung]]

Signatur (Programmierung) - Versionsgeschichte

imported>SchlurcherBot: Bot: http → https