Parameterübergabe bei Unterprogrammen

Die bisher verwendeten Beispiele “ratio” und “Zeile” kamen wir mit relativ einfachen Methoden aus. Methoden können aber auch komplexer werden. So könnte es eine Methode geben, die als Parameter eine Bruchzahl akzeptiert und sie in Text in einer Zeile umwandelt. Oder wenn man das Beispiel umdreht, könnte man auch an die Ausgabe einer Bruchzahl denken, die zusätzlich einen beliebigen Führungstext in einem Zeilenobjekt als Parameter erhält.

Um solche Aufgaben zu lösen, müssen wir wissen, wie man Variable und Objekte über die Schnittstelle einer Methode oder allgemein eines Unterprogramms übergibt. Zuerst wenden wir uns den Möglichkeiten der Übergabe von Variablen der vordefinierten Datentypen zu und besprechen danach die Übergabe von Objekten.

Formale und aktuelle Parameter

Beim Aufruf eines Unterprogramms sind immer zwei Sätze von Parametern beteiligt: die beim Aufruf benutzten aktuellen Parameter und die formalen Parameter des Unterprogramms. Wenn man ein Unterprogramm schreibt, es also definiert, dann definiert man in der Schnittstelle die formalen Parameter.  

Formale Parameter sind lokale Variable des Unterprogramms. Sie können, wie jede andere Variable auch, verändert werden.

Beim Aufruf werden nun die jeweils verwendeten aktuellen Parameter an die formalen Parameter zugewiesen. Das Unterprogramm bearbeitet mit den Parametern und seinen lokalen Variablen das gestellte Problem und erzeugt einen Rückgabewert. Wird ein Unterprogramm als Prozedur geschrieben, entfällt der Rückgabewert.

Lokale Variable und formale Parameter haben eine begrenzte Lebensdauer. Sie existieren nur während des Ablaufes des Unterprogramms. Es gehört daher zum Aufruf des Unterprogramms, diese Variable am Stack anzulegen und zu initialisieren. Der Wert der aktuellen Parameter wird genaugenommen nicht für eine Zuweisung verwendet, sondern zur Initialisierung der formalen Parameter. Dieser kleine Unterschied wird uns gleich noch beschäftigen.

Übergabemethoden: per Wert oder per Referenz

Bei der Übergabe von Parameter kann man die Frage nach dem Typ und der Übergabemethode stellen. In C ist die Übergabemethode klar. Es gibt nur die Wertübergabe. In C++ und in anderen Sprachen, wie z.B. Pascal, gibt es noch die Übergabe per Referenz. Um Mißverständnisse zu vermeiden, unterscheiden wir hier deutlich zwischen dem, was übergeben wird und der verwendeten Methode.

Wenn eine Adresse als aktueller Parameter vorliegt und ein Zeiger als formaler Parameter, dann passen beide zusammen. Der Compiler braucht nur dafür sorgen, daß der Zeiger angelegt und mit der Adresse initialisiert wird. Es handelt sich also um die Übergabe einer Adresse mit Hilfe der Wertübergabe.

Seite 76    Einsteigerseminar C++

Wertübergabe bedeutet, daß der aktuelle Parameterwert vom Compiler in den formalen Parameter des Unterprogramms kopiert wird.

Referenzübergabe bedeutet, daß der Compiler selbständig und für den Programmierer verdeckt statt eines Parameters dessen Adresse übergibt und bei der Verwendung automatisch mit der Adresse indirekt zugreift.

Im Beispiel Bild 6-3 wird beim Aufruf in der Zeile 11 der formale Parameter “param” erzeugt und mit dem Wert aus der Variablen “variable” initialisiert. Die Veränderung des formalen Parameters in der Funktion “incr” hat keinen Einfluß auf die Originalvariable “variable”. Es sind zwei völlig unabhängig voneinander existierende Variablen. Die “printf”-Anweisung der Zeile 12 wird daher “77" ausgeben, den ursprünglichen Wert. Der formale Parameter ”param" verliert am Ende der Funktion in der Zeile 6 seine Gültigkeit. Die Veränderung geht verloren.

Die Wertübergabe kann natürlich auch zu Übergabe von Adressen benutzt werden. (Adressen bezeichnet man gelegentlich auch als Referenzen (leider).) Hier muß in diesem Fall die Adresse bei der Übergabe gebildet werden. Als formaler Parameter wird dann ein Zeiger benutzt.

Der formale Parameter ist jetzt ein Zeiger, der mit einer übergebenen Adresse initialisiert wird. Greifen wir in der Zeile 5 mit dem Zeiger indirekt zu, ändern wir das, worauf der Zeiger zeigt: den aktuellen Parameter, dessen Adresse wir übergeben haben.

Adreßübergaben werden benutzt, um innerhalb von Funktionen auf die aktuellen Parameter zugreifen zu können oder um große Datenstrukturen nicht kopieren zu müssen. Die Adresse ist schließlich nur zwei oder vier Byte groß, ein Feld kann Tausende von Bytes erreichen. Hier ist die Übergabe einer Adresse die viel schnellere Methode.

Eine andere Situation liegt vor, wenn der Compiler beim Übergeben eines Wertes eine Dienstleistung erbringt. Die Leser, die mit Pascal vertraut sind, kennen die Referenzübergabe unter einem anderen Namen: “var-Parameter”. (Wirth spricht von einem Parameter, der den aktuellen Parameter repräsentiert.) Wir wollen deshalb einen kurzen Abstecher zu Pascal machen.

Für viele C-Programmierer war ein hartes Stück Arbeit, sich an die Zeiger und Adressen zu gewöhnen. Will man innerhalb einer Funktion in C auf die Originalvariable zugreifen, dann muß man deren Adresse übergeben und innerhalb der Funktion damit indirekt zugreifen (mit dem “*”-Operator). In Pascal schreibt man einfach vor den Parameter das Schlüsselwort “var”. Damit teilt man dem Compiler mit, daß er sich selbst um die Übergabe kümmern soll. Der Programmierer braucht keinen indirekten Zugriff anzugeben.

Im Pascal-Beispiel wird in der Parameterliste den drei Parametern das Schlüsselwort “var” vorangestellt. Innerhalb der Prozedur kann der Programmierer nun einfach mit der Anweisung “k := j;” auf die aktuellen Parameter zugreifen und sie verändern. Die formalen Parameter repräsentieren (verweisen auf) die aktuellen Parameter, die in Pascal Variable sein müssen. Würde “var” fehlen, dann würden die Werte in formale Parameter kopiert und die Originalvariable blieben unverändert. Das Beispiel stammt aus dem Buch “Pascal User Manual and Report” von Jensen/Wirth.

 Rahmen11 In C++ gibt es einen fast identischen Mechanismus. Wie immer bei C (und C++) wurde er völlig allgemein und nicht nur für die Parameterübergabe realisiert.

Im Bild 6-6 werden die formalen Parameter mit Hilfe von Referenzvariablen realisiert. Ähnlich der Definition eines Zeigers mit einem “*” stellen wir bei der Referenz nun dem Namen ein “&” davor: “” wird als Referenz auf eine “int”-Variable definiert.

Innerhalb der Funktion benutzen wir den Parameter wie wir es von normalen Variablen gewohnt sind. Das gleiche gilt für den Aufruf. Intern erbringt der Compiler jedoch eine Dienstleistung. Beim Anlegen des formalen Parameters weiß er, daß er die Referenz auf den aktuellen Parameter “variable” bilden soll. Technisch wird deshalb die Adresse übergeben. Beim Zugriff mit Hilfe einer Referenzvariablen weiß der Compiler, daß es eine Referenz, ein Verweis, ist und wird automatisch auf das zugreifen, auf das sich die Referenz bezieht: auf den aktuellen Parameter. Der Typ des Parameters ist hier Referenz auf “” oder kurz “int &”.

Für den Programmierer ist das sehr angenehm. Er definiert nur an einer einzigen Stelle, bei der Definition der formalen Parameter, daß eine Adresse übergeben werden soll und braucht sich danach nie wieder Gedanken über Adressen und indirekten Zugriff mit dem “*”-Operator zu machen. Deklariert man eine Funktion mit Referenzparametern muß auch hier der Typ “Referenz auf” angegeben werden. Verändert wird im Unterprogramm nun die Variable im aufrufenden Programm.

Anders als in Pascal kann dieser Mechanismus nicht nur für Parameter sondern auch für spezielle Variablen (sogenannte Aliasvariablen) und Funktionsrückgaben benutzt werden.

Im Beispiel des Bildes 6-7 wird auch der Rückgabewert per Referenz zurückgegeben. Der Rückgabewert wird in der, gegenüber den anderen Beispielen veränderten, “printf()”-Anweisung benutzt. Wieder gibt es nur eine einzige Stelle, an der dem Compiler die Verwendung einer Adresse mitgeteilt wird.

Bei so einfachen Variablen mit dem Datentyp "int" hat die Rückgabe mit Referenz keinen Sinn, da hier der Aufwand mit einer Adresse zu arbeiten größer ist, als wenn man gleich das Ergebnis zurückgibt. Bei Feldern, Strukturen und natürlich Objekten ist das anders.

Bei aller Einfachheit der Referenz gibt es doch eine sehr gefährliche Mißbrauchsmöglichkeit. Schauen wir uns dazu wieder ein Beispiel im Bild 6-8 an. Versuchen wir einmal, eine lokale Variable oder einen Parameter per Referenz zurückzugeben.

Wenn wir uns erinnern, daß intern bei der Referenz-Rückgabe mit Adressen gearbeitet wird und wenn wir weiter daran denken, daß Parameter und lokale Variable am Ende der Funktion ihre Gültigkeit verlieren, dann zeigt die zurückgegebene Adresse auf eine ungültige Variable. Die zurückgegebene Adresse wird erst nach dem Beenden der Funktion weiterbenutzt.

Nicht alle Compiler melden hier einen Fehler.

Wichtig: Versuchen Sie niemals lokale Variable oder Wertparameter per Referenz zurück zu geben!

Allgemeine Referenz oder Alias-Variable

Wie schon erwähnt steht der Referenzmechanismus in C++ auch für normale Variable zur Verfügung. Diese Variable werden auch Alias-Variable genannt, da sie einen zweiten Namen für eine Wertvariable einführen.

Referenzvariable und Referenzparameter unterscheiden sich nur durch die Initialisierung. Bei allgemeinen Referenzvariablen wird der Initialisierungswert bei der Definition der Variablen, bei Referenzparametern beim Aufruf angegeben.

Referenzvariable könnte man auch als “Zeigervariable mit Zugriffsautomatik” bezeichnen. Schauen wir uns den Umgang mit Referenzen an.

Bei der Definition einer Referenzvariablen nehmen wir einen selbstdefinierten Namen und schreiben den Typ davor. Der Typ ist hier “ &”, Referenz auf “int”. Beim Definieren muß initialisiert werden. Der Initialisierungswert ist eine normale Variable. Wegen der Referenz nimmt der Compiler automatisch die Adresse und legt sie in der Referenzvariablen ab. Verwendet man dann die Referenzvariable in einer Zuweisung, greift der Compiler automatisch mit der Adresse in der Referenzvariablen indirekt zu. Dabei greift er auf die Variable zu, auf die wir uns beziehen; hier “intvar”.

Beachten Sie auch den Unterschied zwischen der Initialisierung, bei der automatisch eine Adreßgewinnung erfolgt und der Zuweisung, bei der automatisch ein indirekter Zugriff erfolgt. Bei der Initialisierung wird intern der Adreßoperator “&” verwendet, bei der Zuweisung die indirekte Adressierung “*”.

Die Adreßermittlung nennt man auch “Referenzieren”, den indirekten Zugriff “Dereferenzieren”. Damit läßt sich der Vorgang auch so beschreiben: beim Initialisieren referenziert der Compiler automatisch die Initialisierungsvariable, beim Zugriff dereferenziert er automatisch die Referenzvariable.

Aliasvariable werden sehr selten verwendet; der bei weitem häufigste Anwendungsfall sind Parameter.

Ablauf eines Unterprogrammaufrufes

Im folgenden wollen wir uns den Übergaben von Objekten zuwenden. Schauen wir uns dazu zuerst einmal an, was der Compiler bei einem einfachen Unterprogrammaufruf in einer Hochsprache machen muß.

Die Grund, warum es genau dieser Ablauf sein muß, ist die Fähigkeit von C und C++, Code für Multitasking-Systeme zu erzeugen. (Bild 6-10)

Im ersten Schritt werden die formalen Parameter dynamisch angelegt und initialisiert. Die Parameter liegen auf dem Stack. Im Assembler für die 80x86-Prozessoren ist dieser Schritt ganz einfach. Der Maschinenbefehl "push" kann gleichzeitig Speicher auf dem Stack reservieren und mit einem Wert initialisieren. Bei größeren Variablen wird der Stackpointer (Stapelzeiger) SP explizit verringert und der damit reservierte Bereich mit dem aktuellen Parameter initialisiert.

Nachdem alle formalen Parameter am Stack angelegt und mit den zugehörigen aktuellen Parametern initialisiert wurden, geschieht im zweiten Schritt der Aufruf des Unterprogrammcodes (call).

Ein Unterprogramm wird zu Beginn die notwendigen Verwaltungsarbeiten erledigen. Dazu gehören das Retten von CPU-Registern und das Anlegen der lokalen Variablen. Die lokalen Variablen können auch initialisiert werden. Damit ist alles für die eigentlichen Anweisungen des Unterprogramms vorbereitet.

Nehmen wir an, daß das Unterprogramm eine Funktion ist. Dann kommen wir während des Ablaufes zur “return”-Anweisung. Sie wird den Wert oder das Ergebnis des nachfolgenden Ausdrucks zurückgeben. Dabei stehen wir aber vor dem Problem, wie und wo diese Rückgabe stattfinden soll. Eine Idee wäre, sie auf dem Stack zu lassen. Aber der Stack wird beim Verlassen des Unterprogramms aufgeräumt: alle Parameter und die lokalen Variablen werden entfernt. Ein Rückgabewert wird aber erst später, nach dem Verlassen, im aufrufenden Programm benötigt, z. B. in einer Zuweisung.

Der Rückgabewert muß deshalb zwischengespeichert werden. Dazu brauchen wir einen Platz, der das Ende des Unterprogramms überlebt. Die meisten Compiler benutzen die Prozessorregister als Übergabebereich. Bei Rückgaben von einfachen Variablen wird das gut gehen. Für große Objekte werden uns aber die Register nicht genügend Speicherplatz zur Verfügung stellen können. Hier muß der Compiler ein “anonymes Übergabeobjekt” dynamisch anlegen.

Und schließlich wird dann im siebten und letzten Schritt der Übergabebereich an die Ergebnisvariable zugewiesen.

Diese Aufzählung der einzelnen Schritte führt uns zu einem Initialisierungsproblem: was passiert, wenn wir ein Objekt über eine Schnittstelle übergeben? Hier muß ein formaler Objektparameter angelegt und mit einem aktuellen Objekt initialisiert werden. Das neue Objekt soll so sein, wie das bereits existierende.

Der Compiler hat dafür eine Standardmethode: er benutzt die Zuweisung und kopiert Eigenschaft für Eigenschaft vom vorhandenen Objekt in das neu angelegte. Solange wir, wie bei “ratio”, nur Werteigenschaften haben, funktioniert das. Wenn wir, wie bei “Zeile”, auch Zeiger als Eigenschaften verwenden, dürfen wir nicht mehr eins zu eins kopieren. Dann gäbe es zwei Objekte, die die gleiche Adresse benutzen. Im Destruktor würde dann zweimal versucht, den gleichen Speicherbereich freizugeben.

Der Kopier-Konstruktor

Das Problem können wir mit Hilfe eines speziellen Konstruktors lösen: dem Kopierkonstruktor. Er erwartet als Parameter ein Objekt der Klasse.

Der Kopierkonstruktor wird auch beim Übergeben von Objekten über die Funktionsschnittstelle aufgerufen, falls er vorhanden ist. Dabei stoßen wir auf eine Schwierigkeit. Wenn ein Objekt an eine Funktion übergeben wird, rufen wir eine andere Funktion, den Kopierkonstruktor auf. Dieser Funktion übergeben wir ein Objekt. Bei der Übergabe eines Objektes rufen wir den Kopierkonstruktor. Dem Kopierkonstruktor übergeben wir ein Objekt.... Wir brechen hier besser ab, denn das ist ein Teufelskreis geworden.

Ein Kopierkonstruktor darf also seinen Parameter, ein bereits existierendes Objekt niemals per Wertübergabe erhalten, sonst würden wir in den beschriebenen Teufelskreis geraten. Hier muß die Referenzübergabe verwendet werden. Sicherheitshalber erklären wir auch das Objekt, auf das sich die Referenz bezieht, als konstant.

Wichtig: Der Kopierkonstruktor erhält als Parameter eine Referenz auf ein konstantes Objekt ! (hier: const ratio &)

Damit können wir nun den Kopierkonstruktor für die bisherigen Beispiele “ratio” und “Zeile” schreiben. Schauen wir uns zuerst die einfachere Klasse “ratio” an.

In der Klassendefinition haben wir nun die Methode “Kopierkonstruktor” aufgenommen. Damit können wir auch in der Methode “addiere()” den Parameter als ganzes Objekt übergeben. Bisher hatten wir an dieser Stelle die Adresse übergeben.

Die Namen der Eigenschaften ( hier: z und n) sollten im Normalfall ihre Bedeutung erkennen lassen. Sie sind hier nur wegen der schmalen Buchseite so kurz.

Für die Klasse “ratio” muß der Kopierkonstruktor nicht unbedingt geschrieben werden. Seine Implementierung entspricht genau der Standardmethode des Compilers, nämlich Eigenschaft für Eigenschaft zu kopieren.

Um die Benutzung sichtbar zu machen, finden Sie im Kopierkonstruktor eine “printf()”-Anweisung.

Rahmen25Zum Testen benötigen wir noch ein kleines Hauptprogramm.

Bevor wir das Beispiel im Bild 6-14 diskutieren können, brauchen wir noch das Ergebnis des Programms am Bildschirm. Die Programmausgaben wurden mit Hilfe der Ein-/Ausgabe-Umleitung in eine Datei geschrieben und dann mit Zeilennummern versehen.

Rahmen27Der Kopierkonstruktor wird zuerst aufgerufen. Dies geschieht in der Zeile 7 des Hauptprogramms. Dort wird eine globale Variable angelegt. Ihre Initialisierung erfolgt, bevor "main()" zu arbeiten beginnt. Innerhalb von “main()” wird kein lokales Objekt angelegt. Die Aufrufe des Kopierkonstruktors stammen aus der Zeile 15. Dort rufen wir die “addiere” -Methode auf. Bei der Wertübergabe eines Objektes muß der formale Parameter (“robjekt” in der Zeile 9 der Implementierung Bild 6-13) mit Hilfe des aktuellen Parameters (hier “C”)" initialisiert werden. Dies ist ein Fall für den Kopier-Konstruktor.

 Der dritte Aufruf des Kopierkonstruktors (Zeile 8 im Bild 6-15) erfolgt bei der Initialisierung des anonymen Zwischenobjektes bei der Rückgabe. “addiere” liefert ein Objekt per Wertübergabe zurück. Dazu wird ein anonymes Zwischenobjekt angelegt und mit Hilfe der lokalen Variablen “erg” initialisiert. Und das ist wieder ein Fall für den Kopier-Konstruktor.

Wertübergaben von Objekten führen zum Aufruf eines Konstruktors. Nach Möglichkeit wird man daher vermeiden, die oft großen Objekte auf diese Art zu übergeben. Schließlich kostet ein Methodenaufruf Laufzeit. Die Übergabe per Referenz würde diesen Aufwand an Laufzeit vermeiden. In unserem Fall könnte bei der Methode “addiere()” der Parameter per Referenz übergeben werden. Das Ergebnis darf auf keinen Fall per Referenz zurückgegeben werden, da das Ergebnis in einer lokalen Variablen steht. Das Ergebnis wird erst nach dem Verlassen der Methode weiterverarbeitet. Und da gibt es die lokale Variable schon nicht mehr. Die Referenz würde sich auf eine nicht mehr vorhandene Variable beziehen.

Bei manchen Compilern würde das Ergebnis sogar noch am Stack liegen, da die Stackkorrektur beim Verlassen des Unterprogramms nicht den alten Inhalt löscht. Trotzdem kann man nicht davon ausgehen, daß das immer der Fall ist. Ein Interrupt-Programm verwendet schließlich auch den Stack. Und Interrupts kommen zu beliebigen Zeitpunkten.

Bei “ratio” könnte der Kopierkonstruktor entfallen. Bei “Zeile” brauchen wir ihn wegen der verwendeten Zeiger unbedingt. Schauen wir uns daher noch unser zweites Beispiel an und schreiben einen Kopier-Konstruktor für “Zeile”.

In der Zeile 10 sehen Sie den Kopier-Konstruktor. Eine häufig benutzte Kurzbezeichnung für ihn in der Klasse “X” ist : X::X (const X &).

Im bewusst sehr einfachen Hauptprogramm im Bild 6-17 werden zwei Objekte angelegt (z1 und z2). Mit "clrscr()" wird der Bildschirm gelöscht. Diese Routine heißt nicht bei allen Betriebssystemen gleich. An die beiden Objekte wird dann die Botschaft “print()” gesandt.

Die Implementierung des Kopierkonstruktors entspricht nun nicht mehr der Standardannahme des Compilers. Eine eins zu eins Kopie der Eigenschaften des vorgegebenen Objektes in die Eigenschaften des gerade initialisierten Objektes ist nicht möglich.

Rahmen35Jedes Objekt braucht seinen eigenen, dynamisch angelegten, Speicherbereich. Schließlich wollen wir eine Variable auch verändern können, ohne den Inhalt einer anderen zu verändern. Deshalb dürfen die Inhaltszeiger nicht kopiert werden. Nur der Inhalt selbst wird von dem vorgegebenen dynamischen Speicherbereich in den neu angelegten kopiert.

Rahmen33Damit haben wir den letzten Konstruktor kennen gelernt, den wir bei Objekten mit Zeigern auf dynamisch angelegte Speicherbereiche unbedingt brauchen. Wir kennen nun den Standardkonstruktor, der keinen Parameter hat, den Konstruktor mit Werten und den Kopier-Konstruktor.

Hinweise zur Weiterarbeit

1) Was sind die Vorteile einer Referenz gegenüber einem Zeiger?

2) Wann werden die anonymen Zwischenobjekte vom Compiler entfernt? Mit Hilfe einer Textausgabe und Experimentieren mit Blöcken ({}) findet man es heraus.

3) Wie viele Methodenaufrufe spart die Referenzübergabe ein bei:

- der Parameterübergabe

- der Ergebnisrückgabe?

Probieren Sie es einfach aus.

Im nächsten Kapitel

Für die Klasse “ratio” gibt es eine “addiere()”-Methode, die zwei Objekte addiert und ein Ergebnisobjekt liefert. Dieses Ergebnis wird dann einem anderen Objekt zugewiesen. Etwas ähnliches gibt es auch für Zeilen oder allgemeine Texte. Hier nennt man das  Addieren “Zusammenhängen” oder “Konkatenieren”.

Einmal angenommen, wir wollten eine Methode “konkatinieren()” schreiben, die ganz ähnlich der Methode “addiere()” arbeiten soll. Das Objekt, an das die Methode beim Aufruf gebunden wurde, und das Objekt, das als Parameter übergeben wurde, sollen ihre Texte liefern. Wir hängen sie zusammen und speichern den neuen Text in einem lokalen Objekt der Klasse “Zeile”. Dieses Objekt wollen wir zurückliefern und einem anderen Objekt der Klasse “Zeile” zuweisen.

Das obige Beispiel könnten wir bis jetzt schon schreiben - bis auf eine Stelle. Das Ergebnis der Konkatenierung (des Zusammenhängens) der Texte wird zugewiesen. Da aber in unserem Zeilenobjekt eine Eigenschaft ein Zeiger auf einen dynamisch angelegten Speicherbereich ist, darf diese Adresse nicht eins zu eins kopiert werden. Hier tritt das gleiche Problem wie beim Kopier-Konstruktor nun bei der Zuweisung auf.

Um das Problem lösen zu können, müssen wir dem “=”-Zeichen für die Klasse “Zeile” eine neue Bedeutung geben.