C-Programmierung: Funktionen

Aus Wikibooks
Wechseln zu: Navigation, Suche

Eine wichtige Forderung der strukturierten Programmierung ist die Vermeidung von Sprüngen innerhalb des Programms. Wie wir gesehen haben, ist dies in allen Fällen mit Kontrollstrukturen möglich.

Die zweite Forderung der strukturierten Programmierung ist die Modularisierung. Dabei wird ein Programm in mehrere Programmabschnitte, die Module zerlegt. In C werden solche Module auch als Funktionen bezeichnet. Andere Programmiersprachen bezeichnen Module als Unterprogramme oder unterscheiden zwischen Funktionen (Module mit Rückgabewert) und Prozeduren (Module ohne Rückgabewert). Trotz dieser unterschiedlichen Bezeichnungen ist aber dasselbe gemeint.

Objektorientierte Programmiersprachen gehen noch einen Schritt weiter und verwenden Klassen zur Modularisierung. Vereinfacht gesagt bestehen Klassen aus Methoden (vergleichbar mit Funktionen) und Attributen (Variablen). C selbst unterstützt keine Objektorientierte Programmierung, im Gegensatz zu C++, das auf C aufbaut.

Die Modularisierung hat eine Reihe von Vorteilen:

Bessere Lesbarkeit

Der Quellcode eines Programms kann schnell mehrere tausend Zeilen umfassen. Beim Linux Kernel sind es sogar über 15 Millionen Zeilen und Windows, das ebenfalls zum Großteil in C geschrieben wurde, umfasst schätzungsweise auch mehrere Millionen Zeilen. Um dennoch die Lesbarkeit des Programms zu gewährleisten, ist die Modularisierung unerlässlich.

Wiederverwendbarkeit

In fast jedem Programm tauchen die gleichen Problemstellungen mehrmals auf. Oft gilt dies auch für unterschiedliche Applikationen. Da nur Parameter und Rückgabetyp für die Benutzung einer Funktion bekannt sein müssen, erleichtert dies die Wiederverwendbarkeit. Um die Implementierungsdetails muss sich der Entwickler dann nicht mehr kümmern.

Wartbarkeit

Fehler lassen sich durch die Modularisierung leichter finden und beheben. Darüber hinaus ist es leichter, weitere Funktionalitäten hinzuzufügen oder zu ändern.

Funktionsdefinition[Bearbeiten]

Im Kapitel Was sind Variablen haben wir die Quaderoberfläche berechnet. Nun wollen wir eine Funktion schreiben, die eine ähnliche Aufgabe für uns übernimmt: die Berechnung der Oberfläche eines Zylinders. Dazu schauen wir uns zunächst die Syntax einer Funktion an:

 Rückgabetyp  Funktionsname(Parameterliste)
 {
    Anweisungen
 }

Die Anweisungen werden auch als Funktionsrumpf bezeichnet, die erste Zeile als Funktionskopf.

Wenn wir eine Funktion zur Zylinderoberflächenberechnung schreiben und diese benutzen sieht unser Programm wie folgt aus:

  1. #include <stdio.h>
    
  2.  
    
  3. float zylinder_oberflaeche(float h, float r)
    
  4. {
    
  5.   float o;
    
  6.   o=2*3.141*r*(r+h);
    
  7.   return(o);
    
  8. }
    
  9.  
    
  10. int main(void)
    
  11. { 
    
  12.   float r,h;
    
  13.   printf("Programm zur Berechnung einer Zylinderoberfläche");
    
  14.   printf("\n\nHöhe des Zylinders: ");
    
  15.   scanf("%f",&h);
    
  16.   printf("\nRadius des Zylinders: ");
    
  17.   scanf("%f",&r);
    
  18.   printf("Oberfläche: %f \n",zylinder_oberflaeche(h,r));
    
  19.   return 0;
    
  20. }
    
  • In Zeile 3 beginnt die Funktionsdefinition. Das float ganz am Anfang der Funktion, der sogenannte Funktionstyp, sagt dem Compiler, dass ein Wert mit dem Typ float zurückgegeben wird. In Klammern werden die Übergabeparameter h und r deklariert, die der Funktion übergeben werden.
  • Mit return wird die Funktion beendet und ein Wert an die aufrufende Funktion zurückgegeben (hier: main ). In unserem Beispiel geben wir den Wert von o zurück, also das Ergebnis unserer Berechnung. Der Datentyp des Ausdrucks muss mit dem Typ des Rückgabewertes des Funktionskopfs übereinstimmen. Würden wir hier beispielsweise versuchen, den Wert einer int-Variable zurückzugeben, würden wir vom Compiler eine Fehlermeldung erhalten.
    Soll der aufrufenden Funktion kein Wert zurückgegeben werden, muss als Typ der Rückgabewert void angegeben werden. Eine Funktion, die lediglich einen Text ausgibt hat beispielsweise den Rückgabetyp void , da sie keinen Wert zurückgibt.
  • In Zeile 18 wird die Funktion zylinder_oberflaeche aufgerufen. Hier werden die beiden Parameter h und r übergeben. Der zurückgegebene Wert wird ausgegeben. Es wäre aber genauso denkbar, dass der Wert einer Variable zugewiesen, mit einem anderen Wert verglichen oder mit dem Rückgabewert weitergerechnet wird.
    Der Rückgabewert muss aber nicht ausgewertet werden. Es ist kein Fehler, wenn der Rückgabewert unberücksichtigt bleibt.

In unserem Beispiel haben wir den Rückgabetyp in return geklammert (Zeile 7). Die Klammerung ist aber optional und kann weggelassen werden (Zeile 19).

Auch die Funktion main hat einen Rückgabewert. Ist der Wert 0, so bedeutet dies, dass das Programm ordnungsgemäß beendet wurde, ist der Wert -1, so bedeutet dies, dass ein Fehler aufgetreten ist.

Jede Funktion muss einen Rückgabetyp besitzen. In der ursprünglichen Sprachdefinition von K&R wurde dies noch nicht gefordert. Wenn der Rückgabetyp fehlte, wurde defaultmäßig int angenommen. Dies ist aber inzwischen nicht mehr erlaubt. Jede Funktion muss einen Rückgabetyp explizit angeben.

Die folgenden Beispiele enthalten Funktionsdefinitionen, die einige typische Anfänger(denk)fehler zeigen:

 void foo()
 {
   /* Code */
   return 5; /* Fehler */
 }

Eine Funktion, die als void deklariert wurde, darf keinen Rückgabetyp erhalten. Der Compiler sollte hier eine Fehlermeldung oder zumindest eine Warnung ausgeben.

 int foo()
 {
   /* Code */
   return 5;
   printf("Diese Zeile wird nie ausgeführt");
 }

Bei diesem Beispiel wird der Compiler weder eine Warnung noch eine Fehlermeldung ausgeben. Allerdings wird die printf Funktion niemals ausgeführt, da return nicht nur einen Wert zurückgibt sondern die Funktion foo() auch beendet.

Das folgende Programm arbeitet hingegen völlig korrekt:

 int max(int a, int b)
 {
   if(a >= b){
     return a;
   }
   if(a < b){                                              
     return b;
   }
 }

Bei diesem Beispiel gibt der Compiler keine Fehlermeldung oder Warnung aus, da eine Funktion zwar nur einen Rückgabewert erhalten darf, aber mehrere return Anweisungen besitzen kann. In diesem Beispiel wird in Abhängigkeit der übergebenen Parameter entweder a oder b zurückgegeben.

Prototypen[Bearbeiten]

Auch bei Funktionen unterscheidet man wie bei Variablen zwischen Definition und Deklaration. Mit

 float zylinder_oberflaeche(float h, float r)
 {
   float o;
   o=2*3.141*r*(r+h);
   return(o);
 }

wird die Funktion zylinder_oberflaeche definiert.

Bei einer Funktionsdeklaration wird nur der Funktionskopf gefolgt von einem Semikolon angeben. Die Funktion zylinder_oberflaeche beispielsweise wird wie folgt deklariert:

 float zylinder_oberflaeche(float h, float r);

Dies ist identisch mit

 extern float zylinder_oberflaeche(float h, float r);

Die Meinungen, welche Variante benutzt werden soll, gehen hier auseinander: Einige Entwickler sind der Meinung, dass das Schlüsselwort extern die Lesbarkeit verbessert, andere wiederum nicht. Wir werden im Folgenden das Schlüsselwort extern in diesem Zusammenhang nicht verwenden.

Eine Trennung von Definition und Deklaration ist notwendig, wenn die Definition der Funktion erst nach der Benutzung erfolgen soll. Eine Deklaration einer Funktion wird auch als Prototyp oder Funktionskopf bezeichnet. Damit kann der Compiler überprüfen, ob die Funktion überhaupt existiert und Rückgabetyp und Typ der Argumente korrekt sind. Stimmen Prototyp und Funktionsdefinition nicht überein oder wird eine Funktion aufgerufen, die noch nicht definiert wurde oder keinen Prototyp besitzt, so ist dies ein Fehler.

Das folgende Programm ist eine weitere Abwandlung des Programms zur Berechnung der Zylinderoberfläche. Die Funktion zylinder_oberflaeche wurde dabei verwendet, bevor sie definiert wurde:

  1. #include <stdio.h>
    
  2.  
    
  3. float zylinder_oberflaeche(float h, float r);
    
  4.  
    
  5. int main(void)
    
  6. {
    
  7.   float r,h,o;
    
  8.   printf("Programm zur Berechnung einer Zylinderoberfläche");
    
  9.   printf("\n\nHöhe des Zylinders:");
    
  10.   scanf("%f",&h);
    
  11.   printf("\nRadius des Zylinders:");
    
  12.   scanf("%f",&r);
    
  13.   printf("Oberfläche: %f \n",zylinder_oberflaeche(h,r));
    
  14.   return 0;
    
  15. }
    
  16.  
    
  17. float zylinder_oberflaeche(float h, float r)
    
  18. {
    
  19.   float o;
    
  20.   o=2*3.141*r*(r+h);
    
  21.   return(o);
    
  22. }
    

Der Prototyp wird in Zeile 3 deklariert, damit die Funktion in Zeile 13 verwendet werden kann. An dieser Stelle kann der Compiler auch prüfen, ob der Typ und die Anzahl der übergebenen Parameter richtig ist (dies könnte er nicht, hätten wir keinen Funktionsprototyp deklariert). Ab Zeile 17 wird die Funktion zylinder_oberflaeche definiert.

Die Bezeichner der Parameter müssen im Prototyp und der Funktionsdefinition nicht übereinstimmen. Sie können sogar ganz weggelassen werden. So kann Zeile 3 auch ersetzt werden durch:

float zylinder_oberflaeche(float, float);

Wichtig: Bei Prototypen unterscheidet C zwischen einer leeren Parameterliste und einer Parameterliste mit void . Ist die Parameterliste leer, so bedeutet dies, dass die Funktion eine nicht definierte Anzahl an Parametern besitzt. Das Schlüsselwort void gibt an, dass der Funktion keine Werte übergeben werden dürfen. Beispiel:

  1. int foo1();
    
  2. int foo2(void);
    
  3.  
    
  4. int main(void)
    
  5. {
    
  6.   foo1(1, 2, 3); // kein Fehler
    
  7.   foo2(1, 2, 3); // Fehler
    
  8.   return 0;
    
  9. }
    

Während der Compiler beim Aufruf der Funktion foo1 in Zeile 6 keine Fehlermeldung ausgegeben wird, gibt der Compiler beim Aufruf der Funktion foo2 in Zeile 7 eine Fehlermeldung aus. (Der Compiler wird höchstwahrscheinlich noch zwei weitere Warnungen oder Fehler ausgeben, da wir zwar Prototypen für die Funktionen foo1 und foo2 haben, die Funktion aber nicht definiert haben.)

Diese Aussage gilt übrigens nur für Prototypen: Laut C Standard bedeutet eine leere Liste bei Funktionsdeklarationen die Teil einer Definition sind, dass die Funktion keine Parameter hat. Im Gegensatz dazu bedeutet eine leere Liste in einer Funktionsdeklaration, die nicht Teil einer Definition sind (also Prototypen), dass keine Informationen über die Anzahl oder Typen der Parameter vorliegt - so wie wir das eben am Beispiel der Funktion foo1 gesehen haben.

Noch ein Hinweis für Leser, die ihre C Programme mit einem C++ Compiler compilieren: Bei C++ würde auch im Fall von foo1 eine Fehlermeldung ausgegeben, da dort auch eine leere Parameterliste bedeutet, dass der Funktion keine Parameter übergeben werden können.

Übrigens haben auch Bibliotheksfunktionen wie printf oder scanf einen Prototyp. Dieser befindet sich üblicherweise in der Headerdatei stdio.h oder anderen Headerdateien. Damit kann der Compiler überprüfen, ob die Anweisungen die richtige Syntax haben. Der Prototyp der printf Anweisung hat beispielsweise die folgende Form (oder ähnlich) in der stdio.h :

 int printf(const char *, ...);

Findet der Compiler nun beispielsweise die folgende Zeile im Programm, gibt er einen Fehler aus:

 printf(45);

Der Compiler vergleicht den Typ des Parameters mit dem des Prototypen in der Headerdatei stdio.h und findet dort keine Übereinstimmung. Nun "weiß" er, dass der Anweisung ein falscher Parameter übergeben wurde und gibt eine Fehlermeldung aus.

Das Konzept der Prototypen wurde als erstes in C++ eingeführt und war in der ursprünglichen Sprachdefinition von Kernighan und Ritchie noch nicht vorhanden. Deshalb kam auch beispielsweise das "Hello World" Programm in der ersten Auflage von "The C Programming Language" ohne include Anweisung aus. Erst mit der Einführung des ANSI Standards wurden auch in C Prototypen eingeführt.

Inline-Funktionen[Bearbeiten]

Neu im C99-Standard sind Inline-Funktionen. Sie werden definiert, indem das Schlüsselwort inline vorangestellt wird. Beispiel:

  1. inline float zylinder_oberflaeche(float h, float r)
    
  2. {
    
  3.   float o;
    
  4.   o = 2 * 3.141 * r * (r + h);
    
  5.   return(o);
    
  6. }
    

Eine Funktion, die als inline definiert ist, soll gemäß dem C-Standard so schnell wie möglich aufgerufen werden. Die genaue Umsetzung ist der Implementierung überlassen. Beispielsweise kann der Funktionsaufruf dadurch beschleunigt werden, dass die Funktion nicht mehr als eigenständiger Code vorliegt, sondern an der Stelle des Funktionsaufrufs eingefügt wird. Dadurch entfällt eine Sprunganweisung in die Funktion und wieder zurück. Allerdings muss der Compiler das Schlüsselwort inline nicht beachten, wenn der Compiler keinen Optimierungsbedarf feststellt. Viele Compiler ignorieren deshalb dieses Schlüsselwort vollständig und setzen auf Heuristiken, wann eine Funktion inline sein sollte.

Globale und lokale Variablen[Bearbeiten]

Alle bisherigen Beispielprogramme verwendeten lokale Variablen. Sie wurden am Beginn einer Funktion deklariert und galten nur innerhalb dieser Funktion. Sobald die Funktion verlassen wird verliert sie ihre Gültigkeit. Eine Globale Variable dagegen wird außerhalb einer Funktion deklariert (in der Regel am Anfang des Programms) und behält bis zum Beenden des Programms ihre Gültigkeit und dementsprechend einen Wert.

  1. #include <stdio.h>
    
  2.  
    
  3. int GLOBAL_A = 43;
    
  4. int GLOBAL_B = 12;
    
  5.  
    
  6. void funktion1( );
    
  7. void funktion2( );
    
  8.  
    
  9. int main( void )
    
  10. {
    
  11.     printf( "Beispiele für lokale und globale Variablen: \n\n" );
    
  12.     funktion1( );
    
  13.     funktion2( );
    
  14.     return 0;
    
  15. }
    
  16.  
    
  17. void funktion1( )
    
  18. {
    
  19.     int lokal_a = 18;
    
  20.     int lokal_b = 65;
    
  21.     printf( "\nGlobale Variable A: %i", GLOBAL_A );
    
  22.     printf( "\nGlobale Variable B: %i", GLOBAL_B );
    
  23.     printf( "\nLokale Variable a: %i", lokal_a );
    
  24.     printf( "\nLokale Variable b: %i", lokal_b );
    
  25. }
    
  26.  
    
  27. void funktion2( )
    
  28. {
    
  29.     int lokal_a = 45;
    
  30.     int lokal_b = 32;
    
  31.     printf( "\n\nGlobale Variable A: %i", GLOBAL_A );
    
  32.     printf( "\nGlobale Variable B: %i", GLOBAL_B );
    
  33.     printf( "\nLokale Variable a: %i", lokal_a );
    
  34.     printf( "\nLokale Variable b: %i \n", lokal_b );
    
  35. }
    

Die Variablen GLOBAL_A und GLOBAL_B sind zu Beginn des Programms und außerhalb der Funktion deklariert worden und gelten deshalb im ganzen Programm. Sie können innerhalb jeder Funktion benutzt werden. Lokale Variablen wie lokal_a und lokal_b dagegen gelten nur innerhalb der Funktion, in der sie deklariert wurden. Sie verlieren außerhalb dieser Funktion ihre Gültigkeit. Der Compiler erzeugt deshalb beim Aufruf der Variable lokal_a einen Fehler, da die Variable in Funktion1 deklariert wurde.

Globale Variablen unterscheiden sich in einem weiteren Punkt von den lokalen Variablen: Sie werden automatisch mit dem Wert 0 initialisiert wenn ihnen kein Wert zugewiesen wird. Lokale Variablen dagegen erhalten immer den (zufälligen) Wert, der sich gerade an der vom Compiler reservierten Speicherstelle befindet (Speichermüll). Diesen Umstand macht das folgende Programm deutlich:

  1. #include <stdio.h>
    
  2.  
    
  3. int ZAHL_GLOBAL;
    
  4.  
    
  5. int main( void )
    
  6. {
    
  7.     int zahl_lokal;
    
  8.     printf( "Lokale Variable: %i", zahl_lokal );
    
  9.     printf( "\nGlobale Variable: %i \n", ZAHL_GLOBAL );
    
  10.     return 0;
    
  11. }
    

Das Ergebnis:

Lokale Variable: 296
Globale Variable: 0

Verdeckung[Bearbeiten]

Sind zwei Variablen mit demselben Namen als globale und lokale Variable definiert, wird immer die lokale Variable bevorzugt. Das nächste Beispiel zeigt eine solche "Doppeldeklaration":

  1. #include <stdio.h>
    
  2.  
    
  3. int zahl = 5;
    
  4. void func( );
    
  5.  
    
  6. int main( void )
    
  7. {
    
  8.     int zahl = 3;
    
  9.     printf( "Ist die Zahl %i als eine lokale oder globale Variable deklariert?", zahl );
    
  10.     func( );
    
  11.     return 0;
    
  12. }
    
  13.  
    
  14. void func( )
    
  15. {
    
  16.     printf( "\nGlobale Variable: %i \n", zahl );
    
  17. }
    

Neben der globalen Variable zahl wird in der Hauptfunktion main eine weitere Variable mit dem Namen zahl deklariert. Die globale Variable wird durch die lokale verdeckt. Da nun zwei Variablen mit demselben Namen existieren, gibt die printf Anweisung die lokale Variable mit dem Wert 3 aus. Die Funktion func soll lediglich verdeutlichen, dass die globale Variable zahl nicht von der lokalen Variablendeklaration gelöscht oder überschrieben wurde.

Man sollte niemals Variablen durch andere verdecken, da dies das intuitive Verständnis behindert und ein Zugriff auf die globale Variable im Wirkungsbereich der lokalen Variable nicht möglich ist. Gute Compiler können so eingestellt werden, dass sie eine Warnung ausgeben, wenn Variablen verdeckt werden.

Ein weiteres (gültiges) Beispiel für Verdeckung ist

  1. #include <stdio.h>
    
  2.  
    
  3.  
    
  4. int main( void )
    
  5. {
    
  6.     int i;
    
  7.     for( i = 0; i<10; ++i )
    
  8.     {
    
  9.         int i;
    
  10.         for( i = 0; i<10; ++i )
    
  11.         {
    
  12.             int i;
    
  13.             for( i = 0; i<10; ++i )
    
  14.             {
    
  15.                 printf( "i = %d \n", i );
    
  16.             }
    
  17.         }
    
  18.     }
    
  19.     return 0;
    
  20. }
    

Hier werden 3 verschiedene Variablen mit dem Namen i angelegt, aber nur das innerste i ist für das printf von Belang. Dieses Beispiel ist intuitiv schwer verständlich und sollte auch nur ein Negativbeispiel sein.

exit()[Bearbeiten]

Mit der Bibliotheksfunktion exit() kann ein Programm an einer beliebigen Stelle beendet werden. In Klammern muss ein Wert übergeben werden, der an die Umgebung - also in der Regel das Betriebssystem - zurückgegeben wird. Der Wert 0 wird dafür verwendet, um zu signalisieren, dass das Programm korrekt beendet wurde. Ist der Wert ungleich 0, so ist es implementierungsabhängig, welche Bedeutung der Rückgabewert hat. Beispiel:

  exit(2);

Beendet das Programm und gibt den Wert 2 an das Betriebssystem zurück. Alternativ dazu können auch die Makros EXIT_SUCCESS und EXIT_FAILURE verwendet werden, um eine erfolgreiche bzw. fehlerhafte Beendigung des Programms zurückzuliefern.

Anmerkung: Unter DOS kann dieser Rückgabewert beispielsweise mittels IF ERRORLEVEL in einer Batchdatei ausgewertet werden, unter Unix/Linux enthält die spezielle Variable $? den Rückgabewert des letzten aufgerufenen Programms. Andere Betriebssysteme haben ähnliche Möglichkeiten; damit sind eigene Miniprogramme möglich, welche bestimmte Begrenzungen (von z.B. Batch- oder anderen Scriptsprachen) umgehen können. Sie sollten daher immer Fehlercodes verwenden, um das Ergebnis auch anderen Programmen zugänglich zu machen.