Schnittstelle

Die Parameterdefinition einer Funktion gleicht einer Variablendefinition. Der Typ der Parameter ist wichtig, um zu prüfen, ob die Aufrufparameter mit den Parametern der Funktion auch kompatibel sind. Über die Parameternamen wird von innen aus der Funktion heraus auf die Parameter zugegriffen. Zur Veranschaulichung wird die Funktion trennlinie() so erweitert, dass der Aufrufer angeben kann, wie viele Bindestriche ausgegeben werden sollen.

[Funktion trennlinie mit Parameter]

void trennlinie(int stellen)
{
    int i;
    for (i=0; i<stellen; i++)
    {
        cout << "-";
    }
    cout << endl;
}
...
int main()
{
    int breite = 45;
    trennlinie(breite);
    cout << "Programm zur Ermittlung..." << endl;
    trennlinie(45);

Variable

Der Aufrufer merkt nicht, was in der Funktion mit der Variablen geschieht. Der Wert, der bei einem Aufruf an die Funktion übergeben wird, wird kopiert. So ist es möglich, auch eine Konstante (hier 45) als Parameter zu übergeben.

Seiteneffekt

Wertübergabe an Parameter

Parametervariablen sind lokale Variablen der Funktion, die beim Funktionsaufruf
durch eine Kopie der übergebenen Werte initialisiert werden.

Hintergrund

In Abbildung (graffunction2) wird noch einmal der Syntaxgraph von Abbildung (graffunction) dargestellt. In Abbildung (grafparameter) wird dieser um die Funktionsparameter ergänzt.

An dieser Stelle erscheint im Buch die Abbildung "Syntaxgraph Funktion" (graffunction2)

An dieser Stelle erscheint im Buch die Abbildung "Syntaxgraph Parameter" (grafparameter)

Parameter ohne Namen

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

const int *konstantesZiel;

Konstantes Ziel

int * const konstanterZeiger;

Konstanter Zeiger

const int * const komplettKonstant;

Die letzte Variante kombiniert beides und verhindert sowohl das Inkrementieren des Zeigers als auch den Zugriff auf die Aufrufvariable.

Die Verwendung von const hat dokumentierenden Nutzen. Es sagt dem Aufrufer, was die Funktion mit dem Zeiger tut oder nicht tut. Diese Zusage wird darüber hinaus vom Compiler überwacht.

Arrays als Parameter

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

Übung

• Schreiben Sie eine Funktion namens swap, die zwei Parameter per Referenz entgegennimmt und den Inhalt der beiden Parameter vertauscht.

Beispiel: Stack

[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

int main (int argc, char* argv[])
{
    ...
}

Die Namen argc und argv sind reine Konventionen. Sie können die Parameter natürlich anders nennen. Da sie aber aber inzwischen unter diesem Namen bekannt sind, führt eine Änderung nicht unbedingt zu mehr Klarheit. Betrachten wir zunächst den zweiten Parameter argv. Er ist ein Array von Zeigern auf C-Strings. Grafisch dargestellt sieht argv also so aus wie in Abbildung (picargv).

An dieser Stelle findet sich im Buch die Abbildung "[Der Parameter argv]" (picargv)

argv ist ein Array, das Zeiger enthält. Jeder der Zeiger zeigt auf einen C-String, also auf ein Array vom Typ char, dessen Ende durch ein Nullbyte gekennzeichnet wird. Der erste Zeiger, also argv[0], zeigt immer auf den Programmnamen, mit dem das Programm gestartet wurde. Entsprechend ist argc immer mindestens eins. Diese Eigenheit wird vor allem unter UNIX gern genutzt, um über den Programmnamen auch die Funktionalität zu steuern. Prominentes Beispiel ist das Packprogramm gzip, das entpackt, wenn es als gunzip aufgerufen wurde. Wird ein Dateiname als Parameter angegeben, findet sich dieser unter argv[1]. In diesem Fall enthält die Variable argc den Wert 2.

Beispiel

[Zeigt die Aufrufparameter (main.cpp)]

#include <iostream>
using namespace std;

int main(int argc, char **argv)
{
    for (int i=0; i<argc; i++)
    {
        cout << argv[i] << endl;
    }
    return 0;
}

Variable Anzahl von Parametern

Start und Ende

Zugriff

[Zugriff auf unspezifizierte Parameter (vararg.cpp)]

#include <iostream>
using namespace std;
#include <stdarg.h>

void meineFunktion(int Anzahl, ... )
{
    va_list params; // Zugriffshandle für Parameter
    int intpar;     // Parameterinhalt
    va_start(params, Anzahl); // Zugriff vorbereiten
    // Durchlaufe alle Parameter (steht in Anzahl)
    for (int i=0; i<Anzahl; i++)
    {
        intpar = va_arg(params, int); // hole den Parameter
        cout << intpar << endl;       // zeige ihn an
    }
    cout << "---" << endl;
    va_end(params); // Zugriff abschließen
}

int main()
{
    // Tests der Funktion mit unterschiedlichen Parametern
    meineFunktion(2, 5, 2);
    meineFunktion(0);
    meineFunktion(4, 5, 2, 0, 3);
}

Anzahl der Parameter

Riskant

[1]

argc steht für argument count. Das bedeutet etwa »Anzahl der Argumente«.

[2]

argv steht für argument vector.

[3]

In Einzelfällen werden Sie auch einen dritten Parameter sehen, der ein Zeiger auf die Environment-Variablen darstellt. Dies wird aber vom POSIX-Standard nicht unterstützt. Der Grund ist, dass der Zugriff über die Funktionen getenv() und setenv() sehr viel einfacher ist.