Parameter

Hintergrund

Zusammenfassung

An dieser Stelle erscheint im Buch die Abbildung "Schnittstelle einer Funktion" (grafparas)

Prototypen

Beispiel

[Prototyp]

void trennlinie(int AnzahlStriche);

int main()
{
    int breite = 45;
    trennlinie(45);
    cout << "Programm zur Ermittlung..." << endl;
    trennlinie(breite);
}

void trennlinie(int stellen)
{
    ...
}

Bei Prototypen können die Variablennamen weggelassen werden oder, wie oben zu sehen ist, zur besseren Dokumentation geändert werden. Für den Compiler sind der Funktionsname, der Rückgabetyp und die Typen der Parameter relevant.

Zeiger als Parameter

Beispiel

[Veränderlicher Parameter]

void inkrementiere(int *ziel)
{
    *ziel += 1;
}

int main()
{
    int meinWert = 5;
    inkrementiere(&meinWert); // danach ist meinWert 6
}

An dieser Stelle steht im Buch die Abbildung "Zeiger als Parameter" (grafpointerpara)

Die Grafik zeigt, wie der Aufrufer den Parameter ziel durch die Adresse der Variablen meinWert bedient und wie die Funktion mit *ziel den übergebenen Zeiger nutzt, um auf den Inhalt der Variablen meinWert zugreifen zu können.

Damit eine Funktion eine Variable des Aufrufers verändern kann, wird
deren Adresse als Argument an die Funktion übergeben. Der entsprechende
Parameter wird als Zeiger auf den Typ der Variablen definiert. 
Über diesen Zeiger kann innerhalb der Funktion der Inhalt der 
Variablen des Aufrufers verändert werden.

Konstante Zeiger

Effizienz

void fa(int a[5]);
void fb(int a[]);
void fc(int *a);

gpHinweis

Dokumentationscharakter

const

void fa(const int a[5])
{
    a[2] = 3; // Fehlermeldung des Compilers!
}

Mehrdimensionale Arrays

void fa(int a[5][4]);
void fb(int a[][4]);
void fc(int (*a)[4]);

Die Ähnlichkeit zu den Varianten der Array-Übergabe in der ersten Dimension sind unverkennbar. In der zweiten Dimension muss allerdings eine feste Größe angegeben werden.

Feste Dimension

Referenz-Parameter

Kein Zeiger

[Parameterübergabe per Referenz (refpar.cpp)]

#include <iostream>
using namespace std;

int meineFunktion(int &refParameter)
{
    refParameter = refParameter + 4;
}

int main()
{
    int meineZahl = 5;
    meineFunktion(meineZahl);
    cout << meineZahl << endl; // Ausgabe: 9!
}

Referenz und Zeiger

const

int meineFunktion(const riesentyp &refPar)
{
    ...

Tipp

Rückgabewert

[Stack als verkettete Liste (stackstruct.cpp)]

#include <iostream>
using namespace std;

struct TListenKnoten
{
    int data;            // simuliert die Daten
    TListenKnoten *next; // Verbindung zum Nachfolger
};

// Globaler Anfangspunkt des Stacks:
TListenKnoten *Anker = 0;

void push(int data)
// Füge ein neues Element hinzu
{
    // Neues Element für die Liste erzeugen:
    TListenKnoten *node = new TListenKnoten;
    node->data = data;  // Besetze die Daten
    node->next = Anker; // Hänge die bisherige Liste an
    Anker = node;       // Setze den Anfangspunkt hierher
}

int pop()
// Entnehme das zuletzt eingefügte Element
{
    int inhalt=0; // Zwischenspeicher für ein Element
    if (Anker)    // ungleich 0! Die Liste ist nicht leer!
    {
        // Sichere Zeiger auf das später zu löschende Element:
        TListenKnoten *old = Anker;
        Anker = Anker->next; // Ziehe nächstes Element nach vorn
        inhalt = old->data;  // Sichere die Daten
        delete old;          // Lösche das Element
    }
    return inhalt; // Liefere den Inhalt zurück
}

int main()
// Testen der Stack-Funktionen
{
    push(2); // Daten in den Stack schieben
    push(5); // Daten in den Stack schieben
    push(18); // Daten in den Stack schieben
    cout << pop() << endl; // muss 18 ausgeben
    cout << pop() << endl; // muss 5 ausgeben
    cout << pop() << endl; // muss 2 ausgeben
}

Sie können natürlich statt einer Integer-Variablen beliebige andere Datenstrukturen verwenden. Falls Sie in Ihrem Programm Stacks für verschiedene Datentypen benötigen, können Sie auch einen Zeiger anstelle der Daten verwenden. Wenn Sie einen Zeiger auf void verwenden, kann die Datenstruktur flexibel mit allen denkbaren Datentypen eingesetzt werden. Schließlich ändert sich die Funktionsweise von push() und pop() bei der Änderung der Daten nicht. Bevor Sie aber zu viel Schweiß in derartige Experimente stecken, sollten Sie sich vorher noch die Templates anschauen. Vielleicht lösen die Ihr Problem wesentlich eleganter.

Übungsaufgabe

• Erweitern Sie das Programm zur Realisierung eines Stacks dahingehend, dass nicht nur ein Stack in einem Programm verwendet werden kann, sondern beliebig viele, auch lokale Stacks. Hinweis: Anstatt die Funktionen push() und pop() auf die globale Liste Anker zugreifen zu lassen, müssen Sie die jeweilige Liste als Parameter übergeben.

Vorbelegte Parameter

[Vorbelegte Parameter]

void PraeVar(int a, int b, int c=4, char d='A', float e=0.0)
{
    ...
}

int main()
{
    PraeVar(5, 2, 5);
}

• a== 5. Der Wert wurde vom Aufrufer festgelegt.
• b== 2. Der Wert wurde vom Aufrufer festgelegt.
• c== 5. Der Wert wurde vom Aufrufer festgelegt. Zwar besagt der vorbelegte Parameter, dass c=4 sein soll. Dies wird aber nur gültig, wenn der Aufrufer höchstens zwei Parameter angibt.
• d== 'A'. Der Aufruf enthält nur drei Parameter, also wird der Vorgabewert verwendet.
• e== 0.0. Der Aufruf enthält nur drei Parameter, also wird der Vorgabewert verwendet.

Die Parameter der Funktion main

ANSI

Rückgabetyp

Aufrufparameter