Einführung in C++ Kapitel 4 — Funktionen

In diesem Kapitel wollen wir uns den Verbesserungen widmen, die C++ bei den Funktionen gebracht hat. Diese Änderungen machen das Programmieren ein wenig einfacher und erlauben es dem Compiler, mehr Fehler zu finden. Ein großer Teil dieses Kapitels wird sich den modernen Funktionsprototypen widmen.

Prototypisierung erlaubt es dem Compiler, zusätzliche Typenkontrollen durchzuführen, was so manchen Programmierfehler aufdeckt. Die ersten beiden Beispiele dieses Kapitels sollen Dir die Verwendung von Prototypen begreiflich machen und ihren Nutzen erklären. Die Prototypisierung ist ein relativ neues Konzept in C, sodaß auch so manche erfahrene C Programmiererin sich darin noch nicht zuhause fühlt. Wenn Du allerdings schon Erfahrung mit Prototypen gesammelt hast, kannst Du gleich zum Abschnitt Übergabe mittels Referenz weitergehen.

Prototypen

Beispielprogramm: PROTYP1.CPP

Das Beispielprogramm PROTYP1.CPP stellt uns Prototypen einmal vor und illustriert ihre Verwendung. Es besteht kein Unterschied zwischen der Prototypisierung, die C++ verwendet und jener von ANSI-C. Allerdings sind viele C Programmiererinnen etwas mißtrauisch, wenn es um Prototypen geht und anscheinend nicht wirklich willens, sie auch zu verwenden. In C++ ist die Prototypisierung wesentlich wichtiger und wird auch viel öfter verwendet. In manchen Fällen führt in C++ kein Weg an den Prototypen vorbei.

Ein Prototyp ist ein vereinfachtes Modell eines komplexen Objektes. In unserem Beispiel ist eine komplette Funktion das Objekt und den Prototyp dazu finden wir in Zeile 4. Der Prototyp gibt ein Modell der Schnittstelle der Funktion, sodaß Funktionsaufrufe auf die Richtigkeit der Anzahl und der Art der Argumente überprüft werden können. Jeder Aufruf der Funktion MachWas() muß genau drei Parameter haben, oder der Compiler wird einen Fehler melden. Neben der Anzahl müssen auch die Typen der Parameter übereinstimmen, oder wir bekommen eine Fehlermeldung. Beachte, daß der Compiler in den Zeilen 12 und 13 schon eine Typenüberprüfung, die auf dem Prototyp in Zeile 4 basiert durchführen kann, obwohl die Funktion selbst noch nicht definiert ist. Wenn kein Prototyp verfügbar wäre, könnte weder die Anzahl noch die Art der Parameter überprüft werden. Solltest Du da einen Fehler machen und keinen Prototypen angegeben haben, wird sich das Programm zwar wunderbar kompilieren und linken lassen, bei der Ausführung können dann aber eigenartige Dinge passieren.

Um einen Prototypen zu schreiben, mußt Du nur den Kopf der Funktion an den Beginn des Programmes kopieren und am Ende einen Strichpunkt anhängen als Indikator, daß es sich um einen Prototypen und nicht um die Funktion selbst handelt. Die Variablennamen, die im Prototypen angegeben werden, sind nicht notwendig und dienen eigentlich nur als Kommentare, da sie vom Compiler komplett ignoriert werden. Du könntest den Variablennamen Fluegel in Zeile 4 mit Deinem Vornamen ersetzen und es würde in der Kompilation keinen Unterschied machen. Die Gedanken dessen, der Dein Programm dann liest, werden sich dann womöglich auch mehr um Dich denn um das Programm drehen (was ja beileibe nichts Schlechtes ist).

Einführung in C++ bringt Dich in Partnerschaft mit Amazon.de von Null auf Programmieren in ein paar Klicks.

Zum Beispiel Prototypen:

Schrödinger programmiert C++: Jetzt mit C++14 und Syntaxhighlighting
Das beste Programmierlernbuch — egal in welcher Sprache? Kann gut sein. Statt trocken ist Dieter Bärs Meisterstück lehrreich, statt mühsam beispielhaft beispielbehaftet, statt Nachschlagewerk (das ist es wirklich nicht) Nur-noch-ein-Bissi-Weitermachbuch und statt unverständlich sinnvoll das Verstehen (statt dem Memorisiern) fördernd erklärend.
›› Mehr C++-Bücher

In diesem Fall sind die beiden Funktionsaufrufe in den Zeilen 12 und 13 korrekt, sodaß die Kompilation ohne Fehler über die Bühne gehen sollte.

Obwohl wir in unserem Programm den Typ char für die Variable Augen verwenden wollen, möchten wir ihn doch als Zahl und nicht als Zeichen gebrauchen. Die Typenumwandlung zum Typ int in Zeile 22 brauchen wir, um die richtige Ausgabe (die einer Zahl anstatt eines ASCII Zeichens) zu erhalten. Das nächste Beispielprogramm ist ähnlich, aber ohne diese Umwandlung zu int.

Kompatible Datentypen in C++

Wir haben die Kompatibilität von Typen schon erwähnt, wollen aber hier noch einmal kurz darauf eingehen, um die Diskussion der Prototypen zu komplettieren. Kompatibel sind alle einfachen Typen, die untereinander sinnvoll umgewandelt werden können. Wenn Du zum Beispiel eine ganze Zahl als eigentlichen Parameter verwendest, die Funktion allerdings eine Variable vom Typ float als formellen Parameter verlangt, führt das System die Umwandlung automatisch durch, ohne daß Du etwas davon bemerkst. Dasselbe gilt auch für float nach char und char zu int. Es gibt strikte Regeln für die Typenumwandlung, die Du zum Beispiel in Kapitel 3.2 des ANSI-C Standards findest.

Wenn wir der Funktion als eigentlichen Parameter einen Zeiger auf eine Variable vom Typ int übergeben, die Funktion aber als formellen Parameter eine Variable vom Typ int erwartet, erfolgt keine automatische Umwandlung, da es sich um zwei komplett verschiedene Arten von Werten handelt. So würde auch eine Struktur nicht automatisch in einen long float, einen array oder auch nur in irgendeine andere Struktur umgewandelt werden, da alle diese inkompatibel sind und nicht sinnvoll umgewandelt werden können. Alles in Kapitel 2 über Typenkompatibilität gesagte gilt auch für die Kompatibilität beim Funktionsaufruf. Genauso muß der Typ des Rückgabewertes, in diesem Fall void, mit dem erwarteten Typ im Funktionsaufruf kompatibel sein. Andernfalls gibt der Compiler eine Warnung aus.

Wie funktioniert Prototypisierung in C++?

Hier hast Du die Gelegenheit, die Prototypisierung selbst auszuprobieren und festzustellen, welche Fehlermeldungen Du erhältst, wenn Du einen Fehler machst. Ändere die Parameter in Zeile 12 so ab, daß dort (12.2, 13, 12345) steht und sieh Dir an, was der Compiler dazu sagt. Wahrscheinlich wird er gar nichts sagen, weil alle Typen kompatibel sind. Änderst Du die Parameter aber zu (12.0, 13) wirst Du eine Fehlermeldung oder zumindest eine Warnung erhalten, weil Du zu wenig Argumente angegeben hast. So sollte sich der Compiler auch melden, wenn Du einen der Parameter in Zeile 13 in eine Adresse verwandelst, indem Du ein & davor setzt. Schließlich änderst Du noch das erste Wort in Zeile 4 von void in int und schaust, welchen Fehler der Compiler ausgibt. Zunächst wirst Du den Funktionskopf in Zeile 18 so abändern müssen, daß er mit dem Prototypen übereinstimmt, dann wirst Du festestellen, daß die Funktion keinen Wert zurückgibt. Wenn Du diese Änderungen vorgenommen hast, solltest Du gesehen haben, daß Prototypen wirklich etwas Sinnvolles für Dich tun können.

Kompiliere dieses Programm und führe es aus, dann ändere es wie oben besprochen und versuche nach jeder Änderung, es zu kompilieren.

Ein bisschen mehr über Prototypen

Beispielprogramm: PROTYP2.CPP

Das nächste Programm, PROTYP2.CPP hält einige weitere Informationen über Prototypen für Dich bereit. Es ist identisch mit dem letzten, von einigen kleineren Änderungen abgesehen. Wir haben die Variablennamen im Prototypen in Zeile 4 weggelassen, nur um zu zeigen, daß sie der C++ Compiler wirklich als Kommentare interpretiert. Der Funktionskopf wurde anders formatiert, um jeden Parameter kommentieren zu können. Dies soll beim Lesen des Programmes eine Hilfe bieten. Du solltest aber bedenken, daß Kommentare die sorgfältige Auswahl der Variablennamen nicht ersetzen sollen und können.

Hat die Protoypisierung Nachteile?

In Hinblick auf die Größe des Programmes oder die Geschwindigkeit bringt Prototypisierung keinerlei Nachteile mit sich. Die Prototypen werden beim Kompilieren zur Kontrolle herangezogen und verlängern damit die Dauer eines Kompilierungsvorganges unwesentlich. Wenn Du nur einen Fehler durch die Prototypisierung findest, den Du andernfalls mit einem Debugger suchen hättest müssen, hat es sich schon ausgezahlt.

Prototypisierung wirkt sich also lediglich auf die Größe der Quelldatei und auf die Dauer der Kompilation aus, beides ist aber vernachlässigbar.

Kompiliere das Programm und führe es aus. Du wirst feststellen, daß es dem letzten gleicht, die Änderungen im Prototypen und die Entfernung der Typenumwandlung in der letzten Zeile der Funktion ausgenommen.

Übergabe per Referenz

Beispielprogramm: UEBREF.CPP

Das Programm UEBREF.CPP ist ein Beispiel für die Übergabe per Referenz, ein Konzept, das in ANSI-C nicht verfügbar ist. Wir haben die Referenzvariable in Kapitel 1 schon erwähnt und gleichzeitig festgehalten, daß Du es vermeiden solltest, sie so einzusetzen, wie wir es dort getan haben. Dieses Programm zeigt eine Situation, wo wir sie sehr zu unserem Vorteil verwenden. Die Übergabe per Referenz erlaubt es uns, einer Funktion eine Variable zu übergeben, wobei alle Änderungen an der Variable innerhalb der Funktion an das Hauptprogramm Übergeben werden. In ANSI-C wird derselbe Effekt durch die Übergabe eines Zeigers auf die Variable erreicht, aber die Verwendung einer Referenz ist ein wenig sauberer.

Beachte, daß die zweite Variable im Prototypen in Zeile 5 ein & vor dem Variablennamen hat. Dies weist den Compiler an, diese Variable wie einen Zeiger auf die eigentliche Variable zu behandeln. So wird praktisch die eigentliche Variable vom Hauptprogramm in der Funktion verwendet. In der Funktion selbst wird die Variable Ein2 in den Zeilen 24 bis 27 genauso verwendet wie jede andere auch, aber sie verhält sich, als würden wir die eigentliche vom Hauptprogramm übergebene Variable verwenden und nicht eine Kopie davon. Die andere Variable, Ein1, wird wie eine ganz normale ANSI-C Variable verwendet. Der Variablenname Ein2 ist also ein Synonym für die Variable Index im Hauptprogramm, der Name Ein1 hingegen bezieht sich auf eine Kopie der Variable Zaehler im Hauptprogramm. Im Gebrauch wird ein Zeiger an die Funktion übergeben und automatisch dereferenziert, wenn er in der Funktion verwendet wird. Das ist Dir, der Programmiererin, natürlich klar.

Wenn Du es vorziehst, die Variablennamen im Prototypen wegzulassen, sähe Dein Prototyp folgendermaßen aus: void Pfusche(int, int &);

Als Pascal Programmiererin wirst Du bemerkt haben, daß die Variable Ein1 wie ein normaler Parameter in einem Pascal-Funktionsaufruf behandelt wird, ein Aufruf per Wert. Die Variable Ein2 allerdings wird behandelt wie eine Variable mit dem reservierten Wort VAR davor, was üblicherweise Aufruf per Referenz genannt wird. Wie wir schon festgestellt haben, ist eine Referenzvariable in C++ eigentlich ein sich selbst dereferenzierender Zeiger, der sich auf den eigentlichen Wert bezieht, beziehungsweise darauf zeigt.

Wenn Du dieses Programm kompilierst und dann ausführst, wirst Du bemerken, daß die erste Variable in der Funktion zwar geändert wurde, aber wieder ihren alten Wert erhält, wenn wir zum Hauptprogramm zurückkehren. Auch die zweite Variable wurde in der Funktion geändert, diese Änderung spiegelt sich aber auch im Hauptprogramm wieder, was wir erkennen, wenn die Werte der Variablen am Bildschirm ausgegeben werden. Es sollte jetzt klar sein, daß eine Referenz es Dir erlaubt, einen Parameter per Referenz an eine Funktion zu übergeben. Wenn Du erst einmal ein wenig Erfahrung mit Referenzen gesammelt hast, wirst Du sie einsetzen, um die Effizienz einiger Deiner Programme zu steigern. Die Übergabe einer großen Struktur kann mit einer Referenz sehr effizient gestaltet werden.

Standardparameter

Beispielprogramm: STANDARD.CPP

Das Programm STANDARD.CPP ist ein Beispiel für die Verwendung von Standardparametern in C++. Dieses Programm erweckt sicherlich einen etwas eigenartigen Eindruck, weil es für einige Parameter im Prototypen Standardwerte festlegt. Diese Standardwerte können aber sehr nützlich sein, wie wir gleich sehen werden.

Der Prototyp sagt uns, daß der erste Parameter, Laenge, bei jedem Funktionsaufruf angegeben werden muß, da für ihn kein Standardparameter festgelegt wurde. Den zweiten Parameter, Weite, müssen wir nicht bei jedem einzelnen Aufruf angeben, und wenn wir ihn nicht explizit angeben, verwendet das Programm den Wert 2 für die Variable Weite innerhalb der Funktion. So ist auch der dritte Parameter optional, und wird er nicht angegeben, wird in der Funktion der Wert 3 für die Variable Hoehe verwendet.

In Zeile 11 dieses Programmes geben wir alle drei Parameter explizit an, es ist also nichts Außergewöhnliches an diesem Funktionsaufruf zu bemerken. In Zeile 12 geben wir allerdings nur zwei Werte an und verwenden also den Standardparameter für die dritte Variable. Das System reagiert genau so, als hätten wir die Funktion mit Volumen(x, y, 3) aufgerufen, da der Standardwert für den dritten Parameter 3 ist. In Zeile 13 geben wir beim Funktionsaufruf nur mehr einen Wert an, der für den ersten formellen Parameter verwendet wird, die beiden anderen nehmen die Standardwerte an. Das System verhält sich, als hätten wir die Funktion mit Volumen(x, 2, 3) aufgerufen. Beachte, daß die Ausgabe dieser drei Zeilen umgekehrt erfolgt. Darauf werden wir in kürze eingehen.

Einführung in C++ bringt Dich in Partnerschaft mit Amazon.de von Null auf Programmieren in ein paar Klicks.

Zum Beispiel Standards:

The C++ Programming Language
Das Buch vom Erfinder. Bjarne Stroustrup beschreibt auf 1000 Seiten "seine" Sprache und hat damit neben einer großartigen Programmiersprache auch noch ein unerlässliches Nachschlage-, aber auch (mit Einschränkungen) Lernwerk geschaffen.
›› Mehr C++-Bücher

Es gibt einige Regeln, die zwar offensichtlich sind, aber dennoch hier aufgeführt werden sollen. Sobald ein Parameter in der Liste der formellen Parameter einen Standardwert erhält, müssen auch die folgenden Parameter Standardwerte haben. Es ist nicht möglich, in der Mitte der Liste ein Loch zu lassen, die Vergabe von Standardwerten erfolgt von hinten nach vorne. Selbstredend müssen die Standardwerte die richtigen Variablentypen haben, andernfalls gibt der Compiler eine Fehlermeldung aus. Die Standardwerte können entweder im Prototypen oder im Funktionskopf angegeben werden, nicht jedoch in beiden. Würden die Standardwerte an beiden Orten angegeben, müßte der Compiler nämlich nicht nur diese Standardwerte verwenden, er müßte auch genau überprüfen, ob die beiden Werte auch wirklich identisch sind. Dies würde ein schon sehr schwieriges Unterfangen, das der Entwicklung eines C++ Compilers, noch weiter komplizieren.

Ich empfehle wärmstens, die Standardparameter im Prototypen anzugeben und nicht im Funktionskopf. Der Grund dafür wird klar werden, sobald wir objektorientierte Programmiertechniken anwenden.

Warum ist die Ausgabe mit cout in C++ eventuell so wirr?

Wenn ein Compiler älterer Bauart auf eine cout Anweisung stößt, durchsucht er zuerst die komplette Zeile von rechts nach links auf etwaige Funktionen, dann werden die Daten nacheinander ausgegeben, von links nach rechts. Deshalb wird in Zeile 11 zuerst die Funktion Volumen() berechnet, und deren interne Ergebnisse werden ausgegeben. Dann werden die einzelnen Felder von cout von links nach rechts ausgegeben, "Einige Daten sind" also als nächstes. Schließlich wird der Rückgabewert von Volumen() im Format int, dem Typ des Rückgabewertes, ausgegeben. Das Resultat ist, daß die Ausgabe nicht in der erwarteten Reihenfolge erfolgt, wenn die Zeilen 11 bis 13 abgearbeitet werden. Neuere Compiler haben dieses Problem nicht. Die Ausgabe erfolgt in der intuitiv erwarteten Abfolge.

Zusätzlich haben wir weiland noch immer das Problem, das auftritt, wenn wir cout und printf() vermischen, wie in Kapitel 1 beim Programm NACHR.CPP besprochen. Schlußendlich werden aber alle standardkonformen Compiler dieses Problem überwinden.

Die Zeilen 15 bis 18 entsprechen den Zeilen 11 bis 13, nur sind die Anweisungen auf zwei Zeilen aufgeteilt, sodaß die Ausgabe in der erwarteten Reihenfolge erfolgt.

Kompiliere das Programm und führe es aus, wenn Du es verstanden hast. Die eigenartige Ausgabereihenfolge wird uns übrigens im Laufe dieser Einführung noch einmal begegnen.

Variable Anzahl an Parametern beim Funktionsaufruf

Beispielprogramm: VARPAR.CPP

Das Programm VARPAR.CPP gibt ein Beispiel für die Verwendung von einer veränderbaren Anzahl an Argumenten in einem Funktionsaufruf.

Wir haben einige Mühen auf uns genommen, um den Compiler dazu zu bringen, für uns zu kontrollieren, ob wir in Funktionsaufrufen die richtige Anzahl und die richtigen Typen von Parametern verwenden. Ab und an mag es aber vorkommen, daß wir eine Funktion schreiben wollen, die unterschiedliche Anzahlen von Parametern verwenden kann. Die printf() Funktion ist ein gutes Beispiel dafür. ANSI-C stellt uns in der Datei "stdarg.h" drei Makros zur Verfügung, mit denen sich das bewerkstelligen läßt. Diese können wir auch in C++ verwenden, müssen aber einen Weg finden, die strengere Typenkontrolle zu umgehen, die bei jeder Funktion in C++ durchgeführt wird. Dies bewirken die drei Punkte in Zeile 6. Dieser Prototyp sagt aus, daß als erstes ein Argument des Typs int notwendig ist, dann aber wird vom Compiler keine weiter Typenkontrolle durchgeführt.

Das Hauptprogramm besteht aus drei Aufrufen der Funktion, jeder mit einer anderen Anzahl von Parametern, und das System ignoriert dies einfach. Du könntest so viele verschiedene Variablentypen in den Funktionsaufruf einbauen wie Du willst. Solange der erste Parameter eine Variable vom Typ int ist, wird sich das System jede erdenkliche Mühe geben, Dein Programm zu kompilieren und es auszuführen. Natürlich erfolgt auch keinerlei Kontrolle nach dem ersten Argument, es obliegt also allein Dir, die richtigen Parametertypen im Funktionsaufruf zu verwenden.

In diesem Fall zeigt der erste Parameter die Anzahl der zusätzlichen Argumente an. In diesem einfachen Beispiel geben wir nur die Zahlen auf dem Bildschirm aus, um zu demonstrieren, daß sie wirklich richtig abgearbeitet wurden.

Du hast sicherlich festgestellt, daß die Verwendung von einer variablen Anzahl an Parametern zu sehr obskurem Quellcode führen kann und deshalb nur sehr selten angewendet werden sollte. Die Möglichkeit besteht jedenfalls, solltest Du etwas derartiges jemals benötigen. Kompiliere das Programm und lass' es laufen.

Überladen von Funktionsnamen

Beispielprogramm: UEBERLAD.CPP

Das Programm UEBERLAD.CPP ist ein Beispiel für das Überladen von Funktionsnamen. Diese Technik ist in ANSI-C nicht verfügbar, sehr wohl aber in C++ und wird auch regelmäßig angewendet. Auf den ersten Blick wird sie etwas eigenartig anmuten, ist aber einer der Grundbausteine objektorientierten Programmierens. Die Nützlichkeit und den Sinn dieses Konstrukts werden wir im Laufe dieser Einführung noch sehr zu schätzen lernen.

Dieses Programm hat außer der Funktion main() noch drei zusätzliche Funktionen, und alle drei tragen denselben Namen. Deine erste Frage wird nun sein: "Welche Funktion rufe ich mit MachWas() eigentlich auf?" Die Antwort auf diese Frage ist: Du rufst die Funktion mit der richtigen Anzahl an formellen Variablen des richtigen Typs auf. Rufst Du MachWas() mit einer ganzen Zahl oder einer Variable vom Typ int als eigentlichem Parameter auf, wird die Funktion, die in Zeile 25 beginnt, ausgeführt. Wenn der eigentliche Parameter vom Typ float ist, wird die Funktion in Zeile 30 aufgerufen, hat der Funktionsaufruf zwei float Werte oder Variablen als Argumente, wird die Funktion in Zeile 36 ausgeführt.

Der Rückgabewert wird zur Feststellung der passenden Funktion nicht herangezogen. Allein die Typen der formellen Parameter werden verwendet, um festzustellen, welche der überladenen Funktionen aufgerufen wird.

Das Schlüsselwort overload in Zeile 4 sagt dem System, daß es wirklich Deine ernste Absicht ist, den Namen MachWas zu überladen und dies nicht aus Versehen geschieht. Dies wird aber nur von sehr frühen Versionen von C++ verlangt. Neuere Versionen verlangen dieses Schlüsselwort nicht mehr, es ist aber aus Kompatibilitätsgründen nach wie vor (noch) erlaubt. Es ist nicht notwendig, overload zu verwenden, da das Überladen in C++ generell in einem Zusammenhang geschieht, wo es offensichtlich ist, daß der Funktionsname überladen wird.

In einem endgültigen C++ Standard mag die Verwendung dieses Schlüsselwortes verboten sein. Wie gesagt, C++ ändert sich und wir müssen bereit sein, uns mit der Sprache zu ändern. Tempora mutantur nos et mutamur in illis.

Die eigentliche Auswahl, welche Funktion aufgerufen wird, wird beim Kompilieren getroffen und nicht bei der Ausführung des Programmes, sodaß es zu keinen Geschwindigkeitseinbußen kommt. Würden wir jeder der Funktionen mit dem überladenem Namen einen einzigartigen Namen verleihen, wäre kein Unterschied in der Größe des Programmes oder in seiner Geschwindigkeit festzustellen.

Einführung in C++ bringt Dich in Partnerschaft mit Amazon.de von Null auf Programmieren in ein paar Klicks.

Zum Beispiel Überladen und mehr:

Objektorientierte Programmierung: Das umfassende Handbuch. Lernen Sie die Prinzipien guter Objektorientierung.
Ungefähr alles nicht nur, das man wissen muss, sondern auch, das man wissen kann, in einem Buch. Dabei ist "Objektorientierte Programmierung" nicht unpraktisch und langweilig, nein: voll mit Beispielen und vor allem verständlichen Erklärungen, macht es einen interessiert — und mit brauchbarer objektorientierung zur besseren Programmiererin.
›› Mehr Softwareentwicklung-Bücher

Das Überladen von Funktionsnamen mag Dir eigentümlich vorkommen und das ist es auch, wenn man an die Regeln von K&R oder ANSI-C gewöhnt ist. Hast Du aber einmal etwas Erfahrung mit C++ gesammelt, wirst Du das Überladen ganz selbstverständlich und oft in Deinen Programmen verwenden.

Beachte die Verwendung des Schlüsselwortes const in einigen Funktionsprototypen und -köpfen. Dies bewahrt die Programmiererin, wie gesagt, davor, den formellen Parameter innerhalb der Funktion zu ändern. In einer Funktion, die so kurz ist wie die Funktionen dieses Programmes, besteht keine wirkliche Gefahr einer irrtümlichen Zuweisung. In einer wirklichen Funktion kannst Du aber ganz schnell auf den ursprünglichen Zweck einer Variable vergessen, wenn Du die Funktion später einmal modifizierst.

Programmieraufgaben

  1. Ändere den Typ der Variable Fluegel im Prototypen von PROTYP1.CPP zu float, sodaß eine Diskrepanz mit der Funktionsdefinition besteht. Gibt der Compiler eine Fehlermeldung aus?
  2. Ändere die Funktionsdefinition in PROTYP1.CPP, sodaß sie mit dem geänderten Prototypen wieder übereinstimmt. Kompiliere das Programm und führe es aus, ohne die Funktionsaufrufe in den Zeilen 12 und 13 zu ändern. Erkläre das Ergebnis.
  3. Lösche in STANDARD.CPP den Standardwert für Hoehe, nur um zu sehen, welchen Fehler der Compiler meldet. Nur die letzten Werte der Liste können Standardwerte annehmen.
  4. Ändere die Funktionsnamen in UEBERLAD.CPP so ab, daß jeder Name einzigartig ist und vergleiche die Größe des Programmes mit jener des ursprünglichen Programmes.

(weiter »)

Einführung in C++ bringt Dich in Partnerschaft mit Amazon.de von Null auf Programmieren in ein paar Klicks.

Zum Beispiel Funktionen:

C: Programmieren von Anfang an
Diese Einführung in C++ setzt ein Grund legendes Verständnis der Programmiersprache C voraus. Doch keine Angst: Helmut Erlenkötters geniales "C Programmieren von Anfang an" vermittelt dieses Verständnis in Nu und Schwupp-di-wupp.
›› Mehr C-Bücher

[ Satzes ]