222
 
   
   
clemens clemens clemens
Referat

TitelArten der Parameter 
Anzahl Worte919 
SpracheDeutsch 
ArtReferat 
SchlagworteReferenz Parameter; Java; Cobol; Visual Basic; 
Downloads++++++++ 
Bewertung+++ 

Download Zip (10.7kB)
Download Pdf (3.5kB)


Auszug aus dem Referat (ohne Grafiken)

Arten der Parameterübergabe
in den verschiedenen Programmiersprachen

von Hafner Peter 5.BD

Programmieren 5. Jahrgang 1998/99
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:
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:
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:
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
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
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++
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
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
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
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
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.

 

Ende des Auszuges


Hier hast Du die Möglichkeit dieses Referat zubewerten
und somit die Gesamtbewertung mitzubestimmen!