2. Funktionen - Prototypvereinbarung typangabe funktionsname(parameterliste); - Funktionsdefinition typ funktionsname(parameterliste){ Anweisung - Funktionstyp -> Typ der Funktionswertes zulaessige Typangaben elementare Datentypen void - Fkt. liefert keinen Funktionswert Struktur, Union Zeiger auf beliebige Objekte Bsp. nicht zulaessige Typangaben Felder Funktionen char f1(...); // f1 liefert 1 Zeichen bzw. Zahl char *f2(...); // f2 liefert Pointer auf Zeichen bzw. eine Zeichenkette struct element *f3(...); // f3 liefert Pointer auf Struktur vom Typ struct element Parameterliste typ funktionsname( typ1 parameter1, typ2 parameter2,...) char fkt1( char a[], int b); Funktion ohne Parameter Typ void leere Liste char fkt2 ( ); Typ void* aktuelle Parameter Pointer von beliebigem Typ 2.1. Parameter der main( ) - Funktion werden von der Shell an main( ) uebergeben int main( int argc, char **argv, char **envp ) // argc argument counter // argv argument vector
int main( int argc, char *argv[], char *envp[] ) 1. argc Anzahl der Kommandozeilenargumente >= 1 ( einschliesslich Kommandoname ) 2. Adresse eines Pointerfeldes argv[0] Zeiger auf Kommandoname argv[1] Zeiger auf 1. Argument argv[argc -1] Zeiger auf letztes Argument NULL Ende des Pointerfeldes 3. Adresse eines Pointerfeldes envp[0] Zeiger auf 1. Umgebungsvariable NULL Bsp. #include<stdio.h> int main( int argc, char **argv, char **envp){ int i=0, n; n= argc; while(n>0){ printf( %s \n, argv[argc-1]); n--; while(envp!= NULL) printf( %s \n, envp[i++]); return(0); 2.2. Parameter uebergabe - Typen sollten uebereinstimmen (wird eventuell nicht geprueft bzw. konvertiert) - Reihenfolge der Parameteruebergabe abhaengig vom Compiler (keine Abhaengigkeiten zw. einzelnen Parametern) z.b. fkt(i++, x[i]); // Wert von i vom Compiler abhaengig /* falls 2. Parameter zuerst uebergeben wird x[i] sonst x[i+1]*/ - Durchfuehrung der Parameteruebergabe - call by vallue // fuer C nur diese Art - call by references // fuer C++ - call by vallue bei Funktionsaufruf wird der Wert des aktuellen Parameters uebergeben ( in der aufgerufenen Funktion wird Kopie des aktuellen Parameters erzeugt ) - Funktion arbeitet mit Kopie es ist keine Aenderung am Original moeglich
- Rueckgabe von Ergebniswerten - Verwendung globaler Variablen s.u. - ueber Funktionswert return ( Ausdruck ); Wert des Ausdrucks = Funktionswert return Ausdruck; void Funktion return ; - Uebergabe der Adresse einer Variablen als Wertparameter int fkt3(int *a){ *a=1; // Zugriff auf Original return 0; Funktionsaufruf int x=0, y; y = fkt3 (&x); // Wert von x wird veraendert - Uebergabe von Vektoren (Variablenname = Adresse) int v[100],y; y = fkt3(v); // Adresse 1. Vektorelement entspr. &v[0] - Problem in Funktion keine Ermittlung der Anzahl der Elemente int fkt4( int *a){ sizeof(a); // Byteanzahl des Pointers!!! //Funktion zur Vektoreingabe int vein (int *a, int n ){ int i; for(i=0;i<n;i++){ scanf( %d, &a[i]) return(0); // Aufruf y= vein( v, sizeof(v) / sizeof( int ) );
2.3. Gueltigkeitsbereiche - call by reference int fkt5( int &n){ //Referenztyp n=1; // Zugriff auf Original return (0); - lokale Variablen // Aufruf y= fkt5(x); C -> Vereinbarung am Anfang eines Blocks ( {... ) - Standardspeicherklasse auto Variable wird bei Eintritt in den Block ( Funktionsaufruf ) erst angelegt Lebensdauer bei Blockende Freigabe der Variable Wert beleibt nicht erhalten ( Inhalt unbestimmt ) - Fehlerquelle bei Funktionen die als Funktionswert Pointer liefern struct element { char y[20]; float x; struct element x fkt1( ){ struct element a ; fgets( a.z, sizeof(a.z), stdin ); scanf( %f,&a.x); return &a; // Speicherplatz von a wird freigegeben // wird evtl. fuer andere auto Variable benutzt // -> Inhalt von a evtl. verfaelscht Aenderung der Lebensdauer -> - Speicherklasse static (fuer lokale Variablen ) static struct element a; // Variable bleibt nach der Funktion erhalten struct element { char y[20]; float x; struct element x fkt1( ){ static struct element a ; fgets( a.z, sizeof(a.z), stdin ); scanf( %f,&a.x);
return &a; // Speicherplatz von a wird nicht freigegeben // Variable bleibt nach der Funktionsende erhalten // Zugriff von aussen ueber Pointer moeglich Probleme bei Multithreading ( parallele Funktionsauffuerung )