Artikel pedia
| Home | Kontakt | Artikel einreichen | Oberseite 50 artikel | Oberseite 50 autors
 
 
Artikel kategorien
Letztes fugte hinzu
    Ms-access
   Instrumentation + schnittstellen
   Pc tuning - volle kraft voraus für ihr system
   Informatorische grundlagen
   Javascript
   Interne sortieralgorithmen - der kern der sache
   Plotter und sonstige drucker
   Frage 20 (rössl priska)
   Internet - programmierung
   Monitore
   Semesterarbeit und spezialgebiet für informatik
   Erörterungs zum thema
   Inhaltsverzeichnis
   Einführung in die entwicklung ganzheitlicher informationssysteme:
   Titel dokument
alle kategorien


  Arten der parameterübergabe

Arten der Parameterübergabe in den verschiedenen Programmiersprachen   1. Einleitung Durch die immer stärker werdende Modularisierung von Programmen durch Prozeduren, Funktionen oder auch Objekte stellt sich das Problem des Informationsaustausches unter den einzelnen Modulen. Die Module sollen von außen Informationen bekommen und auch Informationen zurückgeben können, ohne dabei ihre Modularität zu verlieren. Dies wird in den meisten Fällen mittels Parametern realisiert. Parameter sind definierte Schnittstellen von Funktionen, die in drei Gruppen aufgeteilt werden können. 1.

1 Werte-Parameter (Eingabeparameter, call by value): Werte-Parameter dienen dazu, an eine Prozedur oder Funktion Informationen zu übergeben. Eine Änderung des Parameters in der Prozedur hat keine Wirkung nach außen. Eigenschaften: Eine Kopie der Variable wird auf dem Stack abgelegt. Zum Zeitpunkt des Aufrufs eines Unterprogrammes wird ein Wert (Ergebnis eines Ausdrucks) an den Werteparameter übergeben. Die Veränderung der Kopie (am Stack) innerhalb der Prozedur oder Funktion hat keine Auswirkung auf die ursprüngliche Variable. Im Aufruf können daher Konstanten, Variablen, Ausdrücke und Funktionswerte stehen.

1.2 Referenz-Parameter (Ein-/Ausgabeparameter, call by reference): Referenz-Parameter haben den Zweck, Ergebnisse aus einer Prozedur oder Funktion dem aufrufend- en Modul zur Verfügung zu stellen (Output-Parameter). In den meisten Programmiersprachen können die Referenz-Parameter auch als Werte-Parameter verwendet werden. Eigenschaften: Die Adresse der Variable wird am Stack abgelegt Beim Aufruf eines Unterprogrammes wird die Variable selbst verwendet, bzw. eventuell auch verändert Im Aufruf können daher nur Variablen stehen, die vom selben Typ bzw. konvertierbar sind.

1.3 Funktions-Parameter: Mit Funktionsparametern ist es möglich eine Funktion, vielmehr einen Zeiger auf eine Funktion, einem Modul zu übergeben und dann aufzurufen. Anwendung: Menüsteuerung, Rückruffunktion, Quicksort... Eigenschaften: Eine ganze Funktion/Prozedur wird als Parameter an das Unterprogramm übergeben.

1.4 Vor- bzw. Nachteile der Parameterübergabe: Vorteile: + keine globalen Variable nötig, übersichtlicher + modulares Programmieren möglich + Funktionen/Module lassen sich leichter testen + Funktionen/Module in anderen Programmen wiederverwendbar Nachteile: - Gefahr bei Rekursion (Stacküberlauf) - Geschwindigkeitsverlust - Gefahr von eventuellen Übergabefehlern (Reihenfolge, Typ oder Anzahl) 1.5 Weitere Begriffe Aktual-Parameter: - Parameter, die beim Aufruf einer Funktion/Prozedur angegeben werden. - z.B.

funktion(4177) à 4177 ist Aktual-Parameter Formal-Parameter: - Parameter, die in der Funktion/Prozedur verwendet werden und den Wert des Aktual-Parameters übernehmen. - z.B. funktion(int x) à x ist Formal-Parameter 1.6 Übersicht der Parameterübergaben:     Ansi-C C++ Java V-Basic (bis 4.0) Cobol Werte-Parameter Variable-Parameter Funktions-Parameter ja ja (Array) ja ja ja ja ja ja (nur bei Obj.

) nein ja ja nein nein ja nein 2. Parameterübergabe in den verschiedenen Programmiersprachen 2.1 Ansi-C Keine "echten" Variable-Parameter möglich (mit Zeigern arbeiten und Adresse der Var. übergeben) Array / Strings sind Zeiger void fu (int a, int *b) {     a = a + 1;     *b = a; } Aufruf:     fu(a, &b); // a=2, b=0     printf("%d", a); // a=2     printf("%d", b); // b=3 Funktions-Parameter anhand eines Beispiels: typedef int (*FZ) (int,int);       // Funktions-Zeiger Deklaration void aufruf (FZ); int add (int a, int b); int sub (int a, int b); void main (void) {     FZ fu;      fu = add;     // Funktion add wird dem Funktions-Zeiger zugewiesen     aufruf (fu);     // Ausgabe: 30     fu = sub;     // Funktion sub wird dem Funktions-Zeiger zugewiesen     aufruf (fu);     // Ausgabe: 10 } void aufruf (FZ fu) {     printf("\n %d \n", (*fu) (20,10)); } int add (int a, int b) {     return(a + b); } int sub (int a, int b) {    return (a – b); } 2.2 C++ Referenzen ermöglichen Variable-Parameter void fu (int a, int &b) {     a = a + 1;     b = a; } Aufruf:     fu (a, b);     // a=2, b=0     cout << a;     // a=2     cout << b;     // b=3 Default-Parameter erlauben das Weglassen bestimmter Parameter (von rechts nach links) void fu (int a, int b = 2, int c = 3) {     ..





. } Aufruf:     fu (10,20,30);     // è 10,20,30     fu (10,20);     // è 10,20,3     fu (10);     // è 10,2,3     fu ();     // èFehler 2.3 Java In Java erfolgt die Parameterübergabe immer "by value" Einzige Ausnahme: "by reference" bei der Übergabe von Objekten void add(int a, int b, int sum) {     sum = a + b; } Aufruf:     a=2, b=0, sum=0     add(a,b,sum);     // a=2,b=0,sum=0                              // weil nur "by value" Abhilfe: Returnwert int add (int a, int b) {     int sum;     sum = a + b;     return sum; } Aufruf:     a=2, b=1     sum = add (a, b);     // sum = 3 2.4 Visual Basic In Visual Basic sind alle Parameter standardmäßig Referenz-Parameter, können aber durch das Schlüsselwort ByVal in Werte-Parameter umgewandelt werden (ausgenommen Arrays). Es gibt zwei Arten von Aufrufen bei Sub-Prozeduren (mit und ohne Klammern) Bei Funktionen: Aufruf ohne call, jedoch mit Klammern Sub Add (ByVal a As Integer, ByVal b As Integer, Summe As Integer)    Summe = a + b End Sub Aufruf:    Add a, b, Summe  oder    Call Add (a, b, Summe) Hinweis: Add a, (b), Summe    // 2. Parameter wird als Werte-Parameter übergeben                                    (auch wenn 2.

Ref.Par. ist) 2.5 Cobol Die Parameterübergabe ist nur an externe Unterprogramme möglich Es können nur Referenz-Parameter übergeben werden IDENTIFICATION DIVISION. ********************************** PROGRAM-ID. UNTER.

ENVIRONMENT DIVISION. ********************************* DATA DIVISION. ********************* LINKAGE SECTION. 77 A PIC 999. 77 B PIC 999. 77 SUMME PIC 9999.

PROCEDURE DIVISION USING A, B, SUMME.     COMPUTE SUMME = A + B. END. IDENTIFICATION DIVISION. ********************************** PROGRAM-ID. HAUPT.

ENVIRONMENT DIVISION. ********************************* DATA DIVISION. ********************* WORKING-STORAGE SECTION. 77 A PIC 999. 77 B PIC 999. 77 SUMME PIC 9999.

PROCEDURE DIVSION. ****************************** ACCEPT A FROM TERMINAL. ACCEPT B FROM TERMINAL. CALL "UNTER" USING A, B, SUMME. DISPLAY SUMME UPON TERMINAL STOP RUN.  

Suchen artikel im kategorien
Schlüsselwort
  
Kategorien
  
  
   Zusammenfassung Der Vorleser
   sachtextanalyse
   interpretation zwist
   Fabel interpretation
   literarische charakteristik
   interpretation bender heimkehr
   felix lateinbuch
   interpretation der taucher von schiller
   textbeschreibung
   charakterisierung eduard selicke


Anmerkungen:

* Name:

* Email:

URL:


* Diskussion: (NO HTML)





Partner: www.litde.com | impressum | datenschutz

© Copyright Artikelpedia.com