====== Funktionszeiger ======

Definition des Funktionszeigetyps
<code c>
typedef int (*fncSum) (int, int);
</code>

Funktion für Summenbildung
<code c>
int sum(int a, int b){
    return a + b;
}
</code>

Implementierung
<code c>
void main() {
    fncSum mySum = &sum;
    printf( "%d\r\n" , (*mySum)( 1, 2 ));
}
</code>

===== Callback =====
Sehr nützlich sind Funktionszeiger für sogenannte **Callbacks**. Dabei wird zBsp. eine Funktion einer dynamisch geladenen //DLL// aufgerufen. Nehmen wir mal an, diese Funktion hat als Returnwert einen berechneten Integerwert, der über mehrere Operation ermittelt wird. Nun könnte man sich zwar die Zwischenergebnisse in einem Array über den Funktionsaufruf zurückgeben lassen - aber cooler ist doch - wenn man sich live bei der Berechnung die Ergebnisse anzeigen lassen kann und evtl. mit Zeitstempel usw. versehen kann. 

Als erstes schreiben wir mal unseren Typen für den Funktionszeiger. Dieser Typ muss später der Funktion **CalculateInteger** und dem Programm, wo die Funktion **CalculateInteger** genutzt wird bekannt sein. Es wäre also angebracht, diesen Typ in einer Headerdatei zu stecken - und diese bei Bedarf zu laden. Alternativ kann man die Definition auch an den einzelnen Stellen selbst einfügen ;).

<code c>
//Definition in der Datei mydqf.h
typedef int (*fncCalculateInteger) (int, int );
</code>

So, nun schreiben wir mal eine Funktion.. die so/oder so ähnlich eine Berechnung durchführen soll. Diese Funktion kann in einer Dll oder auch sonst wo rumliegen ;)

<code c>
//IrgendeineDll
#include "mydef.h"
int CalculateInteger(int input, fncCalculateInteger fnc){

    int tmp = 0;
    
    //Opertion 1
    tmp = input * 3.14159265359;
    if( fnc != NULL )
        fnc( 1, tmp );
    
    //Opertion 2
    tmp = tmp * tmp;
    if( fnc != NULL )
        fnc( 2, tmp );

    //Opertion 3
    tmp = tmp + tmp;
    if( fnc != NULL )
        fnc( 3, tmp );
    
    //Opertion 4
    tmp = tmp / tmp;
    if( fnc != NULL )
        fnc( 4, tmp );
    
    return tmp;
}
</code>

  * Die Funktion **CalculateInteger** nimmt als ersten Parameter einen Int-Wert entgegen, der zur Berechnung dienen soll.
  * Als zweiten Parameter erwartet die Funktion einen Funktionszeiger des Typs **fncCalculateInteger** oder eben **NULL**
Bei jeder Berechnung wird geprüft, ob der Funktionszeiger **NICHT** **NULL** und dementsprechend aufgerufen, mit dem Operationsschritt und dem Zwischenergebnis.


Nun kommen wir zum Nutzen des Callbacks.

<code c>
#include "mydef.h"

int tmp[4];

int myCallbackFunctionPrintOut( int step, int tmpCalc ){
    printf( "Schritt %d hat als Zwischenergebnis= %d\r\n", step, tmpCalc );
}

int myCallbackFunctionStoreCalc( int schritt, int zwCalc ) {
    tmp[schritt-1] = zwCalc;
}

int main(){
    //Lade der IrgendeineDll ....
    CalculateInteger( 5, &myCallbackFunctionPrintOut );
    CalculateInteger( 5, &myCallbackFunctionStoreCalc);
    return 0;
}
</code>

<code>
Ausgabe: 
Schritt 1 hat als Zwischenergebnis= 15
Schritt 2 hat als Zwischenergebnis= 225
Schritt 3 hat als Zwischenergebnis= 450
Schritt 4 hat als Zwischenergebnis= 1

Und das Array hat an den Indizes folgende Werte.
tmp[0] = 15
tmp[1] = 225
tmp[2] = 450
tmp[3] = 1
</code>