Inhalt:

• Funktionen - Teil 2
  • Prototypen
  • Die main()-Funktion (Teil 1)
  • Ein Paar andere Dinge zu Funktionen
  • Rekursion & Iteration
• Wie geht's weiter?

Funktionen - Teil 2

Prototypen

Ein anderes Anwendungsgebiet liegt bei (eigenen) Bibliotheken. Wenn du eine Sammlung von Funktionen geschreiben hast, und diese einem anderen Programmierer zur Verfügung stellen willst, muss dieser die Prototypen in sein Programm einfügen. (z.B. mit einem header den du dann via "#include" einbeziehst...   (Außerdem entweder die "*.cpp"-Datei mitkompilieren oder die (von dir) mitgegebene Bibliotheken-Object-Datei dazulinken!) Siehe dazu auch: Andere Bibliotheken benutzen. Wenn wir andere Bibliotheken nutzen / eigene Bibliotheken schreiben, werde ich allerdings sowieso darauf zurückkommen!

int quadrat(int);   //Prototyp
 
//Noch ein Prototyp:
int quadrat(int i); //Name des Parameters
//kann angegeben werden, muss aber nicht...
 

Die main()-Funktion (Teil 1)

int main();
int main(int argc); //Selten, aber möglich
int main(int argc, char *argv[]);
int main(int argc, char *argv[], char *env[]);
 //Sehr selten, nur auf einigen Systemen sinnvoll
 
/*
argc               ist die Anzahl der Parameter.
argv[0]            ist das, was der Nutzer getippt hat,
                   um das Programm zu starten.
argv[1 bis argc-1] speichert die Parameter.
env[]              speichert die Environment-Variablen.
*/
 

argc=3 argv[0]="demo.exe" argv[1]="--test" argv[2]="--help"

Um die Parameter (mit Ausnahme von "argc" zu benutzen, musst du wissen, wie man in C(++) mit Buchstaben, Wörtern und Sätzen umgeht... Das ist allerdings erst das Thema des Dritten großen Teils! (s. linke Spalte - Kommt ja bald!!! ;) ). Ich werde dann nocheinmal darauf zurückkommen, wie man mit diesen Parametern arbeiten kann...

Ein Paar andere Dinge zu Funktionen

• Funktionen müssen immer außerhalb einer anderen, wie der main() Funktion definiert werden!
• Sie sollten, wie auch Variablen, einen sinnvollen Namen bekommen
• Man kann mehrere Funktionen mit dem gleichen Namen schreiben, solange ihre Parameter sich voneinander durch Anzahl oder Typ unterscheiden. Dies nennt man "Überladen", oder "Polymorphie" ("Vielgestaltigkeit"). Der Rückgabewert ist beim Überladen übrigens egal! Nur sich unterscheidende Rückgabetypen können nicht zur Unterscheidung genutzt werden!

  bool saghallo()
  void saghallo(int i)
  int saghallo(float f)
   
  //aber nicht:
  int test()
  void test()
  float test()
   

• Rekursion: Rekursive Funktionen sind Funktionen, die sich immer wieder mit veränderten Parametern aufrufen. Gleich mehr... (nächster Abschnitt!)
• Default-Parameter: Wenn du einem Parameter innerhalb des Prototypen/des Funktionskopfes einen Wert zuweist, kann dieser beim Funktionsaufruf weggelassen werden. Geschieht dies, so wird der Standardwert genommen, den du festgelegt hast. Wichtig: Solche default-Parameter dürfen nur am Ende stehen, normale Parameter dürfen dann nicht mehr folgen, damit die Reihenfolge nicht durcheinander gebracht wird. Weitere default-Parameter dürfen folgen, allerdings kann nicht der vorletzte Parameter weggelassen werden, der letzte aber nicht...!
  

  int test1 (int i=0);               //Geht
  int test2 (int i=0, int k);        //Geht nicht
  int test3 (int i, int k=5);        //Geht
  int test4 (int i=0, int k=9);      //Geht
   
  //  [...]
   
  test1();            //Geht: i=0
  test1(3);           //Geht: i=3
   
  test3(2);           //Geht: i=2, k=5
  test3(2,-19);       //Geht: i=2, k=-19
   
  test4();            //Geht: i=0, k=9
  test4(1);           //Geht: i=1, k=9
  test4(-19,8);       //Geht: i=-19, k=8
   
  test4(/*nur k angeben woll*/); //Geht nicht
   

• static: Lokale Variablen, die ihren Wert nach Verlassen einer Funktion bis zum nächsten Aufruf behalten, nennt man "static": "static int beispiel;"
• Es gibt auch "inline"-Funktionen: Inline Funktionen werden automatisch an alle Stellen kopiert, wo sie vorkommen. Dadurch wird Speicher (RAM) gespart (Der Computer muss sich nicht merken, von wo er die Funktion aufgerufen hat!) und die binäre, ausführbare Datei größer. Daher nutzt man sie meist bei kleinen, kurzen Funktionen, da sie "inline" schneller sind, aber die Übersichtlichkeit von Funktionen bleibt! Inlinefunktionen werden mit dem Wort "inline" gekennzeichnet, aber ganz normal aufgerufen:

  inline int saghallo() {/*...*/};
   

Rekursion & Iteration

Rekursive Funktionen sind Funktionen, die sich immer wieder mit veränderter Parameteranzahl aufrufen.

Rekursiv	Iterativ
int fak_rek(int zahl) { if (zahl<=1) //Abbruchbedingung, // welche nur einen // Wert zurückgibt, { // aber die nicht mehr return 1; // sich selbst (Funktion) } //aufruft...   return (fak_rek(zahl-1)*zahl); //Aufruf mit ver&auml;nderten Parametern }	int fak_iter(int zahl) { int fakult=1; int faktor=2; while (faktor<=zahl) //Schleife { fakult*=faktor; faktor++; } return fakult; }
Die rekursive Funktion läuft (kaum merklich) langsamer, da der Computer sich den Punkt merkt, von dem er eine Funktion aufruft, um dorthin zurückzukehren. Daher kommt es hier bei SEHR großen Anwendungen zu Abstürzen (kein Arbeitsspeicher etc.):

Wie geht's weiter?