185.109.110.126: /* Parameter/Argumente */

2024-05-08T10:12:45Z

Parameter/Argumente

Neue Seite

[[Datei:Unterprogramm Prinzip.png|mini|Grundprinzip eines Unterprogramms]]

Ein '''Unterprogramm''' ist ein Teil eines [[Computerprogramm]]s, das eine bestimmte Funktionalität bereitstellt. Es kann von anderen Programmen/Programmteilen ''aufgerufen'' werden, um eine Aufgabe zu übernehmen und verzweigt danach wieder an die aufrufende Stelle ''zurück''. Ein Unterprogramm wird i. d. R. durch einen Bezeichner (z. B. einen Namen) identifiziert, und ihm können zur Verarbeitung Daten als Argumente übergeben werden.<ref name="FU BER">[http://www.inf.fu-berlin.de/lehre/SS04/ALP2/vorlesung/1.4.pdf FU Berlin ''Unterprogramme'']</ref>

Bezüglich der [[Terminologie]] kennt man aus der Praxis einen großen Reichtum an Varianten, die teilweise synonym, teilweise mit semantischen Unterschieden angewendet werden.<ref name="FU BER" /> Bezeichnungen wie ''[[Prozedur (Programmierung)|Prozedur]] ({{lang|en|procedure}}), [[Funktion (Programmierung)|Funktion]] ({{lang|en|function}}), [[Routine (Programmierung)|Routine oder Subroutine]], Operation, {{lang|en|Section}}, [[Modul (Software)|Modul]]'' sind teils historisch und oft im Umfeld verschiedener [[Programmiersprache]]n entstanden, entsprechen aber im Wesentlichen der Bedeutung ‚Unterprogramm‘ oder werden so genannt. So sind im Kontext der [[Objektorientierte Programmierung|objektorientierten Programmierung]] ''[[Methode (Programmierung)|Methoden]] (methods)'' – je nach Programmiersprache – einer [[Klasse (Programmierung)|Klasse]], einem [[Objekt (Programmierung)|Objekt]] oder einer [[Generische Funktion|generischen Funktion]] als in sich abgeschlossene Einheiten zugeordnet.

Bezüglich der Erstellung, Wartung und [[Computerprogramm#Übersetzung und Ausführung|Ausführung]] können Unterprogramme je nach Art der Implementierung eigenständige Komponenten sein (‚Unterprogramme‘ im engeren Sinn, die oft vorübersetzt in [[Programmbibliothek]]en zusammengefasst sind) oder, zusammen mit anderen Funktionsteilen, den [[Programmcode]] eines bestimmten Programms bilden.

== Zweck von Unterprogrammen ==
Das Kapseln von Programmteilen in Unterprogrammen entspringt dem [[Programmierparadigma|Paradigma]] der [[Prozedurale Programmierung|prozeduralen Programmierung]]. Die beiden wichtigsten Vorteile, die dadurch beim [[Softwaredesign]] erzielt werden, sind die Wiederverwendbarkeit von Programmteilen und die Verbesserung der [[Softwarequalität#Beispiel ISO/IEC 9126|Verständlichkeit]] und [[Wartbarkeit]] des [[Quelltext]]s.

Unterprogramme für bestimmte technische oder betriebliche Funktionen (z. B. eine [[Prüfziffer]]nberechnung) als unternehmensweiter Standard sind ein Aspekt der [[Softwarearchitektur]].

Eine Weiterführung des Konzepts der Unterprogramme sind die [[modulare Programmierung]] und [[Modul (Software)|Software-Module]].

== Terminologie ==
; [[Funktion (Programmierung)|Funktion]]
: In Programmiersprachen wie C, C++, C#, Java oder Python werden alle Unterprogramme grundsätzlich ''Funktion'' genannt. In Sprachen wie [[Pascal (Programmiersprache)|Pascal]] oder [[BASIC]] werden nur diejenigen Unterprogramme als Funktion bezeichnet, die einen Wert an den Aufrufer zurückliefern.
; [[Prozedur (Programmierung)|Prozedur]]
: Oft wird unter Prozedur eine spezielle Funktion verstanden, die keinen Rückgabewert liefert (z. B. in Pascal oder BASIC). [[Fortran|FORTRAN77]] fasst unter {{lang|en|''procedures''}} alle Funktionen und prozedurale Unterprogramme ''(subroutines)'' zusammen.<ref>{{Internetquelle |url=http://www.fortran.com/F77_std/rjcnf0001-sh-15.html#sh-15 |titel=FORTRAN77-Standard, Kap. 15 |sprache=en |abruf=2010-09-20 |archiv-url=https://web.archive.org/web/20100124143401/http://www.fortran.com/F77_std/rjcnf0001-sh-15.html#sh-15 |archiv-datum=2010-01-24 |offline=ja |archiv-bot=2023-02-03 03:35:20 InternetArchiveBot }}</ref>
: Abweichend davon werden in [[COBOL]] als Prozeduren lediglich die in der ‚Procedure Division‘ formulierten, durch ‚Paragraphs‘ (Abschnitte) benennbaren Anweisungen (Befehle) bezeichnet, unabhängig davon, ob sie als [[Unterroutine]] verwendet werden oder nicht. Auch in [[PL/I]] bezeichnet man die im Befehlsteil des Quelltextes enthaltenen – prozedural (= ‚fortschreitend‘) zu verarbeitenden – Anweisungen als „Prozeduren“.
; [[Methode (Programmierung)|Methode]]
: Unter einer Methode versteht man in objektorientierten Programmiersprachen Unterprogramme von bzw. in Klassen.

== Geschichte ==
[[David Wheeler]], [[Maurice V. Wilkes]] und [[Stanley Gill]] gelten als Entwickler der ersten Subroutine (damals auch ''{{lang|en|Wheeler-jump}}'' genannt).<ref>{{Internetquelle |url=http://www.computer.org/portal/web/awards/cp-wheeler |titel=David Wheeler. 1985 Computer Pioneer Award |werk=www.computer.org |hrsg=IEEE |abruf=2013-10-20 |archiv-url=https://web.archive.org/web/20131020192219/http://www.computer.org/portal/web/awards/cp-wheeler |archiv-datum=2013-10-20 |offline=ja |archiv-bot=2023-02-03 03:35:20 InternetArchiveBot }}</ref><ref>{{Internetquelle |url=http://www.computerhistory.org/fellowawards/hall/bios/David,Wheeler/ |titel=David Wheeler. 2003 Fellow |werk=computerhistory.org |hrsg=Computer History Museum |offline=1 |archiv-url=https://web.archive.org/web/20150403185912/http://www.computerhistory.org/fellowawards/hall/bios/David,Wheeler/ |archiv-datum=2015-04-03 |abruf=2013-10-20}}</ref><ref>{{Literatur |Autor=David J. Wheeler |Titel=The use of sub-routines in programmes |Sammelwerk=Proceedings of the 1952 ACM national meeting (Pittsburgh) |Verlag=ACM |Ort=New York |Datum=1952 |Seiten=235–236 |DOI=10.1145/609784.609816}}</ref><ref>{{Literatur |Autor=Maurice V. Wilkes, David J. Wheeler, Stanley Gill |Titel=Preparation of Programs for an Electronic Digital Computer, with special reference to the EDSAC and the use of a library of subroutines |Auflage=1. |Verlag=Addison-Wesley |Ort=Cambridge (Massachusetts) |Datum=1951 |Seiten=22 |OCLC=1189900}}</ref>

In frühen [[Imperative Programmierung|imperativen Programmiersprachen]] (zum Beispiel frühe [[BASIC]]- und [[Fortran|FORTRAN]]-Varianten) gab es nur das Konzept des parameterlosen Unterprogramms, welches über [[Sprunganweisung]]en aufgerufen wurde und ausschließlich über globale Variablen mit dem Hauptprogramm wechselwirken konnte.

Mit dem Aufkommen der [[Strukturierte Programmierung|strukturierten Programmierung]] entwickelte sich das Konzept der Prozedur mit Aufrufparametern, die zunächst überwiegend als [[Referenzparameter]] übergeben wurden ''(call by reference)'', das heißt eine Änderung des Parameters innerhalb der Prozedur ändert den zugehörigen Parameter an der Aufrufstelle der Prozedur. Die Einführung von expliziten Rückgabewerten von Prozeduren (respektive Funktionen) ermöglichte die Berechnung von Resultaten, ohne die Referenzparameter zu verändern.

In einem weiteren Schritt wurden [[Wertparameter]] zur Übergabe an Prozeduren eingeführt ''(call by value)'', um unerwünschte Rückwirkungen auf das Hauptprogramm weiter zu reduzieren.

Zur Vermeidung von [[Programmfehler]]n wurde in einigen Programmiersprachen wie zum Beispiel [[Pascal (Programmiersprache)|Pascal]] eine [[starke Typisierung]] von Parametern eingeführt: die tatsächlich verwendeten Parameter müssen hierbei relativ streng [[Zuweisungskompatibilität|zuweisungskompatibel]] mit den formal deklarierten Parametern sein.

In manchen Programmiersprachen, wie beispielsweise [[Modula-2]], können Prozedurvariablen aufgerufen oder als Parameter eingesetzt werden.

Schließlich wurden Prozeduren als objektbezogene ''Methoden'' oder ''Zugriffsfunktionen'' Bestandteil des [[Objektorientierte Programmierung|objektorientierten Paradigmas]], etwa in den Programmiersprachen [[Java (Programmiersprache)|Java]] und [[C++]].

== Unterschiedliche Implementierungen ==
Unterprogramme können, abhängig von der verwendeten [[Integrierte Entwicklungsumgebung|Entwicklungsumgebung]] oder [[Programmiersprache]], unterschiedlich implementiert sein:
* Als logisch in sich geschlossener ''Teil im [[Quelltext]] eines Programms.'' Hinsichtlich der administrativen Verwaltung (z. B. bei Änderungen), der [[Compiler|Kompilierung]] und der technischen Ausführung auf einem Computer gehören solche Quelltextabschnitte fest zum Gesamtprogramm. Je nach Programmiersprache und Art der [[Implementierung]] hat die Subroutine Zugriff auf alle, nur bestimmte oder nur ihre eigenen Daten und Funktionen.
: Eine Variante davon ist das Verwenden von Programmcodeteilen, die als eigenständige, in [[Programmbibliothek]]en verwaltete Quelltext-Elemente geführt werden: Diese werden im Quelltext der sie benutzenden Programme durch spezielle Anweisungen (z. B. [[Include]]) in dem zur Kompilierung (temporär) bereitgestellten Quellcode eingefügt. Solche Codeteile aus Quelltextbibliotheken werden (z. B. in den Programmiersprachen [[COBOL]] oder [[RPG (Programmiersprache)|RPG]]) auch ‚Copybook‘ genannt.
* Als administrativ und zur Ausführung ''eigenständige Programme.'' Sie werden erst zur Ausführungszeit „dynamisch“ geladen. Zum Teil, zum Beispiel bei [[Dynamic Link Library|DLL's]], können solche [[Lademodul|‚nachgeladenen Module‘]] mehrere und unterschiedliche Unterprogramme enthalten. Details siehe [[Dynamisches Linken]].
* Eine ''Mischform'' aus beidem sind Unterprogramme mit ebenfalls eigenständigem Quelltext und getrennter [[Kompilierung]]. Ihr [[Maschinencode]] wird jedoch zusammen mit dem Code sie aufrufender Programme zu einer [[Ausführbare Datei|ausführbaren Datei]] „statisch gebunden“. Details siehe [[Statisches Linken]].

Innerhalb dieser Grundvarianten stellen bestimmte Programmiersprachen weitere Funktionsdetails bereit, die beim Binden und Laden von Unterprogrammen anwendbar sind. Siehe dazu die Beispiele zu ''[[Linker (Computerprogramm)#Überladen|Überladen]]'' oder ''[[Linker (Computerprogramm)#Überschreiben|Überschreiben]]''.

Eine besondere Kategorie von Unterprogrammen bilden die in einem Computersystem bereitgestellten ''[[Systemaufruf|Systemfunktionen]]'' (wie Lesen, Schreiben, Clock usw.). Sie werden im engeren Sinn nicht als Unterprogramm bezeichnet, jedoch nach demselben Ablaufprinzip benutzt: Aufruf mittels [[Anweisung (Programmierung)|Anweisung]], meist mit Parameter-/Argumentenübergabe, Ausführung der Subfunktion zum Beispiel im [[Betriebssystem]], anschließend Rückkehr ins rufende Programm mit Fortsetzung der Verarbeitung.


== Beispiele ==
Die Beispiele in den Programmiersprachen C, C++ und Java zeigen Details zur Programmierung mit Unterprogrammen.

=== C, C++ oder Java ===
Das folgende Beispiel ist ein in Unterprogramm in [[C (Programmiersprache)|C]], [[C++]] oder [[Java (Programmiersprache)|Java]], das beim Aufruf einen Wert entgegennimmt und ihn mit einem konstanten Wert multipliziert, es soll die Umrechnung von Zoll in Zentimeter demonstrieren.

<syntaxhighlight lang="c">
float inch2cm(float length) {
return 2.54 * length;
}
</syntaxhighlight>

=== Python ===
Das folgende Beispiel in [[Python (Programmiersprache)|Python]] gibt die in <code>message</code> übergebene Zeichenkette auf dem Bildschirm aus, liefert aber keinen Wert zurück.

<syntaxhighlight lang="python">
def hello(message):
print(message)
</syntaxhighlight>

=== Assembler ===
Ein einfaches Hallo-Welt-Programm in [[Assemblersprache]], die vier Zeilen ab der Marke <code>print</code> stellen das Unterprogramm dar.

<syntaxhighlight lang="asm" highlight="10-14">
segment code

..start:
mov ax, data
mov ds, ax
call print ; Aufruf des Unterprogramms
mov ah, 4Ch
int 21h ; Beenden des Programms

print:
mov dx, hello
mov ah, 09h
int 21h
ret

segment data
hello: db 'Hello World!', 13, 10, '$'
</syntaxhighlight>

=== Objektmodule Großrechner IBM-Welt ===
* Aufrufende Programme setzen einen Call-Befehl ab und übergeben dabei (mit ‚USING x, y …‘) eine Liste mit den Adressen der Datenfelder/Datenstrukturen, die das Unterprogramm benötigt oder zurückgeben soll. Im [[Maschinencode]] des Programms wird dabei vom [[Compiler]] das Register 1 mit der Adresse der Adressliste und das Register 14 mit der Rücksprungadresse, Register 15 mit der Einsprungadresse im Unterprogramm geladen, danach wird (über ‚BR 15‘) dorthin verzweigt.
* Aufgerufene Programme übernehmen die übergebenen Adressen zur Adressierung ihrer strukturidentischen Datendeklarationen (deren Bezeichner jedoch anders gewählt werden können), wodurch diese 'fremden’ Daten mit den Befehlen des Unterprogramms ansprechbar sind.
* Nach der Verarbeitung im Unterprogramm erfolgt der Rücksprung über das Register 14.

Wie und mit welchen Aufrufkonventionen aufrufende und aufgerufene Module zusammenwirken, zeigt das nachfolgende Beispiel. Unterstellt sei ein fiktives Hauptprogramm, das ein Unterprogramm mit Namen UPRO aufruft. Siehe auch nebenstehende Grafik:
[[Datei:Call-Schnittstelle IBM.png|mini|Struktur der Call-Schnittstelle]]
* Quellcode des rufenden Programms (im Beispiel COBOL-ähnlicher Code):
* Daten:
A.
>Struktur von A, z. B.:
Ax >Format und Längen
Ay ...
B.
B1 (Definitionen, ggf. weitere Teilfelder)
B2 (Definitionen)
B3 (Definitionen)
* Funktionscode:
A-ROUTINE.
A-1. >Befehle-1
Call UPRO Using A, B2.
A-2. >Befehle-2, z. B. Auswerten und Verarbeiten Rückgabewert(e)
A-ROUTINE Exit.
>beliebige weitere Routinen/Befehle
* Programm-Ende

* Quellcode des Unterprogramms, ggf. aus einer anderen Programmiersprache:
: Der daraus erzeugte Objectcode ist im Lademodul des Hauptprogramms eingebunden.
* Datendefinitionen:
A-DAT >Format und Sub-Struktur wie in A; andere Bezeichner möglich!
B-2 dto.
C-x z. B. eigene Definitionen von UPRO
* Funktionscode:
Entry UPRO Using A-DAT, B-2.
>Feldbezeichnungen von Using ggf. abweichend, Reihenfolge identisch zu 'Call'!
>Weitere Befehle des Unterprogramms:
>Mit vollem Zugriff (auch ändernd) auf die Struktur (Einzelfelder) von A-Daten und B2.
Ggf. setzen Returncode, z. B. in B-2 (= B2)
Exit = UPRO-Ende

* Ablauf des Unterprogramm-Aufrufs (Call und [[Return Code|Return]]):
: (vom Compiler generierter Code, bei [[Assemblersprache|Assemblerprogrammen]] vom Programmierer codiert)
* Call im rufenden Programm:
Setzt in einer (vom Compiler angelegten) Hauptspeicher-Adressliste
mit 2 Einträgen die Adresse von A und von B-2
Setzt einen Zeiger ([[Register (Computer)|Register]], konkret R1) auf die Adressliste
Setzt einen Zeiger (Register 14) auf die Rückkehradresse A-2.
Setzt einen Zeiger (Register 13) auf die Register-Savearea,
(Speicherbereich automatisch vom Compiler reserviert, Details siehe<ref>[http://publib.boulder.ibm.com/infocenter/zvm/v5r4/index.jsp?topic=/com.ibm.zvm.v54.gcta0/dup0008.htm IBM SAVE]</ref>)
Lädt Register 15 mit der Adresse (Entrypoint) des Unterprogramms
(die z. B. vom [[Linker (Computerprogramm)|Linkage Editor]] im Maschinenprogramm eingesetzt wurde)
Verzweigt über R15 in das Unterprogramm
* Entry im Unterprogramm:
>Sichern der Registerstände in die Savearea des rufenden Programms (lt. R13)
Speichern der Adresse dieser Savearea (= Inhalt R13) in einem eigenen Speicherbereich
>Übernehmen der übergebenen Variablen (aus Adressliste lt. R1):
Adr(A-DAT) = aus Adressliste(1. Adresse), Adr(B-2) = aus Adressliste(2. Adresse)
>Verarbeitung – mit Zugriff auf übergebene und eigene Daten sowie individueller Registernutzung
* Rücksprung ins rufende Programm:
>Laden R13 mit der gespeicherten Adresse der Savearea
Rückladen aller Register aus der Savearea lt. R13
>Exit: Verzweigung (= Rückkehr) zu Adresse A-2 im rufenden Programm (lt. Inhalt R14)

Nach demselben Schema (Registerkonventionen, Savearea) könnte das Modul weitere Untermodule aufrufen. Das dazu erforderliche Sichern der Registerstände zum Zeitpunkt des Aufrufs erfolgt jeweils in einer „Savearea“ genannten Speicherstruktur aufrufender Module, die folgenden Aufbau aufweist:<br />
|_A_|_B_|_C_|_D1_|_D2_|_.._|_D15_| = 18 „Fullwords“ (je 4 Bytes) = 72 Bytes<small>
A = nicht belegt, reserviert
B = Adresse der Savearea des aufrufenden Moduls; vom aufgerufenen Modul in seiner eigenen Savearea gesetzt
C = Adresse der Savearea des aufgerufenen Moduls; vom aufgerufenen Modul in der Savearea des aufrufenden Moduls gesetzt
Dn = Inhalt der Register „14 bis 12“ (entspricht R14,R15,R0,R1 .. R12):
vom aufgerufenen Modul in der Savearea des aufrufenden Moduls gespeichert und vor dem Rücksprung zurückgeladen.</small>
Über die Inhalte von Speicherstelle B und C sind die Saveareas der beteiligten Module in ihrer Aufrufreihenfolge miteinander ''verkettet;'' sie zeigen den Stand des jeweils letzten Modulaufrufs, womit sich z. B. im [[Debugger|Debug-Modus]] bei [[Modultest]]s die Aufruftiefe und die -Reihenfolge ermitteln und nachvollziehen lässt. Einen detaillierten Assembler-Programmcode für die Savearea-Behandlung zeigt [[Liste von Hallo-Welt-Programmen/Assembler#IBM-Mainframe-ASSEMBLER|dieses Beispiel]].

== Parameter/Argumente ==
{{Hauptartikel|Parameter (Informatik)}}
Unterprogramme (UP) führen [[Funktion (Objekt)|Funktionen]] aus, die in der Regel Daten benötigen, die zu den sie aufrufenden Programmen gehören. Aus Sicht des Unterprogramms können diese Daten Eingangs- oder Ergebniswerte sein. Da je nach angewendeter Unterprogrammtechnik ein Unterprogramm grundsätzlich nur ‚Zugriff‘ auf seine eigenen Daten hat, enthalten die Programmiertechniken und -Sprachen Mechanismen, mit denen die ‚fremden‘ Daten für das Unterprogramm verfügbar gemacht werden; nur dann können dessen Befehle die für sie ‚externen‘ Daten ansprechen. Je nach UP-Variante/Programmiersprache können diesbezüglich verschiedene Konstellationen unterschieden werden:
* Das Unterprogramm kann auf alle im Hauptprogramm definierten Daten zugreifen. Meist ist das nur bei Unterroutinen der Fall, die zum Quellcode des Hauptprogramms gehören.
* Das Unterprogramm kann auf Daten(bereiche) zugreifen, die als ‚global‘ deklariert wurden.
* Der Unterroutine werden 'ihre' Daten beim Aufruf explizit ‚mitgeteilt‘. Die Angaben dazu sind sogenannte „Parameter“.

Die Parametertechnik wird vor allem bei unabhängig vom aufrufenden Programm entwickelten Unterprogrammen verwendet, um einem aufzurufenden UP mitzuteilen, welche Daten es verwenden/verarbeiten soll. Diese Parameter bilden die gemeinsame [[Schnittstelle]] zwischen aufrufendem und aufzurufendem UP. Ein Beispiel ist „DispoSaldoPrüfen (Kontonummer, Betrag, Antwort)“. Im Unter- und im Hauptprogramm sind diese Angaben nach einheitlich angewendeten Konventionen strukturell identisch zu deklarieren. Die während der Programmausführung beim einzelnen Aufruf tatsächlich übergebenen Werte werden 'Argumente' genannt, z. B. als Kontonummer der Wert '4711' und als Betrag '-500,00', als Antwort könnte alternativ 'OK' oder 'Überziehung' zurückgeliefert werden. Dieses Begriffspaar (''Parameter'' und ''Argument'') wird synonym auch als ''formale'' und ''tatsächliche Parameter'' bezeichnet.

Parameter/Argumente können ''elementare'' [[Datenfeld]]er beliebigen Formats sein, z. B. Text oder Integer – oder auf beiden Seiten der Schnittstelle einheitlich definierte [[Datenstruktur]]en. Bezüglich der Verwendbarkeit der übergebenen Daten kann unterschieden werden, ob diese ''nur gelesen'' oder auch ''verändert'' werden können, zum Beispiel für Ergebniswerte. Weiterhin lässt sich unterscheiden, ob mit den Parametern ''Adressen'' (im Hauptspeicher) oder die ''tatsächlichen Daten'' übergeben werden.

Technisch (z. B. im Maschinencode) erfolgt die Übergabe der Parameter/Argumente je nach verwendeter Programmiersprache und Rechnertechnologie mithilfe unterschiedlicher Hardware-Einrichtungen. So kann z. B. der [[Stapelspeicher|Stack]] die Argumente aufnehmen oder Parameter werden über [[Register (Computer)|Register]] übergeben.

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=4253859-2}}

[[Kategorie:Programmiersprachelement]]
[[Kategorie:Unterprogramm| ]]

Unterprogramm - Versionsgeschichte

185.109.110.126: /* Parameter/Argumente */