Unterprogramm - Versionsgeschichte

Pfitzi: Das soll wohl "Unterroutine" heißen ...

2011-11-04T16:21:25Z

Das soll wohl "Unterroutine" heißen ...

← Nächstältere Version		Version vom 4. November 2011, 16:21 Uhr
Zeile 21:		Zeile 21:
	* Es gibt formale Parameter - diese werden durch den aktuellen Parameter ersetzt.		* Es gibt formale Parameter - diese werden durch den aktuellen Parameter ersetzt.
	** X = Sum(3) hier wäre die 3 der aktuelle Parameter;		** X = Sum(3) hier wäre die 3 der aktuelle Parameter;
	*** In der ~~unterroute~~ Sum(x) wird dem x die 3 zugeordnet.		*** In der Unterroutine Sum(x) wird dem x die 3 zugeordnet.
	*** x ist der formale Parameter.		*** x ist der formale Parameter.
	*** Der aktuelle Parameter kann eine Variable sein.		*** Der aktuelle Parameter kann eine Variable sein.
	** Die Wertrückgabe ist der berechnete Wert.		** Die Wertrückgabe ist der berechnete Wert.
	** Der Compiler stellt beim Compilieren (bei der Übersetzung) eine Typverletzung fest		** Der Compiler stellt beim Compilieren (bei der Übersetzung) eine Typverletzung fest.
	** Interpreter stellen die Verletzung zur Laufzeit fest.		** Interpreter stellen die Verletzung zur Laufzeit fest.

Ariane: typo

2011-11-04T13:19:42Z

typo

← Nächstältere Version		Version vom 4. November 2011, 13:19 Uhr
Zeile 1:		Zeile 1:
	Ein Unterprogramm löst im idealen Fall ~~selbststädnig~~ eine Teillösung eines größeren Problems.		Ein '''Unterprogramm''' löst im idealen Fall selbstständig eine Teillösung eines größeren Problems.

	== ~~Vorzüge~~ Vorzüge von Unterprogrammen ==		== Vorzüge von Unterprogrammen ==
	* ~~eine besserer~~ Strukturierung von Programmen (Richtwert eine Seite pro Modul)		* Eine bessere Strukturierung von Programmen (Richtwert: eine Seite pro Modul)
	* Abstraktion (wie etwas zu machen ist ist in diesem Moment nicht wichtig, sondern nur was man als Eingabeparameter hat und was man als Ausgabe erwartet)		* Abstraktion (wie etwas zu machen ist, ist in diesem Moment nicht wichtig, sondern nur was man als Eingabeparameter hat und was man als Ausgabe erwartet)
	* Modularisierung		* Modularisierung
	* ~~bei~~ mehrfacher Verwendung von Code		* Bei mehrfacher Verwendung von Code
	** zum Einsparen von (Programm-)Speicherplatz.		** zum Einsparen von (Programm-)Speicherplatz.
	** Code kann damit kompakt gehalten.		** Code kann damit kompakt gehalten.
	** Wiederverwendung		** Wiederverwendung.


	== Umsetzung ==		== Umsetzung ==
	* Eine Folge von Anweisungen wird unter einem Namen zusammengefasst und wird zur Routine, Prozedur, Unterprogramm, Funktionen		* Eine Folge von Anweisungen wird unter einem Namen zusammengefasst und wird zur Routine, Prozedur, Unterprogramm, Funktionen.
	* Es können Parameter an diese Routinen übergeben werden		* Es können Parameter an diese Routinen übergeben werden.
	* Bei Funktionen wird ein Rückgabewert generiert.		* Bei Funktionen wird ein Rückgabewert generiert.


	=== ~~Parameter übergabe~~ ===		=== Parameterübergabe ===
	* Argumente einer Funktion nennt man Parameter		* Argumente einer Funktion nennt man Parameter.
	* Es gibt formale Parameter - diese werden durch den aktuellen Parameter ersetzt		* Es gibt formale Parameter - diese werden durch den aktuellen Parameter ersetzt.
	** X = Sum(3) hier wäre die 3 der aktuelle Parameter;		** X = Sum(3) hier wäre die 3 der aktuelle Parameter;
	*** In der ~~unterrounte~~ Sum(x) wird dem x die 3 ~~zugeordent~~.		*** In der unterroute Sum(x) wird dem x die 3 zugeordnet.
	*** x ist der formale Parameter.		*** x ist der formale Parameter.
	*** Der aktuelle Parameter kann eine Variable sein.		*** Der aktuelle Parameter kann eine Variable sein.
	** Die ~~Wertrückkabe~~ ist der berechnete Wert.		** Die Wertrückgabe ist der berechnete Wert.
	** Der Compiler stellt beim ~~compilieren~~ (~~Bei~~ der Übersetzung) eine Typverletzung fest		** Der Compiler stellt beim Compilieren (bei der Übersetzung) eine Typverletzung fest
	** Interpreter stellen die Verletzung zur Laufzeit fest.		** Interpreter stellen die Verletzung zur Laufzeit fest.

	=== ~~Parameter übergabe~~ Mechanismus ===		=== Parameterübergabe-Mechanismus ===
	* Call by Value		* Call by Value
	** Bei einer Wertübergabe, wird der ~~konrkte~~ Inhalt einer Variable oder eines Literals in den formalen ~~Paramter~~ kopiert. Der Wert kann geändert werden, hat aber keine Auswirkung auf den aktuellen ~~Paramter~~.		** Bei einer Wertübergabe wird der konkrete Inhalt einer Variable oder eines Literals in den formalen Parameter kopiert. Der Wert kann geändert werden, hat aber keine Auswirkung auf den aktuellen Parameter.
	* Call by Reference		* Call by Reference
	** Bei einer Referenz wird nicht der Wert selbst übergeben sondern die ~~Speicheradrese~~. Literale und Konstanten können so nicht übergeben werden. Mit diesem Mechanismus können die übergebenen ~~Paramter~~ modifiziert werden.		** Bei einer Referenz wird nicht der Wert selbst übergeben sondern die Speicheradresse. Literale und Konstanten können so nicht übergeben werden. Mit diesem Mechanismus können die übergebenen Parameter modifiziert werden.
	* (Call by Name)		* (Call by Name)
	** Veraltet.		** Veraltet.
Zeile 39:		Zeile 39:
	Parameter können innerhlab einer Funktion beliebig genannt werden. Die Funktionen sind in einem eigenen Referenzraum.		Parameter können innerhlab einer Funktion beliebig genannt werden. Die Funktionen sind in einem eigenen Referenzraum.

	== Unterschied zwischen Funktion und ~~Proezdur~~ ==		== Unterschied zwischen Funktion und Prozedur ==
	* Eine Prozedur führt eine Aktion aus		* Eine Prozedur führt eine Aktion aus
	** Hier sind Call-By-Reference-Parameter eventuell sinnvoll um Werte aus der Prozedur nach draußen zu geben.		** Hier sind Call-By-Reference-Parameter eventuell sinnvoll, um Werte aus der Prozedur nach draußen zu geben.
	* Eine Funktion berechnet einen Wert		* Eine Funktion berechnet einen Wert
	** Eine Funktion funktionert gut mit Call-By-Value-Parametern.		** Eine Funktion funktionert gut mit Call-By-Value-Parametern.
Zeile 48:		Zeile 48:
	== Praktische Umsetzung ==		== Praktische Umsetzung ==
	=== In Python ===		=== In Python ===
	In Python stehen die Definitionen der Unterroutinen am Anfang (bzw. ~~Vor~~ dem Aufruf)		In Python stehen die Definitionen der Unterroutinen am Anfang (bzw. vor dem Aufruf)

	<code>		<code>
Zeile 68:		Zeile 68:
	==== Return-Anweisung ====		==== Return-Anweisung ====
	* Gibt den Wert aus der Funktion zurück.		* Gibt den Wert aus der Funktion zurück.
	* Wird kein ~~WErt~~ angegeben oder wird die ~~return~~-Anweisung weggelassen, so wird das Objekt None zurückgegeben.		* Wird kein Wert angegeben oder wird die Return-Anweisung weggelassen, so wird das Objekt None zurückgegeben.
	* Mehrere Anweisungen können mit einem Tupel zurückgegeben werden.		* Mehrere Anweisungen können mit einem Tupel zurückgegeben werden.

	==== Namensräume ====		==== Namensräume ====
	* In Python hat jedes Unterprogramm seinen eigenen Namensraum (~~Lokaler~~ Namensraum)		* In Python hat jedes Unterprogramm seinen eigenen Namensraum (lokaler Namensraum)
	* Der Interpreter schaut erst in den lokalen Namensbereich nach und sucht dann im globalen Namensraum.		* Der Interpreter schaut erst in den lokalen Namensbereich nach und sucht dann im globalen Namensraum.

Anthoney: erg

2011-11-04T10:07:18Z

erg

@@ Zeile 44: / Zeile 44: @@
 * Eine Funktion berechnet einen Wert
 ** Eine Funktion funktionert gut mit Call-By-Value-Parametern.
 == Praktische Umsetzung ==
@@ Zeile 49: / Zeile 50: @@
 In Python stehen die Definitionen der Unterroutinen am Anfang (bzw. Vor dem Aufruf)
-def add(iX,iY):
+<code>
-....return iX+iY
+<br/>def add(iX,iY):
-#enddef
+<br/>....return iX+iY
 <code>
@@ Zeile 57: / Zeile 63: @@
 liefert als Ergebnis 7
 </code>
-(Punkte sind Leerzeichen)
+==== Namensräume ====
 == Links und Quellen ==
@@ Zeile 68: / Zeile 107: @@
 <references/>
 ----
 {{Vorlage:PPA-Eisen|Txt=Unterprogramm}}

Anthoney: init

2011-11-04T09:50:47Z

init

Neue Seite

Ein Unterprogramm löst im idealen Fall selbststädnig eine Teillösung eines größeren Problems.

== Vorzüge Vorzüge von Unterprogrammen ==
* eine besserer Strukturierung von Programmen (Richtwert eine Seite pro Modul)
* Abstraktion (wie etwas zu machen ist ist in diesem Moment nicht wichtig, sondern nur was man als Eingabeparameter hat und was man als Ausgabe erwartet)
* Modularisierung
* bei mehrfacher Verwendung von Code
** zum Einsparen von (Programm-)Speicherplatz.
** Code kann damit kompakt gehalten.
** Wiederverwendung

== Umsetzung ==
* Eine Folge von Anweisungen wird unter einem Namen zusammengefasst und wird zur Routine, Prozedur, Unterprogramm, Funktionen
* Es können Parameter an diese Routinen übergeben werden
* Bei Funktionen wird ein Rückgabewert generiert.

=== Parameter übergabe ===
* Argumente einer Funktion nennt man Parameter
* Es gibt formale Parameter - diese werden durch den aktuellen Parameter ersetzt
** X = Sum(3) hier wäre die 3 der aktuelle Parameter;
*** In der unterrounte Sum(x) wird dem x die 3 zugeordent.
*** x ist der formale Parameter.
*** Der aktuelle Parameter kann eine Variable sein.
** Die Wertrückkabe ist der berechnete Wert.
** Der Compiler stellt beim compilieren (Bei der Übersetzung) eine Typverletzung fest
** Interpreter stellen die Verletzung zur Laufzeit fest.

=== Parameter übergabe Mechanismus ===
* Call by Value
** Bei einer Wertübergabe, wird der konrkte Inhalt einer Variable oder eines Literals in den formalen Paramter kopiert. Der Wert kann geändert werden, hat aber keine Auswirkung auf den aktuellen Paramter.
* Call by Reference
** Bei einer Referenz wird nicht der Wert selbst übergeben sondern die Speicheradrese. Literale und Konstanten können so nicht übergeben werden. Mit diesem Mechanismus können die übergebenen Paramter modifiziert werden.
* (Call by Name)
** Veraltet.

=== Parameterbenamung ===
Parameter können innerhlab einer Funktion beliebig genannt werden. Die Funktionen sind in einem eigenen Referenzraum.

== Unterschied zwischen Funktion und Proezdur ==
* Eine Prozedur führt eine Aktion aus
** Hier sind Call-By-Reference-Parameter eventuell sinnvoll um Werte aus der Prozedur nach draußen zu geben.
* Eine Funktion berechnet einen Wert
** Eine Funktion funktionert gut mit Call-By-Value-Parametern.

== Praktische Umsetzung ==
=== In Python ===
In Python stehen die Definitionen der Unterroutinen am Anfang (bzw. Vor dem Aufruf)

def add(iX,iY):
....return iX+iY
#enddef

<code>
add(3,4)
liefert als Ergebnis 7
</code>

(Punkte sind Leerzeichen)

== Links und Quellen ==
=== Siehe auch ===
=== Weblinks ===
=== Quellen ===
=== Literatur ===
=== Einzelnachweise ===
<references/>
----
{{Vorlage:PPA-Eisen|Txt=Unterprogramm}}