7.1 Definition und Deklaration

Zweck einer Funktion:

• Des öfteren wird ein Programmteil in anderen Programmabschnitten wieder benötigt. Um das Programm übersichtlicher und handhabbarer zu gestalten wird dieser Programmteil einmalig als Funktion programmiert und im restlichen Programm mit seinem Funktionsnamen aufgerufen.
• Bereits fertiggestellte Funktionen können für andere Programme anderer Programmierer zur Verfügung gestellt werden, analog zur Benutzung von pow(x,y) und strcmp(s1,s2) in § 3.6.

In der allgemeinen Form der Funktionsdefinition mit

<speicherklasse> <typ>  <funktions_name> (parameter_liste)
{
 <vereinbarungen>
 <anweisungen>
}

stellen Vereinbarungs- und Anweisungsteil den Funktionskörper dar und <typ> legt den Typ des Rückgabewertes fest. Die Kombination <funktions_name> und (parameter_liste) kennzeichnet eindeutig eine Funktion und wird daher als Signatur einer Funktion bezeichnet. Die Funktionsdefinition wird für jede Funktion genau einmal benötigt.

Im Unterschied dazu ist die Funktionsdeklaration

<speicherklasse> <typ> <funktions_name> (parameter_liste) ;

in jedem Quellfile nötig welches die Funktion <funktions_name> aufruft.

Struktogramm:

Beispiel: Wir schreiben die Berechnung von sgn(x) von Seite  als Funktion. (siehe Ex710.cc)

//	Demonstration of function declaration and definition

#include <iostream.h>

double sgn(double x);   // declare function sgn
...

main()
{
 double a,b;
 ...
 cin  >> a;

 b  = sgn(a);           // function call
 
 cout << "  sgn(" << a << ") = " << b << endl;
}

//--------------------------------------------- 

double sgn(double x)    // definition of function sgn
{
 double y;
 
 y = (x > 0 ? 1. : 0.) + (x < 0 ? -1. : 0.);
 
 return y;              // return value of function sgn
}

Bemerkungen: Die Funktion sgn() ist durch ihre Signatur eindeutig beschrieben. Dies hat für Deklaration und Definition von Funktionen die Konsequenzen:

(i).

Einige weitere (oder noch mehr) identische Funktionsdeklarationen

double sgn(double x);

sind in obigem Beispiel erlaubt.

(ii).

Zusätzliche Funktionsdeklarationen mit anderen Parameterlisten sind erlaubt, z.B.:

double sgn(double* x);
double sgn(int x);

da sich die Argumente von der Ausgangsdefinition unterscheiden. Allerdings haben wir diese neuen Funktionen noch nicht definiert.

(iii).

Eine zusätzliche Deklaration (siehe § 7.2)

double sgn(double& x);

ist nicht erlaubt, da die Signatur wie unter (i) ist. Daher kann der Compiler nicht herausfinden, ob die Funktion unter (iii) oder die Funktion unter (i) in der Anweisung

y = sgn(x);

gemeint ist.

(iv).

Verschiedene Funktionen mit gleichem Namen werden anhand ihrer unterschiedlichen Parameterlisten identifiziert, siehe Pkt. (iii).

(v).

Der Rückgabewert einer Funktion kann nicht zu ihrer Identifikation herangezogen werden, die Deklarationen

double sgn(int x);
int sgn(int x);

können nicht unterschieden werden (gleiche Signatur) und daher lehnt der Compiler diesen Quelltext ab.