Programmierung mit C - LUIS · Programmiersprache C | 16.03.07 | Folie 3 Regionales Rechenzentrum für Niedersachsen Beispiel Eine Funktion ist für die Eingaben des Benutzers zuständig

Regionales Rechenzentrum für Niedersachsen

Programmierung mit C

Funktionen

Programmiersprache C | 16.03.07 | Folie 2Regionales Rechenzentrum für Niedersachsen

Funktionen

... sind Unterprogramme (Subroutinen), mit denen Sie Teilprobleme einer größeren Aufgabe lösen können.

... fassen Anweisungen zu einem Block zusammen, der eine bestimmte Aufgabe löst.

Jeder dieser Blöcke hat einen eindeutigen Namen. Mit Hilfe dieses Namens wird eine Funktion aufgerufen.

Jede Funktion ist unabhängig. Sie kann nur Werte von anderen Funktionen übergeben bekommen und diese unabhängig weiterverarbeiten.

... können einen Wert an das aufrufende Programm zurückgeben.


Beispiel

Eine Funktion ist für die Eingaben des Benutzers zuständig. Eine weitere Funktion berechnet aus den Eingaben einen bestimmten

Wert. Eine Funktion ist für die Ausgabe des berechneten Wertes zuständig. Eine Funktion ist für die Fehlerbehandlung zuständig. Alle Funktionen werden über die Hauptfunktion aufgerufen.


Vorteile bei der Verwendung von Funktionen

Die Aufgabenstellung wird in kleinere unabhängige Module eingeteilt und somit auch strukturiert

Der Quellcode lässt sich besser lesen. Der Code einer Funktion kann in anderen Programmen wiederverwendet

werden. Wiederholende Aufgaben werden in einer eigenständigen Funktion

eingeschlossen. Diese Funktion kann von verschiedenen Stellen im Programm aufgerufen werden.

Fehler lassen sich schneller finden, weil der Code nur an einer Stelle bearbeitet werden muss.

Veränderungen lassen sich einfacher vornehmen und testen, weil nur Codefragmente betroffen sind.


Arbeitsweise einer Funktion

In einer Funktion wird eine bestimmte Aufgabe gelöst. Der Nutzer der Funktion muss nicht wissen, wie die Aufgabe gelöst wird. Dem Nutzer genügt es zu wissen, wie die Funktion aufgerufen wird. Die Funktion ist eine Blackbox.

Der Funktion können Werte übergeben werden. Dem Nutzer der Funktion muss die Art / Typ der Werte bekannt sein. Einige Funktionen besitzen keine Eingabeparameter.

Die Lösung der Aufgabe kann an den Aufrufer zurückgegeben werden. Nicht jede Funktion besitzt Rückgabeparameter.

Funktion

Eingabe-parameter

123

Rückgabe-parameter

146


Beispiel

#include <stdio.h>int mal;void eingabe (void) {

printf("Bitte geben Sie eine Zahl ein: ");scanf("%Ld", &mal);

}void ausgabe (int wert) {

printf("Ergebnis: %Ld\n", wert);}int main(void) {

int zahl;eingabe();zahl = mal * 10;ausgabe(zahl);return 0;

}


Beispiel






}

Hier wird eine Zahl von der Tastatur eingelesen.Die Funktion gibt keinen Wert zurück und bekommt keinen Wert übergeben.


Beispiel






}

Das Ergebnis der Berechnung wird auf dem Bildschirm ausgegeben.Die Funktion gibt keinen Wert zurück, bekommt aber einen Integer-Wert übergeben.


Beispiel






}

Die Funktion main muss in jedem C-Programm vorhanden sein. Diese Funktion wird immer als erstes aufgerufen. Über diese Funktion können andere Funktionen aufgerufen werden.Der Hauptfunktion main wird kein Wert (gekennzeichnet mit void) übergeben, aber sie gibt einen Integer-Wert an das Betriebssystem zurück.


Darstellung als Flussdiagramm

eingabe

ausgabe

zahl = eingabe * 10

main eingabe

scanf()

ausgabe

printf("Ergebnis“)


Darstellung als Struktogramm

eingabe()

zahl = eingabe * 10

ausgabe(zahl)

int main(void)

scanf()

void eingabe(void)

printf(zahl)

void ausgabe(int)


Aufbau von Funktionen

Funktionen selber bestehen aus ... dem Funktionskopf, der die Schnittstelle zum Aufruf darstellt. ... dem Funktionsrumpf, der die Variablen und Anweisungen enthält, die zur

Funktion gehören. Funktionen selber dürfen nicht verschachtelt werden. Eine Funktion

kommt nicht innerhalb einer anderen Funktion vor. Eine Funktion kann nur innerhalb einer Funktion aufgerufen werden.

int main(void) {


}

Funktionskopf

Funktionsrumpf


Funktionskopf

Funktionstyp FktName (Argument1, Argument2,..., ArgumentN) Funktionstyp legt den Datentyp des Rückgabewerts fest.

Der Datentyp legt den Bauplan für den Wert fest, den die Funktion zurückgibt.

Wenn die Funktion keinen Rückgabewert besitzt, wird void genutzt. Es kann jeder in C bekannter Datentyp für die Rückgabe genutzt werden.

Fktname ... ist eine eindeutige Bezeichnung. ... wird für den Aufruf der Funktion benötigt.

Argumente (Übergabewerte) ... werden in runden Klammern zusammengefasst. Die einzelnen Argumente werden durch Kommata getrennt. Jedes Argument besteht aus dem Datentyp und einem Variablennamen.

Beispiel: funktion(int zahl, float wert). Sie können eine beliebige Anzahl von Argumenten übergeben. Wird kein Argument übergeben, wird zwischen die Klammern void oder

nichts geschrieben.


Name einer Funktion

Der Name einer Funktion besteht aus den Zeichen a ... z, A ... Z und den Ziffern 0 ... 9. Im Funktionsnamen kann der Unterstrich genutzt werden.

Als erstes Zeichen muss ein Buchstabe oder der Unterstrich gewählt werden.

Funktionsnamen beginnen häufig mit Großbuchstaben. Die Bezeichnungen Summe() und summe() sind unterschiedlich. Die

Namen der Funktion sind case-sensitiv. Alle Namen sollten aus einem bestimmten Sprachraum kommen. Funktionsnamen, die in den Standardbibliotheken vorkommen, sollten

nicht für benutzerdefinierte Funktion genutzt werden.


Beispiele für Funktionsnamen

Wenn das Ergebnis der Funktion beschrieben werden soll, werden häufig Substantive genutzt. Mittelwert(), Integral(), TuermeVonHanoi().

Falls logische Operationen beschrieben werden, nutzen Funktionsnamen als erstes Wort Adjektive. kleinsterWert(), groessterMesswert().

Falls Funktionen keinen Rückgabewert liefern und die Aktion der Funktion beschrieben werden soll, werden häufig Substantive genutzt. FehlerAusgeben(), setExponent(), Auswaehlen().


Funktionsrumpf

Ein Funktionsrumpf beginnt mit der geöffneten geschweiften Klammer und endet mit der geschlossenen geschweiften Klammer.

Die geschweiften Klammern begrenzen einen Block, in dem zusammengehörige Anweisungen stehen. Die Anweisungen in einem Funktionsrumpf werden für die Lösung einer bestimmten Aufgabe benötigt.

Wenn die geschlossene, geschweifte Klammer erreicht ist, ist die Funktion beendet. Es wird zum übergeordneten Programmteil zurückgesprungen.

Mit Hilfe der Anweisung return (Wert); kann eine Funktion einen Wert an den übergeordneten Programmteil zurückgeben.


Beispiel

Der Name CalcProduct ist die Bezeichnung der Funktion. Mit Hilfe diesen Namens wird die Funktion aufgerufen.

double ist der Funktionstyp der Funktion CalcProduct. Die Funktion gibt Werte von diesem Datentyp an den Aufrufer zurück.

Im Funktionsrumpf werden zwei Werte multipliziert. Das Ergebnis der Multiplikation wird mit Hilfe von return an den

Aufrufer zurückgegeben.

double CalcProduct(int wert, float zahl) {

double ergebnis;ergebnis = wert * zahl;return ergebnis;

}


return-Anweisung

... gibt das Ergebnis, welches in der Funktion berechnet wurde, an den Aufrufer zurück.

... beendet die Funktion und es wird an die Position des Aufrufs zurückgesprungen.

... kann an jeder beliebiger Stelle in einer Funktion auftreten. Häufig steht sie am Ende einer Funktion.

... kann zum Beispiel in Abhängigkeit einer Bedingung mehrfach vorkommen.


Aufruf einer Funktion

Rückgabewert = Funktionsname ( Arg1, Arg2, ..., ArgN) Mit Hilfe des Funktionsnamens wird eine Funktion aufgerufen. Eine Funktion muss vor dem Aufruf definiert werden. In den runden Klammern werden die zu übergebenen Parameter

aufgeführt. Die Parameter in der Argumentliste des Aufrufs müssen denselben Datentyp

wie die Argumente im Funktionskopf besitzen . Beide Argumentlisten müssen dieselbe Anzahl von Parametern besitzen. Wenn keine Parameter übergeben werden, bleiben die runden Klammern

leer. Der Rückgabewert einer Funktion kann mit Hilfe eines

Gleichheitszeichen einer Variablen zugewiesen werden. Die Variable hat den gleichen Datentyp wie der Rückgabewert. Der Typ des Rückgabewertes wird durch den Funktionstyp angegeben.


Beispiel

double CalcProduct (int wert, float zahl) {double ergebnis;ergebnis = wert * zahl;return ergebnis;

}int main(void) {

const int zahl = 3;const float wert = 4.5;int uebergabe;uebergabe = CalcProduct(zahl, wert);return 0;

}


Funktionsprototypen

Funktionsprototypen werden dazu genutzt, Funktionen vor dem Aufruf und vor ihrer Definition zu deklarieren. Prototypen bestehen aus dem Funktionskopf, der mit einem Semikolon

abgeschlossen wird. In der Argumentliste wird nur der Datentyp der übergebenen Variablen

angegeben. Der Name der Übergabevariablen wird nicht benötigt. Prototypen stehen häufig am Anfang eines C-Programms, um eine doppelte

Vergabe von Funktionsnamen zu vermeiden. Mit Hilfe des Prototypen

... wird dem Compiler mitgeteilt, dass eine Funktion mit dem angegebenen Namen existiert.

... werden die Eigenschaften der Funktion festgelegt. Für die main()-Funktion wird kein Prototyp benötigt. Die Hauptfunktion

ist dem Compiler im Aufbau bekannt.


Beispiel

#include <stdio.h>int mal;void eingabe(void);void ausgabe(int);int main(void) {

...return 0;

}void eingabe (void) {

...}void ausgabe (int wert) {

...}

Funktionen

Prototypen


Beispiel

double myRechnung(int, float);int main(void) {

const int zahl = 3;const float wert = 4.5;int uebergabe;uebergabe = myRechnung(zahl, wert);return 0;

}double myRechnung (int wert, float zahl) {

double ergebnis;ergebnis = wert * zahl;return ergebnis;

}

Prototyp für die unten aufgeführteFunktion


Variablen

... können ... innerhalb eines Blocks definiert werden. Diese Variablen werden als lokal

bezeichnet. Sie sind nur innerhalb dieses Blocks gültig und bekannt. ... am Anfang des Programms definiert werden. Diese Variablen werden als

global bezeichnet. Diese Variablen sind im gesamten Programm bekannt. ... als statische Variablen definiert werden. Diese Variablen behalten auch

nach dem Verlassen des Blocks ihren Wert. ... sollten so lokal wie möglich und so global wie nötig angelegt werden.


Lokale Variablen

Alle lokalen Variablen in dem neben stehenden Beispiel sind mit kursiver blauer Schrift geschrieben.

Lokale Variablen werden innerhalb eines Blocks definiert. Ein Block ist immer durch die geschweiften Klammern begrenzt.

Sobald ein Block betreten wird, wird die Variable immer wieder neu angelegt. Wird der Anweisungsblock verlassen, wird die Variable aus dem Speicher gelöscht. Das heißt, eine Variable lebt nur so lange wie der Block abgearbeitet wird.

Die Variable ist nur innerhalb eines Blocks bekannt.

int main(void) {int zahl;int mal;………return 0;

}void berechne() {

int zahl;int mal;…………

}


Identische Namen

In jedem Block kommt ein Variablenname exakt einmal vor.

Jeder Variablenname ist ein Stellvertreter für eine Speicherzelle im Arbeitsspeicher. Die Speicherzelle wird freigegeben, sobald der Block verlassen wird.

Aus diesen Grund können in verschiedenen Blöcken identische Namen genutzt werden. Zur besseren Lesbarkeit und Verständlichkeit können unterschiedliche Namen verwendet werden. Beispiel: mainFaktor in dem Hauptprogramm und

potenzierenFaktor in der Funktion ptoenzieren.

preisBrutto und preisNetto für die Kennzeichnung von Beträgen mit und ohne Steuern.

int main(void) {int zahl;int mal;………

for(...){ int zahl; }

return 0;}berechne() {


}


Globale Variablen

int globVar;

int main(void){int zahl;int mal;………return 0;

}berechne() {


}

... werden außerhalb einer Funktion definiert. Meist werden Sie am Anfang eines Programms definiert.

... gelten für das gesamte Programm. ... können von allen Funktionen in einem

Programm genutzt werden. Eine lokale Variable, die den selben Namen

wie eine globale Variable hat, hat Vorrang vor der globalen Variablen.

Überlegen Sie sich genau, welche Variablen global gehalten werden sollten. Variablen, die selten oder nur in bestimmten Funktionen benötigt werden, sollten lokal gehalten werden.

Bei der objektorientierten Programmierung wird auf globale Variablen verzichtet. Daher sollte man schon in C von deren Verwendung absehen.


Beispiel

int ergebnis;int potenzieren(int, int);int main(void){

int faktor;int potenz;faktor = 3;potenz = 3;ergebnis = 1;ergebnis = potenzieren(faktor, potenz);return 0;

}int potenzieren(int faktor, int potenz){

int ergebnis;int count;for(count = 1; count <= potenz; count++){

ergebnis = ergebnis * faktor;}return ergebnis;

}

undefiniert

ergebnis (global)

1

undefiniert

faktor (lokal)

33

faktor (lokal)

3

potenz(lokal)

3

faktor (lokal)

3

potenz(lokal)

1

count (lokal)

undefiniert

ergebnis (lokal)

ergebnis * faktor

2


Existenz und Sichtbarkeit

Bei einem Aufruf einer Funktion werden für alle lokalen Variablen neue Speicherzellen reserviert. Nach dem Ende der Funktion wird der Speicher wieder freigegeben. Die lokale Variable ist innerhalb der Funktion existent und sichtbar.

Globale Variablen werden am Anfang eines Programms deklariert. Für globale Variablen wird am Anfang eines Programms Speicher bereitgestellt und am Ende des Programms freigegeben. Sie sind während der Laufzeit des Programms für alle Funktionen existent.

Wenn eine lokale Variable in einem Block und eine globale Variable identische Namen besitzen, überdeckt die lokale Variable die globale Variable in diesem Block. Die globale Variable ist in diesem Block nicht sichtbar.


Statische Variablen

... bezeichnen immer dieselbe Speicherzelle, egal wie oft eine Funktion aufgerufen wird.

... sind nur innerhalb der Funktion sichtbar, in der sie deklariert werden.

... behalten auch nach dem Verlassen der Funktion den zugewiesenen Wert.

... können global oder lokal sein.

... müssen wie Konstanten schon bei ihrer Deklaration initialisiert werden.

int main(void) {………return 0;

}int berechne(int faktor) {

int ergebnis; static int zahl = 1; ergebnis = faktor * 3;

zahl++;return ergebnis;

}


Speicherklassen

Beschreibung

extern

Speicher- klasse auto Diese Speicherklasse ist der Vorgabewert jeder Variablen. Ist keine

Speicherklasse vereinbart, so gilt auto. Die Variablen sind nur innerhalb des vereinbarten Blocks { } gültig. Nach dem Verlassen des Blocks wird die Variable gelöscht. Ablage: Stack.

static Die Variable wird über die Laufzeit der Funktion erhalten und steht beim nächsten Funktionsaufruf wieder zur Verfügung. Ablage: DatensegmentDie Variable ist schon an anderer Stelle definiert und angelegt worden. Falls Programme aus mehreren Modulen zusammengesetzt werden, wird diese Speicherklasse benötigt.

register auto-Variable, die nach Möglichkeit im Register der CPU abgelegt wird. Moderne Compiler optimieren oft selber die Zuordnung von CPU-Registern zu Variablen


Funktionen und Module

#include <stdio.h> int frage (int);int zahl;

void main (void){ int wert = 2; int result; wert = 2; result = frage (wert); result = frage (zahl);}

Funktion

Modul


Variablen in Funktionen und Module

#include <stdio.h> int frage (int);int zahl;

void main (void){ int wert = 2; int result; wert = 2; result = frage(wert); result = frage(zahl);}

Diese Variable gilt für das gesamte Modul.Die Variable kann in jeder Funktion in dem Modul genutzt werden.Die Variable ist global für das Modul.

Diese Variablen sind innerhalb der Funktion main() definiert.Diese Variablen gelten nur für diese Funktion. Sie sind lokal.In anderen Funktionen können diese Variablen nicht genutzt werden.


Variablen in Funktionen

#include <stdio.h>int frage (int eingabe){ int rueckgabe; printf ("\n\nEs wurde der Wert %d uebergeben",eingabe); printf ("\nBitte einen Integerwert, z.B. 2 : "); scanf ("%d",&rueckgabe); if(rueckgabe > 10){ int result; result = -1; printf ("\n...ist groesser als 10? %d \n\n", result); } return rueckgabe; }

Diese Variable ist innerhalb der Funktion definiert.Diese Variablen gelten nur für diese Funktion. Sie sind lokal.In anderen Funktionen können diese Variablen nicht genutzt werden.

Diese Variable ist nur innerhalb des Blocks bekannt.Der Block beginnt und endet mit den geschweiften Klammern.Diese Variable ist nur lokal in diesem Block gültig.


Lokale, globale und statische Variablen


Parameter übergeben

Wertparameter ("call by value"): Der Wert einer Variablen wird an eine Funktion übergeben. Es wird eine Kopie der Variablen erzeugt, die übergeben werden soll. Die Funktion hat nur Zugriff auf die Kopie, aber nicht auf das Original. Es ist nur eine Übergabe von Werten möglich. Die Argumentliste einer Funktion besteht aus Wertparameter, die mit

Hilfe von Kommata getrennt werden.

Referenzparameter ("call by reference"): Die Adresse einer Variablen wird übergeben. Als Referenz wird die Speicheradresse einer Variablen bezeichnet. Die Funktion greift direkt auf das Original zu. Über eine Referenz können Werte übergeben und zurückgegeben

werden. In C ist diese Art der Übergabe mit Hilfe von Zeigern implementiert.

(Wird später behandelt).


"call by value"

#include <stdio.h>void MyFunction(int wert);int main(void){ int zahl; zahl = 3; MyFunction(zahl); return 0;}void MyFunction(int wert){ wert = wert * 10;}

wert

zahl

3

undefiniert3

30


"call by reference"

#include <stdio.h>void MyFunction(int wert);int main(void){ int zahl; int *wert; zahl = 3; wert = &zahl; *wert = *wert * 10; return 0;}

undefiniert zahl

undefiniert wert

3

Adresse von zahl

30


Hauptfunktion main(void)

Genau eine Funktion in einem Programm muss den Namen main() tragen.

Diese Funktion wird beim Programmstart als erstes ausgeführt. Nach dem C89-Standard kann die Hauptfunktion den Funktionstyp void

besitzen. Nach C99-Standard gibt die Hauptfunktion int zurück. Mit Hilfe der Anweisung return 0; teilt die Hauptfunktion dem

Betriebssystem mit, dass das Programm ordnungsgemäß beendet wurde.Fehlermeldungen haben eine Nummer, die die Meldung eindeutig identifiziert. Die Fehlernummern sind größer oder kleiner als 0. Aus diesen Grund wird eine Null bei einer fehlerfreien Ausführung des Programms zurückgegeben.


Programmausführung

Aus dem Betriebssystems heraus wird das Programm eines Anwenders aufgerufen.Für das Betriebssystem ist die Anwendung ein Unterprogramm, das nach der Beendigung an die aufrufende Stelle des Betriebssystems zurückkehrt.


Programmausführung

Das Hauptprogramm kann weitere Unterprogramme aufrufen, die nach der Beendigung zu dem übergeordneten Programm zurückkehren.Ein Sprung in ein Unterprogramm kann von beliebiger Stelle beliebig oft erfolgen.


Stacks und Queues

Ein Stack ist ein Speicherbereich, bei dem die zuletzt eingetragenen Daten zuerst wieder ausgelesen werden. Man verwendet hier auch den Begriff LIFO-Speicher (Last in, first out).

Eine Queue ist ein Speicherbereich bei dem die zuerst geschriebenen Daten zuerst wieder ausgelesen werden. In diesem Fall spricht man von einem FIFO-Speicher (First in, First out).


Stacks und Queues

Stack Queue

ein einaus

aus

Information Information

Stack-pointer


Unterprogramme

Häufig benutzte Softwareroutinen können in Form von Unterprogrammen realisiert werden.

Der Prozessor verwendet hierzu den Call-Befehl. Dieser Befehl sorgt dafür, dass die Adresse des Befehls nach dem Call-

Befehl auf den Stack geschrieben wird. Nach Abarbeitung der Routine wird mit dem RET-Befehl (Return from

Subroutine) die Rücksprungadresse vom Stack geholt und die Programmabarbeitung fortgesetzt.


Unterprogrammaufruf

Hauptprogramm UnterprogrammBefehl 1;Befehl 2;CALL UP1Befehl 4;Befehl 5;Befehl 6;Befehl 7;....

UP1:Befehl1Befehl2Befehl3RET

$100$102$104$106$108$10A$10C Stackp.

vor UP-Aufr106

$200$202$204$206

Stackp.während UP-Aufr


Ablauf Unterprogrammaufruf

Es wird das Programm ab Adresse 100 abgearbeitet Auf Adresse 104 steht der Unterprogrammaufruf CALL UP1, welcher

das Unterprogramm UP1 aufruft Der Prozessor schreibt die Adresse des Befehls, die nach dem

Unterprogrammaufruf steht (Befehl 4 auf Adresse $106) auf den Stack. Der Stackpointer wird auf die nächste freie Speicherstelle im Stack

gesetzt. Der Programmzähler wird mit der Adresse des Unterprogramms geladen

($200) und die Abarbeitung fortgesetzt. Am Ende des Unterprogramms steht der Befehl RET (Return from

Subroutine). Dieser Befehl bewirkt, dass der Stackpointer um ein Datenwort erhöht wird und die Adresse vom Stack als neuer PC geladen wird.


Geschachtelter Unterprogrammaufruf

Hauptprogramm Unterprogramm 1 Unterprogramm 2Befehl 1;Befehl 2;CALL UP1Befehl 4;Befehl 5;Befehl 6;Befehl 7;....

UP1:Bef1Befehl2CALL UP2Befehl3RET

$100$102$104$106$108$10A$10C vor UP-Aufr. 106

$200$202$204$206$208

Währ UP1-Aufr.

$210$212$214$216

UP2:Bef1Befehl2Befehl3Befehl4RET

Stack

206Währ UP2-Aufr.


Geschachtelte Unterprogramme

In Unterprogrammen können wiederum Unterprogramme aufgerufen werden.

Es läuft wiederum der gleiche Vorgang ab: Die Rücksprungadresse wird auf den Stack geschrieben. Es wird in das zweite Unterprogramm verzweigt.

Am Ende des Unterprogramm wird in das aufrufende Programm zurückgekehrt.

Durch die LIFO-Struktur des Stacks kehrt das Programm jeweils an die aufrufende Stelle zurück.

Bei entsprechend großem Stack-Speicherbereich lassen sich somit beliebig viele geschachtelte Unterprogrammaufrufe tätigen.


Ablage auf dem Stack

Der Stack ist dynamisch. Der Stack wächst automatisch zu der kleineren Speicheradresse hin und schrumpft wieder, falls die abgelegten Daten nicht mehr benötigt werden.

Der Stack arbeitet nach dem LIFO (Last in - First out) - Prinzip. Was zuerst auf dem Stack abgelegt wird, wird als erstes herausgegeben.

Für jede Funktion wird ein Datenblock auf dem Stack erstellt. Dieser Datenblock wird als Stack-Frame (Rahmen) bezeichnet. In einem Stack-Frame werden die folgende Daten gespeichert: Alle Argumente einer Funktion, ... alle lokalen, nicht-statischen Variablen, ... die Rücksprungadresse, ... Inhalte, die gesichert werden müssen, ... Rückgabewerte, falls vorhanden, und ... kurzfristig Zwischenergebnisse.


Bibliotheksfunktionen

... werden häufig als Systemfunktionen oder Runtime-Library bezeichnet. ... werden teilweise vom C-Standard definiert. Jeder Compiler kann aber

eigene Funktionen für die Maussteuerung etc. anbieten. ... werden einzeln gespeichert und sind fertig compiliert. ... sind fertig compiliert und liegen meist als Objektdateien vor. ... werden in Bibliotheken implementiert. Bibliotheksdateien haben die

Dateiendung ".lib" und sind im Verzeichnis C:\Pfad_zum_Compiler\Lib abgelegt. Die Bibliotheken werden meist zusammen mit dem Compiler oder Entwicklungsumgebung vertrieben.

Der Linker sucht nach eingebundenen Bibliotheksfunktionen und fügt den Code in das Programm ein.


Bibliotheksfunktionen deklarieren

Die Deklaration einer Bibliotheksfunktion ... steht in einer so genannten Header-Dateien. Der Prototyp einer Standard-Bibliotheksfunktionen ist normiert.

Die Funktion wird mit ihren Namen aufgerufen, bekommt manchmal Parameter übergeben und gibt teilweise einen Wert an den Aufruf zurück.


Header-Dateien

... fassen Funktionen zu einem bestimmten Thema zusammen. ... die Funktionen enthalten, die häufig benötigt werden, sind vordefiniert

und werden mit dem Compiler oder der Entwicklungsumgebung ausgeliefert. Sie befinden sich unter Windows meist im Verzeichnis C:\Pfad_zum_Compiler\Include und können mit Hilfe eines Texteditors oder IDE angesehen werden.

Mitgelieferte Header-Dateien können über #include<Name_der _Header-Datei> in das eigene Programm eingebunden werden.

Beispiele für vordefinierte Header-Dateien: math.h enthält mathematische Funktionen. time.h enthält Funktionen zur Datums- und Zeiterfassung. stdio.h enthält Funktionen zur Ein- und Ausgabe von Daten.


Rekursive Funktionen

... sind Funktionen, die sich selber aufrufen.

Jede Rekursion benötigt eine Abbruchbedingung.

Andernfalls kommt es zu einer Endlosschleife verbunden mit einem Stacküberlauf.

int Division (int wert, int zahl) {if ( wert >= zahl) {

return(1 + Division(wert - zahl, zahl)); } if ( wert != 0) {

printf("Rest %d\n", wert);}return 0;

}int main(void) {

int ergebnis; ergebnis = Division (7,2 );printf ("Ergebnis =%d\n", ergebnis);return 0;

}

Documents

Programmierung mit C - LUIS · Programmiersprache C | 16.03.07 | Folie 3 Regionales Rechenzentrum für Niedersachsen Beispiel Eine Funktion ist für die Eingaben des Benutzers zuständig